RTT有一个非常好的功能就是调试界面了，但是移植finish组件需要使用RTT的驱动文件，个人表示只喜欢用内核，不想用RTT的方式写驱动，所以自己改写了一下RTT自带的finish功能，可以不使用RTT的drv。

3 W( a; B, u" p. r7 L基本能实现自己想要的功能，基本思路就是把RTT各种命令的函数及其调用的函数复制到我们自己的文件夹，然后串口中断后保存串口的数据，当点击回车时比较我们输入的字符跟定义的命令字符，然后执行相应的操作。
移植RTT的内核到nucleo144-F7,参照火哥的书籍移植，移植后配置好RTT的rt_kpruntf()函数，然后就可以自己配置finish了
9 i+ j0 e/ g% ]  K8 ~! @
. [# C3 l# q) |& D% H2 a1、把命令对应的函数及其调用的函数复制到我们自己的文件里面，基本都在rtt文件夹的cmd.c(各种list_)和msh_cmd.c(ls,echo等)，可以用查找以下两个函数的方式查找内核中的命令，因为rtt的命令都是通过这两个函数导入到内核里面FINSH_FUNCTION_EXPORT()
MSH_CMD_EXPORT()
9 X( N0 W! e# \7 o0 u; ]: ?
( H3 {) }, a- x这样就可以查到内核里面有哪些命令，然后把命令的实现函数（跟命令一个名字）复制过来。
' m; _: S- R  j% N. R/ b

1. 
   : S9 j0 r2 Y- q0 |5 j1 o
2. const char *cmd_list[MAX_CMD] = {        "ps",
   " }9 E: F( z7 ~- x1 @
3.                                                                                                 "free",
   ) H7 z! ]$ Y7 u! G1 o6 u
4.                                                                                                 "list_thread",
   
5.                                                                                                 "list_sem",
   
6.                                                                                                 "list_timer",
   
7.                                                                                                 "list_mutex",
   . s  J( {2 l/ l7 i* k2 |  O3 W: T
8.                                                                                                 "list_mailbox",
   
9.                                                                                                 "list_msgqueue",
   0 L  ~+ `# W4 l3 g6 a3 a4 N  `
10.                                                                                                 "list_event",
    , r1 @- |  \/ G, d+ l% N
11.                                                                                                 "list_fevent",
    % b) O3 X( _' t5 |7 k
12.                                                                                                 "list_mempool",
    / |" X* E. k. E
13.                                                                                                 "help",
    0 I0 B& j/ l! ?& V) w; q5 P
14.                                                                                                 "reboot",
    + I; [$ Z0 N  H+ ~
15.                                                                                                 "shutdown_thread",
    / t" n$ N, ~1 l" w3 B8 K9 b
16.                                                                                                 "reset_thread",
    
17.                                                                                                 "led3_open",
    
18.                                                                                                 "led3_close",
    
19.                                                                                                 "show_version"
    1 h  J2 q' b; @9 F/ B: {/ b& I: ]& I
20.                                                                                                 /*add cmd here*/};
    , c* C5 d1 w8 d: i! F# ?- p
21. 
    
22.                                                                                                
    
23. static int object_name_maxlen(struct rt_list_node *list)
    ! _7 }( t) Z$ J) B% h* F9 F0 q
24. {
    5 d. i  L: l' f* w* L+ |" M3 g9 l# e
25.     struct rt_list_node *node;
    
26.     struct rt_object *object = NULL;
    
27.     int max_length = 0, length;
    6 D' F  [8 h2 s# A" F
28. 
    
29.     rt_enter_critical();
    * p% D9 }+ V. J" H: s: i, E/ P
30.     for (node = list->next; node != list; node = node->next)
    
31.     {
    
32.         object = rt_list_entry(node, struct rt_object, list);
    4 y1 ?$ ]) z$ N; U2 x( l7 y
33. 
    
34.         length = rt_strlen(object->name);
    
35.         if (length > max_length) max_length = length;
    ' s. z& a) W, a9 k
36.     }
    
37.     rt_exit_critical();
    
38. 
    
39.     if (max_length > RT_NAME_MAX || max_length == 0) max_length = RT_NAME_MAX;
    
40. 
    
41.     return max_length;
    - I+ D3 u  q- ]0 j, W3 L
42. }
    ' o* R5 Y$ }8 f6 p
43. 
    4 `- p! W# A0 F  T+ ?( o+ k3 T$ [
44. rt_inline void object_split(int len)
    3 R, ~0 S+ }: _- r$ ~: Z! `4 z
45. {
    6 i! B2 H5 b! o! P
46.     while (len--) rt_kprintf("-");
    $ C' ]" D, [! D1 Q. ~( L( `( ~
47. }
    
48. 
    9 |* f% N; h2 F+ H5 [% t
49. 
    - u; S/ x( B! }+ [/ P7 ]3 T
50. static long _list_thread(struct rt_list_node *list)
    
51. {
      L4 u) g, k3 _+ e
52.     int maxlen;
    
53.     rt_uint8_t *ptr;
    ' F; v, ^8 \3 e- I; s# _$ G
54.     struct rt_thread *thread;
    , k& ^) S5 }  A6 [8 o7 E, ]* ^
55.     struct rt_list_node *node;
    % |" b) s+ r: ~
56. 
    
57.     maxlen = object_name_maxlen(list);
    
58. 
    
59.     rt_kprintf("%-*.s pri  status      sp     stack size max used left tick  error\n", maxlen, "thread"); object_split(maxlen);
    ( d+ Q8 O, w: k: U4 ^. Q
60.     rt_kprintf(     " ---  ------- ---------- ----------  ------  ---------- ---\n");
    
61.     for (node = list->next; node != list; node = node->next)
    
62.     {
    & P3 J8 ]8 g& b) [# R; ]$ q% n- ^
63.         rt_uint8_t stat;
    . X% B" e4 Z! r7 w1 L) L
64.         thread = rt_list_entry(node, struct rt_thread, list);
    
65.         rt_kprintf("%-*.*s %3d ", maxlen, RT_NAME_MAX, thread->name, thread->current_priority);
    $ K2 p( _( S$ ?3 ?
66. 
    
67.         stat = (thread->stat & RT_THREAD_STAT_MASK);
      y- s+ p4 V; g. P) n: i6 \  X
68.         if (stat == RT_THREAD_READY)        rt_kprintf(" ready  ");
    
69.         else if (stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend");
    $ q3 h: u0 T6 s2 R' t. J
70.         else if (stat == RT_THREAD_INIT)    rt_kprintf(" init   ");
    1 E8 Z$ @- x: n3 U
71.         else if (stat == RT_THREAD_CLOSE)   rt_kprintf(" close  ");
    
72. 
    " q9 Z" q8 S5 E
73.         ptr = (rt_uint8_t *)thread->stack_addr;
    + T8 b+ ?$ r. {1 D" `! C' g& v
74.         while (*ptr == '#')ptr ++;
    
75. 
    
76.         rt_kprintf(" 0x%08x 0x%08x    %02d%%   0x%08x %03d\n",
    
77.                    thread->stack_size + ((rt_uint32_t)thread->stack_addr - (rt_uint32_t)thread->sp),
    $ Q7 K9 p! k4 h' [" S0 \
78.                    thread->stack_size,
    
79.                    (thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t) thread->stack_addr)) * 100
    
80.                         / thread->stack_size,
    # D) Q, m$ I+ p
81.                    thread->remaining_tick,
    8 v6 B8 V; @: {5 d
82.                    thread->error);
    $ x7 P# v3 D/ w2 G
83.     }
    
84. 
    2 R* F; T8 ]; P, F5 [
85.     return 0;
    
86. }
    - ~$ Y4 F/ Q$ N& _4 h
87. 
    
88. long list_thread(void)
    / I/ c; F7 p$ I. \1 K( ~+ P
89. {
    
90.     struct rt_object_information *info;
    " p6 o; }( a- d1 K6 P/ J! P  C- e
91. 
    
92.     info = rt_object_get_information(RT_Object_Class_Thread);
    
93.     return _list_thread(&info->object_list);
    " j$ [( s* N( P# h9 n' m8 ?
94. }
    

复制代码

代码太多，就贴了一段。
9 `  ^: v: j1 I& L8 A2、测试一下自己复制的各个命令是否有效，自己在main文件里面执行各个命令对应的函数，这里只移植了部分命令，有一些需要修改config文件，

1. list_thread();
   8 z. f2 h! S/ G$ T" _9 E7 N
2. list_sem();
   
3. list_event();
   . P& U2 E2 y6 }* g0 `# b% r0 _$ w
4. list_mutex();
   ! [# ^6 T7 N+ ]
5. list_mailbox();
   : W3 W# x" y/ x0 l
6. list_msgqueue();
   ' L1 S1 K9 U& P6 x# Z: t- X
7. list_memheap();
   
8. list_mempool();
   
9. list_timer();

复制代码

然后查看串口的输出。
3、搞定了命令对应的函数已经串口打印正确，然后就是获取串口的输入执行对应的命令，首先要定义一个字符串数组保存我们的命令用来跟串口的数据比较等到要执行的命令函数，
; e) g/ T- l3 D/ U1 J  G4 T5 H7 W6 ~

1. const char *cmd_list[MAX_CMD] = {        "ps",
   ) G4 P, K) f; c4 @
2.                                                                                                 "free",
   & ^2 C7 q* ?. W1 B2 Y* _: p' x
3.                                                                                                 "list_thread",
   
4.                                                                                                 "list_sem",
   
5.                                                                                                 "list_timer",
   
6.                                                                                                 "list_mutex",
   9 {! f: k; u1 t4 p
7.                                                                                                 "list_mailbox",
   5 d8 r, Y" ~+ |2 U( U( ^* A# ~
8.                                                                                                 "list_msgqueue",
   
9.                                                                                                 "list_event",
   
10.                                                                                                 "list_fevent",
    6 _: ?2 F/ Z$ o$ t# l
11.                                                                                                 "list_mempool",
    : X* ~# f3 F+ @; m4 W! X5 ^
12.                                                                                                 "help",
    ; m3 W$ [7 `, o3 Q- `- r. W' z
13.                                                                                                 "reboot",
    2 P) e$ U! K. l7 h8 K! n5 \& \: d
14.                                                                                                 "shutdown_thread",
    
15.                                                                                                 "reset_thread",
    7 S+ M" V% b! ]5 O# W
16.                                                                                                 "led3_open",
    - z1 T6 T2 z' Y6 z( n# D
17.                                                                                                 "led3_close",
    & l# L: H7 D0 `5 |  a# m
18.                                                                                                 "show_version"
    6 m5 D/ e/ o/ N1 f/ n; J; m" [
19.                                                                                                 /*add cmd here*/};

复制代码

我这里就添加了以上命令。
4、获取串口的数据参考原子的串口函数，当从串口收到回车符时，就判断输入的命令。
3 z4 K! p, n7 T  \5 R

1. //串口3中断服务程序
   4 [, z) |' d) l( H: t
2. void USART3_IRQHandler(void)                       
   " V8 R! s& ~8 U0 ~6 e8 ^7 J2 x6 x3 n
3. {
   7 Y: f0 V; X& ^" I  Z) E
4.         uint8_t Res;
   ) A6 A9 |8 ~' T2 o1 c/ ~$ X+ J
5. #ifdef SUPPORT_RTT
     q2 w0 g  K( L1 O; u
6.         /* enter interrupt */
   
7.         rt_interrupt_enter();
   
8. #endif
   1 D; W7 q" r) |9 K1 B5 b4 M
9.        
   
10.         if((__HAL_UART_GET_FLAG(&Uart3Handle,UART_FLAG_RXNE)!=RESET))  //接收中断(接收到的数据必须是0x0d结尾)
    - \, _5 B) Z. j" p$ f* z
11.         {
    * f# I8 [; v9 _. G5 L/ R
12.     HAL_UART_Receive(&Uart3Handle,&Res,1,1000);                 //保存收到的数据
    
13.                 HAL_UART_Transmit(&Uart3Handle,&Res,1,1000);                //将输入的数据原封不动的打印到串口
    " N' y% B2 h$ q  ^3 z3 i) a
14.                 if(Res == 0x7f)                //DEL键，如果按了del键，不仅要删除putty的显示，还要删除刚刚输入的命令的最后一个字符
    
15.                 {
    . L2 c: _; U4 }
16.                         USART_RX_BUF[(USART_RX_STA&0X3FFF)-1] = '\0';                        //删除最后一个字符
    
17.                         USART_RX_STA--;                                                                                                                                                //数量减一
    
18.                 }
    
19.                 else
    9 G4 w' w8 ^5 M7 T5 [
20.                 {
    
21.                         if((USART_RX_STA&0x8000)==0)//接收未完成
    3 p  X" i( x. Q9 t+ s1 r* r. {
22.                         {
    
23.                                         if(Res==0x0d)USART_RX_STA|=0x8000;                                //收到了oxod
    
24.                                         else
    2 R2 ?' Z* t. u+ Y" `0 x! Q
25.                                         {
    3 }) ~; U/ S! _% w2 G0 ]- \" J
26.                                                 USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;                //保存数据
    
27.                                                 USART_RX_STA++;                                                                                                                //数量加一
    & I, }7 `: s' I/ i
28.                                                 if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收          
    
29.                                         }                 
    ' i  C/ X& B( s  w4 L2 K
30.                         }
    
31.                 }                        
    & s& D8 D/ F% b
32.         }
    , D5 v/ J& C! M$ Y# q: e
33.         HAL_UART_IRQHandler(&Uart3Handle);       
    
34. #ifdef SUPPORT_RTT
    3 m$ o: a- g3 X$ r8 K1 h
35.         /* enter interrupt */
    4 A: r$ ]6 L( l" G1 k& A" v! F2 {
36.         rt_interrupt_enter();
    
37. #endif
    
38. }

复制代码

这里USART_RX_STA类似一个寄存器操作，USART_RX_BUF保存串口数据，当收到回车，相应的标志位会被置位，会有一个线程来处理串口的数据。
5、新建一个线程用来处理串口输入的数据。线程函数如下
0 Q2 @0 v5 G+ E" f! \7 g  N% t7 |7 H& B

1. static void msh_thread_entry(void *parameter)
   5 L. n* F8 O, g9 N2 ^4 [! s9 I/ h) k7 d
2. {
   
3.         uint8_t cmd;
   $ m' G  B$ }( R8 H; j, O
4.         uint8_t md_value;
   
5.         rt_kprintf("\r\nmsh>");       
   
6.         while(1)
   ' s1 Q9 U6 x" B/ J
7.         {
   
8.                 if(USART_RX_STA&0x8000)
   + E; F( G* N0 J+ a' c4 H
9.                 {
   . P+ Q4 S2 D7 }. ]
10.                         if(USART_RX_BUF[0]!='\0')
    
11.                         {
    
12.                                 rt_kprintf("\r\n");
    
13.                                 for(cmd=0;cmd<=MAX_CMD;cmd++)
    . r$ D2 @& P( @: g2 k* Q5 f* P) t' C
14.                                         if(rt_strcmp((const char*)USART_RX_BUF,cmd_list[cmd])==0)
    
15.                                                 break;
    
16.                                 switch(cmd)
    
17.                                 {
    ' D$ H. F/ V* v7 B7 b2 x
18.                                         case PS:list_thread();break;
    
19.                                        
    
20.                                         case FREE:rt_kprintf("Not yet open\r\n");break;
    4 h% f1 j2 k: ?  w. {4 o; `% t! S
21.                                        
    
22.                                         case LIST_THREAD:list_thread();break;
    
23.                                        
    
24.                                         case LIST_SEM:list_sem();break;
    ; s' @8 ^3 V1 D6 D) X
25.                                        
    
26.                                         case LIST_TIMER:list_timer();break;
    
27.                                        
    , L$ Z& @3 x+ ^$ Y' i
28.                                         case LIST_MUTEX:list_mutex();break;
    6 S( u6 g2 h  F) R% k
29.                                        
    . O, E/ x  ~  k) |4 u5 h
30.                                         case LIST_MAILBOX:list_mailbox();break;
    9 J8 J+ t# {( H9 o
31.                                        
    ! e# o1 @% n% I, B: H
32.                                         case LIST_MSGQUEUE:list_msgqueue();break;
    ; |" P6 l8 Z4 g3 N* S+ }
33.                                        
    
34.                                         case LIST_EVENT:list_event();break;
    + ]! W3 n' s- O3 o9 P
35.                                        
    
36.                                         case LIST_FEVENT:rt_kprintf("Not yet open\r\n");break;
    
37.                                        
    
38.                                         case LIST_MEMPOOL:rt_kprintf("Not yet open\r\n");break;
    ! A& Y9 _/ _9 Z3 H
39.                                        
    % F6 s' p0 T# y' F) F
40.                                         case REBOOT:HAL_NVIC_SystemReset();break;
    : r* G& h1 P' G7 L5 i4 k7 J! _0 ~. B
41.                                        
    
42.                                         case SHUTDOWN_THREAD:rt_kprintf("Not yet open\r\n");break;
    1 n: |) Q* b4 \9 P, t) H
43.                                        
    
44.                                         case RESET_THREAD:rt_kprintf("Not yet open\r\n");break;
    
45.                                        
    3 z& o) J) ?: U' n; g- c
46.                                         case LED3_OPEN://HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_SET);rt_kprintf("LED3 IS OPEN\r\n");break;
    
47.                                                 md_value=0x01;
    0 N, d+ Z' q; u
48.                                                 rt_mb_send_wait(test_mail,(rt_uint32_t)md_value,0);
    
49.                                                 break;
    
50.                                        
    
51.                                         case LED3_CLOSE://HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET);rt_kprintf("LED3 IS CLOSE\r\n");break;
    
52.                                                 md_value=0;
    
53.                                                 rt_mb_send_wait(test_mail,(rt_uint32_t)md_value,0);
    9 Y) t- Q+ ]( I: [8 V, e
54.                                                 break;
    2 Q8 D* o$ z. H' q( |! }( l
55.                                        
    
56.                                         case SHOW_VERSION:
    6 {4 z0 g4 o( X& a
57.                                                 rt_show_version();
    
58.                                                 break;
    
59.                                        
    : B7 A) }# J$ ]# m/ J# _- ^0 H
60.                                         case HELP:
    0 a6 ]1 t) C1 y2 `+ o& |
61.                                                 for(uint8_t i=0;i<(MAX_CMD-1);i++)
    
62.                                                         rt_kprintf("%s\r\n",cmd_list[i]);
    
63.                                                 break;
    " n* ^6 n3 B- t; a( Y
64.                                         case OTHER_CMD:
    2 k' q/ b! F: F" U- q, c
65.                                                 break;
    
66.                                        
    
67.                                         default:rt_kprintf("command not found!\r\n");break;
    
68.                                 }
    1 e1 Z6 f2 L; Q6 P3 M$ ~' w, ]
69.                         }
    
70.                         rt_kprintf("\r\nmsh>");
    
71.                         rt_memset(USART_RX_BUF,0,sizeof(USART_RX_BUF));
    ( T/ V9 U* q: h1 |. |
72.                         USART_RX_STA=0;
    
73.                 }
    
74.                 rt_thread_delay(5);
    4 Q) d4 j- g. u% u
75.         }
    1 t! ~* c+ }. P
76. }

复制代码

就是判断串口的数据，执行相应的命令，这个函数里面有邮箱的发送函数，为了测试用的，会有一个线程专门接收邮箱的数据然后控制LED。然后新建对应的线程就可以操作了。
目前仅支持删除键，上下左右TAB键什么都不支持。
0 P: |+ [1 I6 V' H8 X然后添加命令只需添加命令数组，加大MAX_CMD，在命令处理线程里面增加相应的操作。
使用这种方法，对于任何系统，裸机都可以实现shell。
- `0 Q, i) M7 \9 F( p9 r我在main里面定义了5个线程，线程一 LED1闪烁、线程二消息队列发送发送控制LED2的消息，线程三消息队列接收接收线程二的消息并控制LED2、线程四 模拟MSH、线程五邮箱接收MSH线程发来的控制LED3的邮箱内容，涉及了线程的创建，消息队列，邮箱定时器等。nucleo144-F7可以直接下载。
如果文章中或者代码中有什么错误，希望大家指正，对于RTT的理解，有疑问的也希望大家指导。
DEMO.zip (2.62 MB, 下载次数: 45)

2018-11-11 18:43 上传

点击文件名下载附件
" o% v4 W( w$ A5 B

  a* K8 {% }) u! U. D# T$ F
. O7 G1 i, J, T" X3 |6 E8 ?

感谢分享   

creep 发表于 2018-11-12 14:03
3 y6 I; b: ^6 X6 {: }' q2 G感谢分享

互相学习

谢谢  分享 谢谢