【2023.9.16获奖项目】基于迪文屏的DE-RTOS第一篇Shell

dwinForumAdmin

【开源】重磅！基于迪文屏的DE-RTOS第一篇Shell

1.背景介绍

迪文屏的开发者非常的多，但是迪文没有一个很好的生态系统，像国产RTThread一样，拥有多种组件，多种传感器，能够快速的实现产品开发，为此我设计了一款基于C51的DE-RTOS，希望能成为迪文的操作系统之一。
该系统是参考RTThread的文件结构，也为了后续方便移植RTThread的各种组件和软件包，RTThread的系统框架如下图所示：

2.设计难点

目前基于C51的操作系统不多，RTX51系列是不开源的，所以C51的任务跳转也是比较难实现的，我也在找各种方法，后续还准备设计一款类似STM32CubeMX的图形配置软件，可以直接通过图形化进行外设、组件和软件包的配置，这个软件周期也会比较长，需要先完善DE-RTOS之后再去设计图形化配置软件。下面是STM32CubeMX的软件界面：

3.代码设计

（1）需要设计好文件框架，我是直接参考RTThread的文件框架，同时添加上一些迪文和自己的内容，文件框架如下图所示：

（2）接下来就是移植Shell，在移植Shell的时候，其实就移植了一部分的RTThread，这部分移植还是挺复杂的，需要对串口数据进行FIFO的处理，然后再进行解码，根据解码的结果去调用合适的函数。调用函数用到了函数指针，这样就可以根据字符串的内容去执行相关函数，同时还可以传递数据。大概贴一下Shell函数解析的代码：

1. <font size="3" face="宋体">void shell_task_entry()
   
2. {
   
3.     static uint8_t frist_flag = 0;
   
4.     char ch = 0;
   
5.     int8_t ret = 0;
   
6. 
   
7.     if(frist_flag == 0)
   
8.     {
   
9.         frist_flag = 1;
   
10.         shell.echo_mode = 1;
    
11.         printf(FINSH_PROMPT);
    
12.     }
    
13. 
    
14. 
    
15.     //while(1)
    
16.     {
    
17.         
    
18.         ch = de_hw_console_getchar();
    
19.         if(ch == 0)
    
20.         {
    
21.             return;
    
22.         }
    
23.             
    
24.         // printf("%c", ch);
    
25. 
    
26.         /*
    
27.          * handle control key
    
28.          * up key  : 0x1b 0x5b 0x41
    
29.          * down key: 0x1b 0x5b 0x42
    
30.          * right key:0x1b 0x5b 0x43
    
31.          * left key: 0x1b 0x5b 0x44
    
32.          */
    
33.         if (ch == 0x1b)
    
34.         {
    
35.             shell.stat = WAIT_SPEC_KEY;
    
36.             return;
    
37.         }
    
38.         else if (shell.stat == WAIT_SPEC_KEY)
    
39.         {
    
40.             if (ch == 0x5b)
    
41.             {
    
42.                 shell.stat = WAIT_FUNC_KEY;
    
43.                 return;
    
44.             }
    
45. 
    
46.             shell.stat = WAIT_NORMAL;
    
47.         }
    
48.         else if (shell.stat == WAIT_FUNC_KEY)
    
49.         {
    
50.             shell.stat = WAIT_NORMAL;
    
51. 
    
52.             if (ch == 0x41) /* up key */
    
53.             {
    
54. #ifdef FINSH_USING_HISTORY
    
55.                 /* prev history */
    
56.                 if (shell.current_history > 0)
    
57.                     shell.current_history --;
    
58.                 else
    
59.                 {
    
60.                     shell.current_history = 0;
    
61.                     return;
    
62.                 }
    
63. 
    
64.                 /* copy the history command */
    
65.                 memcpy(shell.line, &shell.cmd_history[shell.current_history][0],
    
66.                        FINSH_CMD_SIZE);
    
67.                 shell.line_curpos = shell.line_position = strlen(shell.line);
    
68.                 shell_handle_history(&shell);
    
69. #endif
    
70.                 return;
    
71.             }
    
72.             else if (ch == 0x42) /* down key */
    
73.             {
    
74. #ifdef FINSH_USING_HISTORY
    
75.                 /* next history */
    
76.                 if (shell.current_history < shell.history_count - 1)
    
77.                     shell.current_history ++;
    
78.                 else
    
79.                 {
    
80.                     /* set to the end of history */
    
81.                     if (shell.history_count != 0)
    
82.                         shell.current_history = shell.history_count - 1;
    
83.                     else
    
84.                         return;
    
85.                 }
    
86. 
    
87.                 memcpy(shell.line, &shell.cmd_history[shell.current_history][0],
    
88.                        FINSH_CMD_SIZE);
    
89.                 shell.line_curpos = shell.line_position = strlen(shell.line);
    
90.                 shell_handle_history(&shell);
    
91. #endif
    
92.                 return;
    
93.             }
    
94.             else if (ch == 0x44) /* left key */
    
95.             {
    
96.                 if (shell.line_curpos)
    
97.                 {
    
98.                     printf("\b");
    
99.                     shell.line_curpos --;
    
100.                 }
     
101. 
     
102.                 return;
     
103.             }
     
104.             else if (ch == 0x43) /* right key */
     
105.             {
     
106.                 if (shell.line_curpos < shell.line_position)
     
107.                 {
     
108.                     printf("%c", shell.line[shell.line_curpos]);
     
109.                     shell.line_curpos ++;
     
110.                 }
     
111. 
     
112.                 return;
     
113.             }
     
114.         }
     
115. 
     
116.         /* received null or error */
     
117.         if (ch == '\0' || ch == 0xFF) return;
     
118.         /* handle tab key */
     
119. #ifdef FINSH_USING_SYMTAB
     
120.         else if (ch == '\t')
     
121.         {
     
122.             int i;
     
123.             /* move the cursor to the beginning of line */
     
124.             for (i = 0; i < shell.line_curpos; i++)
     
125.                 printf("\b");
     
126. 
     
127.             /* auto complete */
     
128.             shell_auto_complete(&shell.line[0]);
     
129.             /* re-calculate position */
     
130.             shell.line_curpos = shell.line_position = strlen(shell.line);
     
131. 
     
132.             return;
     
133.         }
     
134. #endif
     
135.         /* handle backspace key */
     
136.         else if (ch == 0x7f || ch == 0x08)
     
137.         {
     
138.             /* note that shell.line_curpos >= 0 */
     
139.             if (shell.line_curpos == 0)
     
140.                 return;
     
141. 
     
142.             shell.line_position--;
     
143.             shell.line_curpos--;
     
144. 
     
145.             if (shell.line_position > shell.line_curpos)
     
146.             {
     
147.                 int i;
     
148. 
     
149.                 de_memmove(&shell.line[shell.line_curpos],
     
150.                            &shell.line[shell.line_curpos + 1],
     
151.                            shell.line_position - shell.line_curpos);
     
152.                 shell.line[shell.line_position] = 0;
     
153. 
     
154.                 printf("\b%s  \b", &shell.line[shell.line_curpos]);
     
155. 
     
156.                 /* move the cursor to the origin position */
     
157.                 for (i = shell.line_curpos; i <= shell.line_position; i++)
     
158.                     printf("\b");
     
159.             }
     
160.             else
     
161.             {
     
162.                 printf("\b \b");
     
163.                 shell.line[shell.line_position] = 0;
     
164.             }
     
165. 
     
166.             return;
     
167.         }
     
168. 
     
169.         /* handle end of line, break */
     
170.         if (ch == '\r' || ch == '\n')
     
171.         {
     
172. #ifdef FINSH_USING_HISTORY
     
173.             shell_push_history(&shell);
     
174. #endif
     
175. 
     
176. #ifdef FINSH_USING_MSH
     
177.             
     
178.             shell_screen_append(0, shell.line, shell.line_position);
     
179.             if (cmd_is_used() == DE_TRUE)
     
180.             {
     
181.                 if (shell.echo_mode)
     
182.                     printf("\r\n");
     
183.                 cmd_exec(shell.line, shell.line_position);
     
184.             }
     
185.             else
     
186. #else
     
187.             printf("\r\n");
     
188. #endif
     
189.             {
     
190. #ifndef FINSH_USING_MSH_ONLY
     
191.                 /* add ';' and run the command line */
     
192.                 shell.line[shell.line_position] = ';';
     
193. 
     
194.                 if (shell.line_position != 0)
     
195.                     finsh_run_line(&shell.parser, shell.line);
     
196.                 else
     
197.                     if (shell.echo_mode) printf("\n");
     
198. #endif
     
199.             }
     
200.             printf(FINSH_PROMPT);
     
201.             memset(shell.line, 0, sizeof(shell.line));
     
202.             shell.line_curpos = shell.line_position = 0;
     
203.             return;
     
204.         }
     
205. 
     
206.         /* it's a large line, discard it */
     
207.         if (shell.line_position >= FINSH_CMD_SIZE)
     
208.             shell.line_position = 0;
     
209. 
     
210.         /* normal character */
     
211.         if (shell.line_curpos < shell.line_position)
     
212.         {
     
213.             int i;
     
214. 
     
215.             de_memmove(&shell.line[shell.line_curpos + 1],
     
216.                        &shell.line[shell.line_curpos],
     
217.                        shell.line_position - shell.line_curpos);
     
218.             shell.line[shell.line_curpos] = ch;
     
219.             if (shell.echo_mode)
     
220.                 printf("%s", &shell.line[shell.line_curpos]);
     
221. 
     
222.             /* move the cursor to new position */
     
223.             for (i = shell.line_curpos; i < shell.line_position; i++)
     
224.                 printf("\b");
     
225.         }
     
226.         else
     
227.         {
     
228.             shell.line[shell.line_position] = ch;
     
229.             if (shell.echo_mode)
     
230.                 printf("%c", ch);
     
231.         }
     
232. 
     
233.         ch = 0;
     
234.         shell.line_position ++;
     
235.         shell.line_curpos++;
     
236.         if (shell.line_position >= FINSH_CMD_SIZE)
     
237.         {
     
238.             /* clear command line */
     
239.             shell.line_position = 0;
     
240.             shell.line_curpos = 0;
     
241.         }
     
242.     } /* end of device read */
     
243. }</font>

复制代码

（3）然后就是判断执行什么函数，如果输入内容错误，则直接返回错误提示。

1. <font size="3" face="宋体">void cmd_exec(char *cmd_line, uint8_t cmd_len)
   
2. {
   
3.     if(cmd_len > 0)
   
4.     {
   
5.         uint8_t i = 0;
   
6.         char cmd_line_temp[30] = {0};
   
7. 
   
8.         memcpy(cmd_line_temp, cmd_line, cmd_len);
   
9.         for(i = 0;i < cmd_cnt;i++)
   
10.         {
    
11.             if(memcmp(cmd_list[i].name, cmd_line_temp, strlen(cmd_list[i].name)) == 0 && cmd_len >= strlen(cmd_list[i].name))
    
12.             {
    
13.                 cmd_list[i].function(cmd_line_temp);
    
14.                 //printf("ret:%d\r\n", cmd_list[i].function(cmd_line_temp));
    
15.                 break;
    
16.             }
    
17.         }
    
18.         if(i == cmd_cnt)
    
19.         {
    
20.             cmd_error(cmd_line_temp);
    
21.         }
    
22.     }
    
23. }</font>

复制代码

（4）同时我还设计了控制屏幕控件的函数，可以不用阅读【T5L_DGUSII_应用开发指南】就可以对控件进行操作，目前只设计了文本和基本图形中的矩形，后续会完善剩下的，代码如下所示：

1. <font size="3" face="宋体">void base_graph_rectangle_fill_set(uint16_t addr, base_graph_param_t base_graph_param_temp[], uint8_t len)
   
2. {
   
3.     uint8_t cmd[252] = {0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0xE0, 0x03, 0x20, 0xAA, 0xAA, 0xFF, 0x00};
   
4.     uint8_t i = 0;
   
5. 
   
6.     if(len > 24)    //一次最多24个数据
   
7.         len = 24;
   
8. 
   
9.     //图形数量
   
10.     cmd[3] = len;
    
11. 
    
12.     for(i = 0;i < len;i++)
    
13.     {
    
14.         cmd[4 + i * 10] = base_graph_param_temp[i].start_x / 256;
    
15.         cmd[5 + i * 10] = base_graph_param_temp[i].start_x % 256;
    
16.         cmd[6 + i * 10] = base_graph_param_temp[i].start_y / 256;
    
17.         cmd[7 + i * 10] = base_graph_param_temp[i].start_y % 256;
    
18.         cmd[8 + i * 10] = base_graph_param_temp[i].end_x / 256;
    
19.         cmd[9 + i * 10] = base_graph_param_temp[i].end_x % 256;
    
20.         cmd[10 + i * 10] = base_graph_param_temp[i].end_y / 256;
    
21.         cmd[11 + i * 10] = base_graph_param_temp[i].end_y % 256;
    
22.         cmd[12 + i * 10] = base_graph_param_temp[i].color / 256;
    
23.         cmd[13 + i * 10] = base_graph_param_temp[i].color % 256;
    
24.     }
    
25. 
    
26.     cmd[len * 10 + 4] = 0xFF;
    
27.     cmd[len * 10 + 5] = 0x00;
    
28. 
    
29.     sys_write_vp(addr, cmd, (len * 10 + 6) / 2);
    
30.    
    
31. }
    
32. 
    
33. //文本变量设置
    
34. void text_display_value_set(uint16_t addr, uint16_t offset, char *text_data, uint16_t text_len)
    
35. {
    
36.     sys_write_vp(addr + offset, text_data, text_len);
    
37. }
    
38. 
    
39. //文本描述设置
    
40. void text_display_describe_set(uint16_t addr, uint32_t mask, uint16_t value_addr, int16_t x, int16_t y)
    
41. {
    
42.     if(mask & TEXT_MASK_VALUE_ADDR == TEXT_MASK_VALUE_ADDR)
    
43.     {
    
44.         sys_write_vp(addr, (uint8_t *)&value_addr, 1);
    
45.     }
    
46. }</font>

复制代码

（5）最后还有一个触摸的回调，通过注册按键、添加按键回调来实现按键的触发，保证了系统的分层调用关系。代码如下：

1. <font size="3" face="宋体">void touch_init(uint16_t touch_addr)
   
2. {
   
3.     touch_address = touch_addr;
   
4. }
   
5. 
   
6. void touch_insert(uint16_t touch_value, touch_function_t touch_function_temp)
   
7. {
   
8.     touch_function[touch_function_cnt] = touch_function_temp;
   
9.     touch_values[touch_function_cnt] = touch_value;
   
10.     touch_function_cnt++;
    
11. }
    
12. 
    
13. //用于产生按钮点击扫描信号,放在1ms的定时器中调用即可
    
14. void touch_tick()
    
15. {
    
16.         #define BTN_SCAN_PERIOD                100   //按钮点击事件的扫描周期,单位ms
    
17.         static idata uint8_t tick = 0;
    
18.         
    
19.         tick++;
    
20.         if(tick == BTN_SCAN_PERIOD)
    
21.         {
    
22.                 tick = 0;
    
23.                 is_btn_scan = 1;//产生一个按钮点击扫描信号
    
24.         }
    
25. }
    
26. 
    
27. //按钮点击事件扫描并处理
    
28. void touch_handler()
    
29. {
    
30.         uint16_t btn_val;
    
31.     uint8_t i = 0;
    
32.         
    
33.         if(is_btn_scan == 0)//是否有扫描信号,没有的话就啥也不做,直接返回
    
34.                 return;
    
35.         is_btn_scan = 0;//清除
    
36.         
    
37.         //1.开始检查是否有按钮按下
    
38.         sys_read_vp(touch_address, (uint8_t*)&btn_val, 1);
    
39.         if(btn_val == 0)
    
40.                 return;
    
41.         
    
42.         //2.按钮点击事件处理
    
43.         for(i = 0;i < touch_function_cnt;i++)
    
44.     {
    
45.         if(btn_val == touch_values[i])
    
46.         touch_function[i]();
    
47.     }
    
48. 
    
49.         //3.清除按键值
    
50.         btn_val = 0;
    
51.         sys_write_vp(touch_address, (uint8_t*)&btn_val, 1);
    
52. }</font>

复制代码

4.界面设计

（1）界面：界面设计就是简单的显示Shell的输入和输出，不过也用到了一些新技术，通过修改变量地址来实现翻页，这样就非常方便，界面素材只有三张图。

（2）代码：一共就两个界面，首页和显示页，有技术难度的在显示页，可以实现自动翻页和自动换行功能，主要是通过代码实现的，具体如下：

1. <font size="3" face="宋体">#define PAGE_LINE_MAX   17  //一页最多十七行
   
2. 
   
3. uint8_t page_total = 0;         //总页数
   
4. uint8_t page_current = 0;       //当前页数
   
5. uint8_t last_page_lines = 0;    //最后一页的行数
   
6. uint8_t last_page_length = 0;   //最后一页的字符数
   
7. uint16_t page_addr = 0x2000;
   
8. 
   
9. void display_page_status()
   
10. {
    
11.     char page_temp[6] = {0};
    
12. 
    
13.     page_temp[0] = (page_current + 1) / 10 + '0';
    
14.     page_temp[1] = (page_current + 1) % 10 + '0';
    
15.     page_temp[2] = '/';
    
16.     page_temp[3] = (page_total + 1) / 10 + '0';
    
17.     page_temp[4] = (page_total + 1) % 10 + '0';
    
18.     text_display_value_set(0x1100, 0, page_temp, 3);
    
19. }
    
20. 
    
21. void shell_screen_append(uint8_t mode, char *line_data, uint8_t line_len)
    
22. {
    
23.     char line_temp[100] = {0};
    
24.     char line_cnt = 0;
    
25.     uint8_t i = 0;
    
26.     uint8_t current_line_cnt = 0;
    
27. 
    
28.     if(mode == 0)
    
29.     {
    
30.         memcpy(line_temp, "msh >", 5);
    
31.         line_cnt = 5;
    
32.     }
    
33.     if(page_current != page_total)
    
34.     {
    
35.         page_current = page_total;
    
36.         text_display_describe_set(0x1200, TEXT_MASK_VALUE_ADDR, page_addr + page_current * 0x200, 0, 0);
    
37.     }
    
38.    
    
39.     for(i = 0;i < line_len;i++)
    
40.     {
    
41.         line_temp[line_cnt++] = line_data[i];
    
42.     }
    
43. 
    
44.     current_line_cnt = (line_cnt / 25) + 1;
    
45.     last_page_lines += (line_cnt / 25) + 1;
    
46. 
    
47.     if(last_page_lines > PAGE_LINE_MAX)
    
48.     {
    
49.         page_total++;
    
50.         page_current = page_total;
    
51.         last_page_lines = current_line_cnt;
    
52.         last_page_length = 0;
    
53.         text_display_describe_set(0x1200, TEXT_MASK_VALUE_ADDR, page_addr + page_current * 0x200, 0, 0);
    
54.         display_page_status();
    
55.     }
    
56. 
    
57.     if(line_cnt % 2 == 1)
    
58.     {
    
59.         if(line_cnt % 25 < 23)
    
60.         {
    
61.             line_temp[line_cnt++] = ' ';
    
62.             line_temp[line_cnt++] = '\r';
    
63.             line_temp[line_cnt++] = '\n';
    
64.         }
    
65.         else if(line_cnt % 25 == 24)
    
66.         {
    
67.             line_temp[line_cnt++] = ' ';
    
68.         }
    
69.     }
    
70.     else
    
71.     {
    
72.         if(line_cnt % 25 < 24)
    
73.         {
    
74.             line_temp[line_cnt++] = '\r';
    
75.             line_temp[line_cnt++] = '\n';
    
76.         }
    
77.     }
    
78. //    printf("\r\n%s %d\r\n", line_temp, line_len);
    
79.     text_display_value_set(page_addr + page_current * 0x200, last_page_length / 2, line_temp, line_cnt / 2);
    
80.     last_page_length += line_cnt;
    
81. }
    
82. 
    
83. void page_next()
    
84. {
    
85.     // printf("page_next");
    
86.     if(page_current < page_total)
    
87.     {
    
88.         page_current++;
    
89.         text_display_describe_set(0x1200, TEXT_MASK_VALUE_ADDR, page_addr + page_current * 0x200, 0, 0);
    
90.         display_page_status();
    
91.     }
    
92. }
    
93. 
    
94. void page_last()
    
95. {
    
96.     // printf("page_last");
    
97.     if(page_current > 0)
    
98.     {
    
99.         page_current--;
    
100.         text_display_describe_set(0x1200, TEXT_MASK_VALUE_ADDR, page_addr + page_current * 0x200, 0, 0);
     
101.         display_page_status();
     
102.     }
     
103. }</font>

复制代码

5.结论

C51移植Shell还是相对麻烦的，因为有些变量是没有的，所以需要通过别的方法来实现。好在整体功能都实现了，后续DE-RTOS希望有更多的开发者一起参与，来完善迪文的操作系统生态，我也会好好维护和升级DE-RTOS。

开源地址：https://gitee.com/erzhekeji/dwin_dertos.git

界面工程：

6.演示视频：

备注说明：如需源码，请参考此链接：http://inforum.dwin.com.cn:20080/forum.php?mod=viewthread&tid=8908&highlight=%E7%AC%AC%E4%B8%80%E7%AF%87&_dsign=cec5eea7

dhl666

牛，实时性怎么样，我也自己写了一个任务调度的RTOS，其他功能还没完善