你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

STM32CubeMX Nucleo F767ZI 教程(3) 串口调试工具 Letter Shell

[复制链接]
STMCU小助手 发布时间:2022-8-23 16:13
前言
2 v& R0 A0 d+ ~' X: a一般使用串口来打印调试信息之类的,正点原子的USMART也不错,这边引入了一个类似于Linux 命令行的调试功能,Letter Shell,功能很强大,github的链接在下面。
3 C# `/ x( k, A2 s  o我们要移植一下这个功能,方便后面的调试。这个功能使用到了串口,接收到串口数据后回传到上位机,直到接收到命令行回车触发,也就是0x0A(LF 换行)以及0x0D(CR 回车),不同的软件,结束符可能也有点区别。确认收到完整的命令,就可以解析命令,根据不同函数的地址就可以进行调用了,这样子调试程序就很方便了。0 Y1 b; @4 \% V+ d! M& [
效果图如下:. J* J3 e+ C4 \9 {8 c  q; k4 z3 G( K& Q

% g3 @" T& P* ]$ X 20210220214542675.gif ( D1 w! o. [8 ?5 y7 Q! ?" v# m+ V

1 ~/ `9 j1 Z6 R9 n" H9 E0 N
一、FreeRTOS配置1 O$ a5 Y; w( j/ d# Q
1.FreeRTOS
- h9 u( a( k& h, [
Letter Shell 仅需要用到串口,然后使用shell 的回调命令,就可以使用了,但是后续我们需要使用到FreeRTOS,这就涉及到中断优先级的问题了,STM32CubeMX有16个优先级,0为最高优先级,15为最低优先级,FreeRTOS可以管理管理包括优先级5-16的中断,我们这里先配置一下FreeRTOS,暂时不需要其他功能,默认配置有一个defaultTask的线程,我们用这个来控制LED以指示系统的正常运行,所以这个按照默认配置就可以了。; H: z  `, B6 C; M+ u

- c4 x7 P- k( c: I  x) a/ l 20210124211939416.png
0 S8 S  O$ L) s) S9 n
# V. x3 F0 _$ ]+ qFreeRTOS需要使用时钟基,默认是SysTick,滴答定时器,默认配置是1ms中断一次,然后计时器+1,但是SysTick并不是很准确,我们可以在SYS 选项卡中改一下Timebase Source,这里我们改为定时器3当时钟基。1 M4 f4 z: J8 \7 a- z' |, a6 G
20210124222836342.png
' W9 U4 U5 z/ e0 c7 U# M
% b3 q1 J( K. T9 U5 y1 u7 _然后配置一下串口,因为Nucleo板载了ST-LINK V2.1,有一个虚拟串口连接到USART3,所以使能USART3,然后使能中断就可以了。点击GENERATE CODE生成代码。! O8 H8 J) Q' \7 M$ o

8 n. A: O4 @- D 2021012422385383.png - o% E+ s3 u2 R; z; l

1 B+ g. S% G3 W# v先打开 “freertos.c”,里面有一个默认的线程,StartDefaultTask,我们在这里加一个LED闪烁的功能,先测试一下生成的工程没问题。8 W9 J* e  @: T

- V9 o* \5 A, w0 i% i
  1. /* USER CODE BEGIN Header_StartDefaultTask */& S% W* d$ r4 [8 A3 N  q5 k& w
  2. /**5 B  F0 g* D/ m0 H$ a  K
  3.   * @brief  Function implementing the defaultTask thread.3 O) G- U( h. a/ J# s* g
  4.   * @param  argument: Not used
    . i: t4 ~5 V  N1 C. R2 w' u% z
  5.   * @retval None; Q3 X4 m& M* f# m6 }2 U# h5 Q4 H
  6.   */. Z$ U& e( T/ Q! Z" n  [9 ]
  7. /* USER CODE END Header_StartDefaultTask */
    8 P, [' A/ }$ m. o/ W4 y
  8. void StartDefaultTask(void *argument)
    9 i9 z* f  H9 L! W$ @3 _
  9. {
    6 q4 d: |2 m& l: v1 h! o+ s
  10.   /* USER CODE BEGIN StartDefaultTask */( Q/ [* E+ n; ?; t( B7 f& }
  11.   /* Infinite loop */1 v. Q0 R0 S* Z" y: y9 l
  12.   for(;;). ]" m$ U% `4 l+ E
  13.   {4 y8 J3 N# @( ~
  14.     HAL_GPIO_TogglePin(LD3_GPIO_Port,LD3_Pin);8 ^9 {- m5 \+ w" k2 U- t7 k9 [& H
  15.     osDelay(100);, p( P# `+ l: _4 a; Q! W9 j& y) y
  16.   }/ k3 F  x8 _& T% P
  17.   /* USER CODE END StartDefaultTask */# D. E8 Z0 Z1 `  B
  18. }4 z2 h3 ~- [) g) q
复制代码
2 |# M4 a, K  K  }1 g  U$ ^! p7 ^3 u/ a
注意,配置的Keil工程,默认是没有设置下载完自动复位,我们需要按一下Nucleo 板子上面黑色的复位按钮,另外默认的配置下,有一个以太网的初始化 “MX_ETH_Init()”,需要接入网线到路由器,不然初始化不通过,会跳转到Error_Handler();
  1. if (HAL_ETH_Init(&heth) != HAL_OK)
      z% P/ X9 `; P, C: n) d" R  B
  2. {; K! |2 P8 n# G$ F) v0 V7 h
  3.   Error_Handler();
    8 q/ ?  H* L6 k- f
  4. }
复制代码
" R! K5 y( ]" ]5 f
二、移植Letter Shell1 g( H, D0 a6 p: v( v
下载github上面的源代码,解压出来。3 g4 `. k1 c+ L1 i0 @& ^$ G
$ Q. c6 O1 |7 x6 l! {: p8 }# A
20210124230430874.png
; @  Y/ ^; N/ [8 s8 S/ {
3 |- Y+ Y2 o6 t6 odemo 有一些平台上面的例程/ u3 v8 R% \4 @8 o
doc 是功能演示( v; Y% F4 [4 [
extensions 有一些扩展功能- f  l- y7 V; t+ ]
src 是源代码) L7 G6 }. i; ^, y
tools 是一个用于遍历工程中命令导出的工具,位于tools/shellTools.py,需要python3环境运行,可以列出工程中,所有使用SHELL_EXPORT_XXX导出的命令名,以及位置,结合VS Code可以直接进行跳转! P  P' }1 x$ S/ d! F& \

, g5 H7 V! U$ w我们在STM32Cube 的工程项目下新建一个文件夹 Shell,然后把 src文件夹下的源代码都放进去,遵守开源公约,LICENSE也要记得放进去。放进去之后,demo\stm32-freertos 目录下还有三个文件,我们也拷贝过去覆盖即可。5 r4 L) |6 Z8 k. E. I

1 `9 G7 T6 u3 u$ Y 20210124231354443.png
* ?4 {6 V# [1 k$ Q1 @+ J1 N! E- u# r0 I3 Z( d
然后在keil工程下添加这些文件。
* b$ X* z! e) S* C- A' L5 z  ^# _. \. {1 ?2 O" Z7 Y
20210124231834258.png
' r$ X- b4 z& y* P2 W: W. b2 \
6 \- J7 V+ W; f. g$ _5 V( Y+ Z. {编译一下,此时会报错# r, m$ l2 ?; e* Y& }/ I& ?) s
  k" z) k/ F: _2 X8 [. v
  1. ..\Shell\shell_cfg.h(15): error:  #5: cannot open source input file "stm32f4xx_hal.h": No such file or directory
复制代码
2 Z% M" h/ ~  ^6 p# `
原因是letter shell的demo使用的是F4的板子, “shell_cfg.h”,里面包含了f4的头文件,#include “stm32f4xx_hal.h” 。我们这是 F7的板子,并且是STM32CubeMX生成的工程文件,所以我们只要替换成 #include “main.h”,这样改了一次以后,以后换芯片系列也能很方便的移植了。再次编译,仍然会报错。* x3 ?& X( D# J7 f
; i0 f3 V" e% }
  1. ..\Shell\shell_port.c(13): error:  #5: cannot open source input file "serial.h": No such file or directory
复制代码

6 m: u7 w" t; e6 S6 Y这是因为 “shell_port.c” 中有 serial.h,看名字,这是与串口相关的文件,我们把这种不需要的头文件删掉,只留下两个头文件就可以了。
: R; D) v* B% m$ s/ c6 ?. c$ ?8 j3 p' \8 L% r4 E# |
  1. #include "shell.h"! h3 y1 T  a7 \+ Y2 w: D& L% ~6 ?" Q
  2. #include "usart.h"
复制代码
5 `7 @. m! d! E$ i: ?0 I
下面两个函数是shell读写的实现,里面使用的是固件库的函数。9 H$ g4 y3 j% T$ z% [' S- T9 g

: s# e5 g% z1 C; B$ N. G
  1. /*** d! B+ v) J3 u9 s# J
  2. * @brief 用户shell写
    2 X- W! q- e! p7 j
  3. *
    " @& F2 F; v- Y9 n+ F
  4. * @param data 数据  f, y1 d3 r% g# }1 n; u
  5. */$ T+ j" S+ [$ o- Z* X' O
  6. void userShellWrite(char data)" m' Z. n: E) H2 k6 ~5 q) W
  7. {- p$ e& K% u, U3 F
  8.     serialTransmit(&debugSerial, (uint8_t *)&data, 1, 0xFF);# [! @; Y) @7 Z9 z
  9. }) a+ V' t- B5 E% K

  10.   }( e: u7 i( \  r
  11. /**
      U9 u" \; W& I( O
  12. * @brief 用户shell读6 K) b4 }8 T, b1 z2 \4 u
  13. *
    6 Y2 C# Z7 M1 A/ X2 D5 v: O
  14. * @param data 数据! c1 q- J% E  }) p; H& l
  15. * @return char 状态1 f2 P% k0 |3 u! `% [" ^" [
  16. */
    8 F0 C6 Y, y1 Y  v) U' [1 J' a
  17. signed char userShellRead(char *data)% u% |3 N! U% J! q5 `( j
  18. {$ B% H; E, j* j: l
  19.     if (serialReceive(&debugSerial, (uint8_t *)data, 1, 0) == 1)+ c9 C8 N8 q6 a7 l
  20.     {0 D" j" z- n$ K0 D# F  @4 {
  21.         return 0;: J/ r8 \% g, d' {; C' R
  22.     }8 s/ x6 b8 i  W. ^% Z5 G# c
  23.     else
    % T# c% d4 r/ T: R' `  _5 W; t
  24.     {. ~  x% W; n* I6 Q: Q
  25.         return -1;' T( s! \1 n! r. t, z5 j
  26.     }
    , [9 E: [. r& @
  27. / e; G: F& n* F: {6 ?3 l$ n, ]- ?$ X
  28. }
复制代码

. N; D8 o: Q. w* u既然使用了STM32CubeMX来生成工程,这里我们改成HAL库的形式。
: H: K( Q; k) P- e: q
4 A; @2 u/ b$ S+ [/ F+ D, o+ j" I
  1. /**% j$ P* Q* [/ |* i: ?
  2. * @brief 用户shell写
    * V( g' w) c# @5 z5 g5 d; E: m3 H. K. c
  3. * % Y/ c% D+ U: ~6 l0 C( c. }  [
  4. * @param data 数据4 k& o6 z5 L6 x; O
  5. */
    # z8 Q2 q5 e1 K) r2 D
  6. void userShellWrite(char data)
    ) {; x) k) O" u: U. |4 {
  7. {
    , B0 L0 J/ \/ q2 i5 E8 D  k
  8.   HAL_UART_Transmit(&huart3,(uint8_t *)&data, 1,1000);
    + M# C# C- R* m/ b
  9. }! q. s8 {0 Y7 ~: G: c0 g1 `1 A
  10. 6 N- p: w( k- l1 S" e

  11. 7 ?- J7 S5 C$ b% n7 \' Z
  12. /**& _6 W8 r3 O9 I0 G( a, D/ s
  13. * @brief 用户shell读) v9 @& x, ^) `0 W( `
  14. * : K3 E- L( J+ Z& R
  15. * @param data 数据4 ], h3 t$ @0 w- k* ]* D
  16. * @return char 状态. r; [' c/ {8 y' J* o
  17. */
    * U7 b2 @7 R- t5 J9 z) p( z
  18. signed char userShellRead(char *data)0 _8 U1 {# c# J3 q; ?& k& X* l
  19. {
    # ^( i9 O* Q* C# U' A9 W% P: @
  20.   if(HAL_UART_Receive(&huart3,(uint8_t *)data, 1, 0) == HAL_OK)1 D, e/ K/ S6 Z# t) Y6 Y& C, n9 d# M
  21.   {4 y; U6 i% _) @- Q+ R- f
  22.       return 0;
    8 P- ?- n9 F0 z) J- |
  23.   }
    ! l: L7 G% V- z2 D* ?
  24.   else& {" D( p' `& g; H# V/ d
  25.   {
      s! ~% }6 K& o( ]5 m
  26.       return -1;
    2 @4 @0 m) K+ m# p
  27.   }' N6 a9 R8 A- V3 E9 L8 r# f
  28. }
    3 j% d, A8 P5 l5 W5 B# E8 j1 Z
复制代码
7 N: i+ ^8 v: h) e& `8 N
再次编译就不会出错了。( T& S7 U* S+ A

4 E- U4 L. Y7 E. e0 i* V三、Letter Shell的使用
  G& H# b1 [; ygithub 上有具体的使用说明。我这里是下载的最新版本,3.0.6,这里也是根据这个版本进行一些解释性的说明。
  a! J9 a1 m9 t7 u6 x7 b# N5 U. N6 C, j& u# ]% c% A% E8 T1 A
3.1 定义shell对象
2 R" x) J5 z# j8 X% V  v
在 “shell_port.c” 中定义了 shell 的对象。这个Shell结构体定义了历史的输入,读写对象的函数指针等等。4 P/ }" L* _( {) K. j

: ?4 J+ b$ s/ o
  1. Shell shell;
复制代码
. O7 p( l% t9 v$ n
3.2 定义shell读写函数) H! m5 w0 I: A0 \7 W7 X
定义shell读,写函数,函数原型如下:2 Q4 X3 M, [2 }2 P
) a8 e  Y) W4 w; v) o7 L  ]5 e
  1. /**
    9 S3 N& H; h& U, {, q+ k* p( ?
  2. * @brief shell读取数据函数原型" O+ ?/ p6 B- W7 w2 h
  3. *0 ?% t; F! d/ J
  4. * @param char shell读取的字符
    % Y& P2 g+ c6 A
  5. *' I" ?2 ^0 g, b8 E& z: i
  6. * @return char 0 读取数据成功
    ' y$ r& k& u; j$ H2 @/ v! h1 P- E
  7. * @return char -1 读取数据失败8 J* b8 Q1 G' d1 P
  8. */
    / ~7 a; l# g* h7 C, g
  9. typedef signed char (*shellRead)(char *);+ ]6 j3 N9 d. k
  10. $ d; P* P2 p9 z
  11. /**" v4 \4 f  ~8 z+ R% k; f" w
  12. * @brief shell写数据函数原型
    * o7 [+ l; x  G( E6 |2 P+ B5 c* F
  13. *
    ( H3 \' @8 O2 x1 ~
  14. * @param const char 需写的字符
    " a) o! ]& p1 h$ G- }# Q9 f0 n
  15. */2 x, U- n8 D( E5 n0 W9 {
  16. typedef void (*shellWrite)(const char);* ?: G- D- f( ~2 J! v5 u
复制代码

* B7 Z6 f+ V; e1 l6 a+ H+ c8 W' }我们在上面已经进行了修改。
. V# \- f  r5 c  t9 g
, r" T6 Y4 N, w( o* h9 {: x, v0 R3.3 申请缓存区
1 V- Q( d4 U5 w; r4 o申请一片缓冲区
$ x$ a& D, A  b+ T7 V4 B$ b& l! F( g- j% n3 ~+ ^& ?6 s) P1 E
  1. char shellBuffer[512];
复制代码

/ ?( T) |% r6 S+ o( ^; H7 m: @1 k7 U+ h3.4 调用shellInit进行初始化0 Z6 ~& T) |6 l: ?5 I, ^
调用shellInit进行初始化,函数实现如下:* i+ Q. \& z& i4 ?# D
2 o# y+ |: H: F/ y$ e, o1 Z  b
  1. /**. L* y# ^' n3 D8 c
  2. * @brief 用户shell初始化
    2 I, ^, D: [. @$ s* Q& s5 X! k
  3. * 6 F3 f% I2 q7 d4 E( M6 n1 c
  4. */
    1 K1 ^' o  w% t$ k  g1 B8 x
  5. void userShellInit(void)
    ' ]0 A6 a# K8 H1 s: n
  6. {+ Y; U% \2 ?5 V5 _: h
  7.     shell.write = userShellWrite;6 t1 T! y3 |: f7 ]
  8.     shell.read = userShellRead;0 _/ o. D5 E4 Q
  9.     shellInit(&shell, shellBuffer, 512);
    ) O* M0 o( y" N; j
  10. }
复制代码

. H  d% B  \1 x1 Z3.5 初步完成shell的初始化4 I- G1 {3 h8 O* J* c' b5 P
以上步骤,除了要修改shell的读写函数,其他的在shell_port.c中都已经实现了,所以我们在main.c 添加头文件
4 L/ P5 I0 N+ k6 D! @8 u8 M  a4 ^- j0 C3 G* z! G* U% n4 K
  1. /* USER CODE BEGIN Includes */
    1 F/ ~9 U2 P! u. s" Y
  2. #include "shell_port.h"
    3 W4 \7 j/ F5 _! y2 B( s
  3. /* USER CODE END Includes */
复制代码

7 v& t* i! B) W1 ], Z5 j3 u然后在 main 函数中初始化shell,基本上就移植完毕了。! a! U+ D" G& v4 X
8 h! R& c; o1 D4 ]$ [; f
  1. /* USER CODE BEGIN 2 */; E( d+ q1 U  p! E5 R
  2.   userShellInit();    //letter shell 的初始化- b  {* N+ L2 G+ Q
  3.   /* USER CODE END 2 */
复制代码
7 h$ _  `# Q% v- q
此时编译一下,还是报错,老样子,是因为没有 “serial.h” 文件,我们双击报错点,跳到异常点,把这个注释掉即可。然后再次编译,就没有报错了。0 a; M' V3 [. @0 D9 E- ~

; T  l; T6 W( X/ n; ~$ v( g/ q
  1. ..\Shell\shell_port.h(15): error:  #5: cannot open source input file "serial.h": No such file or directory
复制代码
7 B; W! j& g6 w# E1 ^( S
我们把程序下载到Nucleo。7 [; B& I: p( c. y2 ^7 q
然后打开SecureCRT 或者 MobaXterm 或者 “putty”,建议是使用MobaXterm,因为这个功能强大,且有免费试用版。# S2 H4 g( U4 ]! b" @* F0 J! w

6 u  U5 j, r2 }8 ^! r' l* o我们需要建立一个串口连接, SecureCRT 点击快速连接, MobaXterm 点击 Session ,然后找到串口的选项,串口的端口就是 STLINK-V2.1的虚拟串口, 波特率为115200,其他的默认不变,点击 OK$ k* a% k0 t; L; n* f  S4 u$ y! K

9 v  W' d& k) n/ K( w 20210124235734855.png
) R% e2 s& f( h, B9 q7 V" B' B5 d) b* T! K8 K
由于我们还没编写串口接收方面的函数,按下字符是不会进行回传的,这里我们先按一下复位按钮,接上网线等到初始化完成后,就可以看到 letter shell 初始化完成后的串口信息。6 ]0 t0 D  C% D4 M1 z( M: a
1 ]* ^' z: ^7 r, M
20210125000101173.png ! `( _9 d! W+ b# s
- X; b& `- F8 P: O( O# }0 m* b
四、Letter Shell的进一步了解; D# `- K% w* J& R* I0 E3 J. g
第三节已经完成了Letter Shell的初始化,在这一步,已经能够shell初始化已经打印的功能,但是要想使用好letter shell,我们还需要对letter shell有进一步的了解。
$ T' b0 ]( J: L# y8 y% Y
- \2 T/ x# E) N, |7 U/ _4.1 宏定义
4 q  U6 B9 c* ?; _在文件 “shell_cfg.h” 中定义了各种各样的宏,用户可以根据不同的需求来配置宏。* w& L2 d  Y7 Z7 r+ T
下面的表格列出了各个宏的意义。! {1 e/ Y1 f* ?

0 k4 i' S0 ?( R. H, N# t' R' b Z9[D2ZUY1[R~NU1CT(4F8BN.png . Z* U2 S2 W- c9 s1 U* s" l0 n, k* n
6 Z- W# J4 s' H# M- ~
在文件 “shell_cfg.h” 也有具体的说明。- N( O, z* y/ O6 L3 Q

* m3 V( M; J3 ^6 i5 D
  1. /**
    6 n1 O0 X, i; J
  2. * @brief 是否使用默认shell任务while循环,使能宏`SHELL_USING_TASK`后此宏有意义- V, T: m/ g. W5 `) Y
  3. *        使能此宏,则`shellTask()`函数会一直循环读取输入,一般使用操作系统建立shell" \4 G: y3 _7 ]" Y: |7 D: f; E; Z
  4. *        任务时使能此宏,关闭此宏的情况下,一般适用于无操作系统,在主循环中调用`shellTask()`
    7 s, @1 B) ?8 D: l$ c4 m! X
  5. */
    5 {' u: t: L2 D; x* G2 k3 K# E% b
  6. #define     SHELL_TASK_WHILE            1: x/ z7 v) D! R# p, |3 v

  7. # z* |& K4 c) [' H
  8. /**
    0 c" x1 W. s6 D4 C
  9. * @brief 是否使用命令导出方式! @( c) m6 \  ]( @+ O8 j
  10. *        使能此宏后,可以使用`SHELL_EXPORT_CMD()`等导出命令
    1 P8 K, Z) n* `$ R! s6 N, G6 Q4 D8 i# m
  11. *        定义shell命令,关闭此宏的情况下,需要使用命令表的方式
    6 Z# y' M+ @& @  L; _
  12. */6 j2 `( U) m& Y" M3 W; }# P
  13. #define     SHELL_USING_CMD_EXPORT      1
    0 \5 @" n/ a& g3 l

  14. 9 d1 W7 d! L0 M! k
  15. /**
    ( D# z& s5 A& e$ A, ]/ b
  16. * @brief 是否使用shell伴生对象
    0 Z- E! I8 E6 D3 T! [
  17. *        一些扩展的组件(文件系统支持,日志工具等)需要使用伴生对象. T$ k$ L0 [# c
  18. */! z- H; S# _' I; i1 Q# q
  19. #define     SHELL_USING_COMPANION       06 P+ C# q6 Y) ]" ~. K
  20. & I2 V% t8 s) Y
  21. /**
    0 o/ K5 y+ d% q; c/ z5 p
  22. * @brief 支持shell尾行模式
    7 e, a+ f0 U% V) _- c# Z
  23. */' C! N: a1 i0 `* A$ a
  24. #define     SHELL_SUPPORT_END_LINE      0
    + t  i* e8 s) c6 v# W* E, f* y

  25. ; P' S- X% ~  @7 H+ m' s* Y5 c/ z
  26. /**
    2 z; U7 a% \4 V4 O6 X0 \. e7 [  ?
  27. * @brief 是否在输出命令列表中列出用户
    1 b/ m4 K# Y) u' Y. c# z! X5 ?
  28. */
    ' _; t0 W! y6 z8 f
  29. #define     SHELL_HELP_LIST_USER        05 Y# D5 B6 d5 O! S

  30. 5 |  G- n% n8 i7 M
  31. /**6 {. _) x  t2 Y/ i+ X& ]. ^
  32. * @brief 是否在输出命令列表中列出变量
    3 g' L+ `: i: {/ X+ n
  33. */2 W" A1 x' v5 [$ F5 |2 B7 |( ^# k. h" W
  34. #define     SHELL_HELP_LIST_VAR         0( m& q+ Y. f8 n, R9 m
  35. 9 g6 i* j2 l2 @- A2 u
  36. /**
    7 ?7 w/ g# ?; F% S5 J/ |
  37. * @brief 是否在输出命令列表中列出按键
    6 m) Z- b+ F, V
  38. */
    ' K: t- U# ^$ C  `. q) K5 x- B
  39. #define     SHELL_HELP_LIST_KEY         0
    % _8 v) F# x) _) m- z% s
  40. 2 A2 [; B; s, `5 L! c. A
  41. /**
    ! J# q: F- j  l
  42. * @brief 是否在输出命令列表中展示命令权限) S/ U5 [! P7 S) }5 X2 K/ S) H$ `
  43. */
    % S" B' S$ \, I& c, ^+ w
  44. #define     SHELL_HELP_SHOW_PERMISSION  1, C# T4 b) }, f1 {9 B! {

  45. % J" c; V" D; i2 f* A9 u
  46. /**, V- h, Q$ b0 [% d& w. o* x! P4 B
  47. * @brief 使用LF作为命令行回车触发# f) z7 T& {% l
  48. *        可以和SHELL_ENTER_CR同时开启
    3 s: ?+ V1 }. v/ n! U3 W) ]
  49. */
    9 U# j0 T8 ?* A0 ~! k; p/ P6 W
  50. #define     SHELL_ENTER_LF              0$ v  h7 G: t7 h

  51. 8 E- l, |; y4 b- D9 ]+ m
  52. /**
    0 F1 O3 o5 G1 f% H3 T% }' r
  53. * @brief 使用CR作为命令行回车触发
    6 D' m$ M1 N# |5 B8 ^7 [
  54. *        可以和SHELL_ENTER_LF同时开启) t4 ]6 U: p2 A
  55. */
    + p. g2 R2 r$ ]/ \2 ]
  56. #define     SHELL_ENTER_CR              0
    + v9 u& `! n( |$ s3 F
  57. 9 X, ]2 `' {, D  @( i" b
  58. /**! f* L1 I: c* L* j9 r9 ]2 o$ o9 f
  59. * @brief 使用CRLF作为命令行回车触发+ q5 Y$ \  M! `
  60. *        不可以和SHELL_ENTER_LF或SHELL_ENTER_CR同时开启
    & R) B3 o2 n' s# z
  61. */
    $ D, P, o, G3 L+ }" L2 }
  62. #define     SHELL_ENTER_CRLF            1
    ; e3 p: u2 m4 K' ?! ?$ F, [
  63. 0 m* y. C  I* T2 B1 D* m
  64. /**6 A  w8 l2 P( ~
  65. * @brief 使用执行未导出函数的功能
    ) Z/ {2 a7 I6 ?4 l& {8 {" x0 [, v
  66. *        启用后,可以通过`exec [addr] [args]`直接执行对应地址的函数
    4 {8 Z  ]& q! e2 B! w
  67. * @attention 如果地址错误,可能会直接引起程序崩溃
    # d& P9 t* c# @& r
  68. */
    4 I, @7 E" p3 S/ v  c) G
  69. #define     SHELL_EXEC_UNDEF_FUNC       02 J! E# _) d- w; L! y

  70. + m5 @9 U, ?( l6 K3 b
  71. /**
    & |; q  r/ N& K5 R
  72. * @brief shell命令参数最大数量3 |8 A) R7 d9 j) E- T0 m. l! z
  73. *        包含命令名在内,超过8个参数并且使用了参数自动转换的情况下,需要修改源码
    * F, e8 F- x0 t* q$ ^
  74. */" u5 T9 [* n' P! f% {8 ^
  75. #define     SHELL_PARAMETER_MAX_NUMBER  81 p" c8 j: r! Z, l9 d* Q
  76. ' ?' l* L/ \  K' u  Y+ }5 ?
  77. /**
    . K# h7 c% X4 ?9 T& F% ]. f
  78. * @brief 历史命令记录数量
    " ]4 @& t, i: j$ M8 c" e
  79. */  y4 F: y+ ^8 }! u
  80. #define     SHELL_HISTORY_MAX_NUMBER    5
    ; M' l3 U" y9 ?- @9 W3 V
  81. # J9 o( N" s4 P' x3 U% |
  82. /**# u8 `9 G" {: X# H4 J6 W! A: Q
  83. * @brief 双击间隔(ms)
    + Q! @% S1 m; ?: ?4 s" L( ~& h( R
  84. *        使能宏`SHELL_LONG_HELP`后此宏生效,定义双击tab补全help的时间间隔2 P( `% g$ H; W0 b& Z/ X
  85. */
    & O. @" y  b3 c9 ?/ k( B9 ^
  86. #define     SHELL_DOUBLE_CLICK_TIME     200
    & }- F" ~# @4 N" O- w/ X

  87. 0 ]0 ]/ p4 d# [7 L6 `( _6 ?
  88. /**4 ]7 N  R& x, H  B' J
  89. * @brief 管理的最大shell数量; s2 E0 ?$ c4 P8 M- f
  90. */+ Y' n# C6 s8 B" t* \
  91. #define     SHELL_MAX_NUMBER            5
    & y5 p1 d9 W# J5 N% w' ?& e

  92. 7 m, \3 t; W! D) ?1 Q+ P, J
  93. /**
    : [) I+ q" ?8 Y9 B: [2 g7 B
  94. * @brief shell格式化输出的缓冲大小& U9 U! Y& S+ C% _6 v  o& ^
  95. *        为0时不使用shell格式化输出1 p$ u  w9 G& }7 a, W! ~( Y# G
  96. */
    3 G% M' W# e0 s
  97. #define     SHELL_PRINT_BUFFER          128
    $ _  X, _$ m( P# m$ E( J* @

  98. 7 Y+ |: Q. N- O5 H+ Z2 g1 {
  99. /**
    4 H9 X2 M5 E" B+ w+ [$ y
  100. * @brief 获取系统时间(ms)/ E9 K2 M* r+ Z
  101. *        定义此宏为获取系统Tick,如`HAL_GetTick()`7 p  \' r0 b3 o9 Z$ G$ x7 Y
  102. * @note 此宏不定义时无法使用双击tab补全命令help,无法使用shell超时锁定7 [! n% G# l* ?5 I5 C3 Q, H  d
  103. */$ l0 {2 w! Q; D& g
  104. #define     SHELL_GET_TICK()            HAL_GetTick()) F) ]0 H% u" w( Z8 z/ K# O

  105. ) I. u. E( E& U4 p: C6 n& r$ U8 l: ?( V
  106. /**- L+ c, Z* v* j& B1 U; t
  107. * @brief shell内存分配6 K' M5 g/ S& _) }9 R, h, p
  108. *        shell本身不需要此接口,若使用shell伴生对象,需要进行定义
    5 A( ]. J: x' Q& P0 @& ~
  109. */
    & v, V; g  |/ G* D  ]
  110. #define     SHELL_MALLOC(size)          0! p- I$ @3 U2 ~4 R$ G5 b

  111. 4 r7 N2 {- w- @6 s" a2 q6 x6 K  C" y
  112. /**( r# A) f% `' k: }5 X; M
  113. * @brief shell内存释放  _4 H7 [( Z$ Y; @) X3 o, g
  114. *        shell本身不需要此接口,若使用shell伴生对象,需要进行定义$ f$ H. ?$ r8 {
  115. */
    & t! w) @) T, `' b1 x4 E& m1 O
  116. #define     SHELL_FREE(obj)             0
    3 j: X% D# s) |
  117. + z! I7 g$ p& o1 t: G# z
  118. /**
    ( U6 d2 ]7 c$ x# m- U
  119. * @brief 是否显示shell信息
    - G/ {9 l4 }" |  d& s
  120. */
    3 a2 |; z" h& P% @4 @
  121. #define     SHELL_SHOW_INFO             1
    6 T) _1 L! l- C

  122. 6 f/ i2 Y% L$ q- A
  123. /**
    % q( {# q7 y- k" B7 |3 O% I# m
  124. * @brief 是否在登录后清除命令行% R* g4 J3 _1 n) c# j
  125. */- e1 W/ Y# F% \2 v7 `* {
  126. #define     SHELL_CLS_WHEN_LOGIN        1
    % z9 y1 h$ X# [' I( h' H

  127. 8 z5 W! U  d, m3 U& b. m
  128. /**( c) F# d; i- b8 b
  129. * @brief shell默认用户* t! g5 ~( J$ u5 m
  130. */& R( u6 C* |2 S' \2 T3 z
  131. #define     SHELL_DEFAULT_USER          "letter"
    6 ]5 X8 r; ^+ |0 X% W

  132. 6 x  z$ @% e2 v) D+ F& p( I! H
  133. /**1 C1 [( C* l' s, G- W
  134. * @brief shell默认用户密码, m3 ~2 M% V& s
  135. *        若默认用户不需要密码,设为""
    " ~0 I. F( I/ k) h
  136. */( t3 N& `, }/ m, p
  137. #define     SHELL_DEFAULT_USER_PASSWORD ""
    % a! E6 }( D. n  O
  138. - s" [# e2 J/ p/ S& }$ R  C
  139. /**
      c- R( S/ t8 C0 R( n1 l
  140. * @brief shell自动锁定超时
    3 B1 C6 R  K) k9 ~+ s
  141. *        shell当前用户密码有效的时候生效,超时后会自动重新锁定shell0 O$ k& `" c  e2 N0 z) i
  142. *        设置为0时关闭自动锁定功能,时间单位为`SHELL_GET_TICK()`单位
    - x9 k% A; |" Z; H
  143. * @note 使用超时锁定必须保证`SHELL_GET_TICK()`有效3 [' @9 [5 F% p0 B
  144. */
    * u- u$ B. q0 p/ J
  145. #define     SHELL_LOCK_TIMEOUT          0 * 60 * 1000# Y7 m( H6 _" ^) G
复制代码
: n/ x) Q, P* k% A
下面介绍一下比较重要的几个宏:0 l7 v6 ^4 S7 |' w4 |' f
$ \( [2 m& \3 Z- P( S' f
4.2 SHELL_TASK_WHILE0 G5 |+ w  a" a# }5 G
这个宏仅在这里面生效,这是在使用操作系统的时候使用到的,它会一直轮询地读取串口数据,然后调用 shellHandler 解析串口数据。这仅仅是个范例,因为这里没有进行任务切换,所以会一直堵塞在这里,而我们如果要使用FreeRTOS创建一个线程来处理这个任务,需要使用osDelay来进行切换。因为这里一次只读取一个字节,所以如果任务切换间隔过大,可能会丢失某些数据,另外,因为接收串口的时候要进行回显,所以任务间隔过大,也会影响操作体验,所以我们在串口接收中断调用 shellHandler 进行处理。我们不需要在线程中一直读取,所以这个宏 SHELL_TASK_WHILE 设为0,但是设为1也不影响就是了。* j! Z. g) _- I' N, G6 h
2 \' T$ L& C/ {# {) j8 \
  1. /**
    " N" k0 ~3 [  M  G  P# M
  2. * @brief shell 任务
    : N( }5 A7 @( C2 l7 ~
  3. * : `. i" y  }+ h% K
  4. * @param param 参数(shell对象)( e$ Y6 m- o1 a3 R" _
  5. *
    * o" A) c2 a# z- h5 ^# R9 W
  6. */
    ( E. d1 B2 B" H! J
  7. void shellTask(void *param)
    & L2 ?2 y, C$ i0 }( P0 J$ f" K2 T
  8. {
    . o$ f- _: r2 t
  9.     Shell *shell = (Shell *)param;: a7 M" f; z5 X% u8 d# W
  10.     char data;, O8 ^& ?/ Z# L, L5 n7 Z% `: |$ n+ F  z
  11. #if SHELL_TASK_WHILE == 1
    9 j* D1 i3 X$ i5 z# X+ O9 w3 H
  12.     while(1)
    3 R* R3 T- o5 Z/ B
  13.     {
    ' H& w0 l4 q- n. O" _: a  l( V
  14. #endif
    " a8 b+ a( f& S7 P% \
  15.         if (shell->read && shell->read(&data) == 0)
    1 S' y) x) B5 h. i8 ?* |
  16.         {  _; H3 K6 Y8 l2 ]
  17.             shellHandler(shell, data);' Z" J: }; q" V7 x. |5 ~7 k
  18.         }
    " Z0 a  W/ K- ]1 E
  19. #if SHELL_TASK_WHILE == 1
    % v% \+ h, r1 K
  20.     }6 b, F8 r. K( s, A: D9 ]5 Q$ t, Q; t
  21. #endif1 {! P6 a5 M" F$ F
  22. }
    , u; D. X  `. P& E2 {% Q
复制代码

9 T/ {  e& N: l4.3 SHELL_USING_CMD_EXPORT, O# G5 O3 V/ D) h- ]8 m: U
命令导出功能,通过这个宏,我们就可以在命令行中输入指定函数的名称以及传递函数,就可以直接调用该函数,用于调试,十分方便,所以这个宏不变,默认为1.5 R3 L0 F* \8 p+ U9 V# E
* ~# f, x* K' U/ K# U: Y! O
4.4 SHELL_USING_COMPANION
# R* N% Y# W% q作者定义的伴生对象,用于一些扩展的组件(文件系统支持,日志工具等),但是目前这个功能还不是很完善,所以这个宏默认设为0,不启用。3 Q1 U2 f7 [. O: ?! @3 ^
9 w1 I- ~1 Z$ x- g1 u# Y, a
4.5 SHELL_ENTER_CRLF
" ~; z& M) X$ `- G& l

8 X5 @' H. U  ?/ c这个与 SHELL_ENTER_LF 以及 SHELL_ENTER_CR 互斥,作为命令行回车触发,使用的SecureCRT 以及 MobaXterm 是使用 CR 作为命令行回车触犯,所以这三个的配置为) X( E) a7 W& ~/ F7 l
" g( D3 V6 E& g( K* S
  1. #define     SHELL_ENTER_LF              0
    . Y4 D" A1 l4 N1 d/ b
  2. #define     SHELL_ENTER_CR              1* b# T5 |/ d6 z1 b2 A! @
  3. #define     SHELL_ENTER_CRLF            0
复制代码
# b5 C2 f0 `! t2 g$ L6 @: V
4.6 SHELL_PRINT_BUFFER3 y8 t7 C7 R6 ^$ o/ D" o
这个宏定义了格式化输出的大小,在 shellPrint 中使用到,使用方法和 printf 类似,只是注意不要超过缓存大小。4 I0 _4 }' K# n  l  V( r5 ~6 F
这个宏也是按照默认值就可以了,也可以根据自己的需求进行修改。0 N% N6 @: u) b! u

0 e; c9 D' `; e0 C6 K6 J+ U4.7 其他的宏; x) x% i. v0 ?9 H& u1 j, d& \
其他的宏理解起来很容易,这里也就不进行细说了。
1 B) w; P" O/ |' `最终宏的定义如下:
7 A- o, u# }/ |0 y& ]5 D0 M/ h, O# b9 F2 I) c  m. e" X
  1. #define     SHELL_TASK_WHILE            0
    3 }1 N) `! U: [9 ~
  2. #define     SHELL_USING_CMD_EXPORT      1( K. `$ I  R5 {& t5 F% n( F
  3. #define     SHELL_USING_COMPANION       0) ?7 r& N; h0 v5 K5 m
  4. #define     SHELL_USING_COMPANION       0( z) B& v: G, Q3 f) p. `
  5. #define     SHELL_SUPPORT_END_LINE      04 z5 ^$ L2 J1 T4 h7 l, V  Q
  6. #define     SHELL_HELP_LIST_USER        0
    # w0 ^6 L4 v, X9 L8 `
  7. #define     SHELL_HELP_LIST_VAR         0
    4 v5 j/ G9 j& c. z7 p/ Z
  8. #define     SHELL_HELP_LIST_KEY         00 A+ S5 d# k+ Z, x# R
  9. #define     SHELL_HELP_SHOW_PERMISSION  1& L1 {& b& N! ^* `0 h6 o. p/ q& n, _/ Q
  10. #define     SHELL_ENTER_LF              0$ L7 C7 Z6 D, {8 b8 W( m
  11. #define     SHELL_ENTER_CR              1
    9 ~5 N6 j8 Y  [2 B
  12. #define     SHELL_ENTER_CRLF            0
    5 B4 I* X% c  c5 ^+ ]" w
  13. #define     SHELL_EXEC_UNDEF_FUNC       0- X5 A/ B9 c) [1 X. c! i' d
  14. #define     SHELL_PARAMETER_MAX_NUMBER  8$ l' {6 a% r3 \$ j) J5 _3 H
  15. #define     SHELL_HISTORY_MAX_NUMBER    5- e* E* P( g* G) `3 ~+ w$ R
  16. #define     SHELL_DOUBLE_CLICK_TIME     200) d! F: \8 h' D+ u: R% A
  17. #define     SHELL_MAX_NUMBER            5
    8 S3 A8 K; {& P8 K: T0 o
  18. #define     SHELL_PRINT_BUFFER          128
    . l( h8 r- F# s- a) _/ u, Q1 P
  19. #define     SHELL_GET_TICK()            HAL_GetTick()
    . |4 g) @0 l% D) y! Z
  20. #define     SHELL_MALLOC(size)          0
    2 Y1 W# Q* q4 W4 n! t, O2 A. c: ^
  21. #define     SHELL_FREE(obj)             00 C; ?% B' h) T* [, `8 ?
  22. #define     SHELL_SHOW_INFO             1
    9 R( V  N: v3 U7 u" ~. X8 t* o
  23. #define     SHELL_CLS_WHEN_LOGIN        16 {7 d  _( c6 P0 W4 H7 ~) a/ q" Y1 x
  24. #define     SHELL_DEFAULT_USER          "letter"
    ' o$ B$ U+ M+ |" k4 G
  25. #define     SHELL_DEFAULT_USER_PASSWORD ""6 z( {1 E! C4 @# g" a
  26. #define     SHELL_LOCK_TIMEOUT          0 * 60 * 1000
复制代码

' W* ^( H  @+ n+ t8 \- U% S4.8 shell的接收处理
2 j' x- \, m7 _: r/ W# r3 y$ l/ N要正确的将串口接收到的数据当参数传递给 shellHandler,先要确保打开串口的中断,HAL_UART_Receive_IT ,使用这个串口中断,需要定义接收到的buffer数组,以及接收buffer的大小。
, U9 T( d" n# H" g' w
1 x* R& {+ T* D# |) h- B# ~3 a5 z: m
  1. #define HAL_USART3_RXBUFFERSIZE         13 ^+ v9 o+ ~1 |) ~
  2. uint8_t HAL_USART3_RxBuffer[HAL_USART3_RXBUFFERSIZE]; //HAL库使用的串口接收缓冲
复制代码
  j. S; g6 [+ Y. V
在main函数中打开串口中断% s8 U+ k9 r, P- f" l4 f, Q
! N( r* U; o2 d& [( \% U* c; |
  1. HAL_UART_Receive_IT(&huart3, (uint8_t *)HAL_USART3_RxBuffer, HAL_USART3_RXBUFFERSIZE);//使能串口中断:标志位UART_IT_RXNE,并且设置接收缓冲以及接收缓冲接收最大数据量
复制代码

. I: l" x8 _: i. [: Q# m, p! Z/ ~+ v打开串口中断后,在串口中断中就能获取到串口数据了,在HAL库中,串口中断最终会回调 HAL_UART_RxCpltCallback,所以我们就在这个接收串口数据,然后调用 shellHandler 进行解析。4 V+ |5 |6 d- E' K

7 l. N  b& B4 n6 Y1 U4 J/ v
  1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart). T7 o: |2 }- q$ a
  2. {
    & V; ^! z3 G  T% ]  D* c5 n
  3.   uint8_t udata;
    0 O3 w6 x7 m' L8 w5 A$ h+ r
  4.   if(huart->Instance == USART3)      //串口3的接收部分
    , X' Q. b7 ]2 M7 h9 A6 a. p# a
  5.   {
    # d5 |6 O6 X8 N4 L
  6.     HAL_UART_Receive_IT(&huart3,(uint8_t *)HAL_USART3_RxBuffer, HAL_USART3_RXBUFFERSIZE);     //接收串口的缓存
    5 R- N( n1 @: e* u- U7 X
  7.     udata = HAL_USART3_RxBuffer[0];# C& }6 I/ d( N( a1 C: M: Y
  8.     shellHandler(&shell, udata);
    4 C( a. g8 b, {
  9.   }
    + F! s" }/ |, p, k0 d9 {0 z$ A
  10. }
复制代码
. ^7 ]) ~& ~2 P9 L) ]5 t$ i- h
编译后下载程序,复位,这时候输入cmd 命令,按下回车,就会列出可以支持的命令了。后续如果自定义了导出函数,也会在这里显示。到这里,就说明了串口的收发是正常的,shell 也移植成功了。! Q6 t/ Y. C' `2 Y2 x
+ R/ x0 N. ?. S! i
2021012523522544.png 7 _- b1 F. y7 u
3 I% U) P$ B9 N$ b  r
五、使用Letter Shell 进行调试程序
" m& Z- w5 l4 f如同上面的 cmds 命令,我们用户也可以自定义命令,在编写完一个函数之后,我们可以通过SHELL_EXPORT_CMD 导出该函数,这样我们就能通过命令行来调用这个命令执行,以达到调试的目的。
  R, A2 C9 e8 W& Nletter shell 3.0同时支持两种形式的函数定义方式,形如main函数定义的func(int argc, char *agrv[])以及形如普通C函数的定义func(int i, char *str, …),两种函数定义方式适用于不同的场景。
* [$ G; ^; L2 B/ N' Q
' `1 Y7 s& Q! n9 p下面使用LED来举例。
) d, d+ a+ G: g  H# X
7 Z; ^! ^* X9 j, j' l8 l. I5 L4 I5.1 普通c函数的命令导出( {1 v9 r5 f0 _& l' E* i
  1. void LD1_ON(void)- J2 M5 c% f' K* R! y# \
  2. {, T& m/ j$ {6 \; X, i/ i2 [# @+ X
  3.   HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_SET);
    " n& p6 c( J; W, Q" ]; c
  4. }
    5 A! k7 y# _6 F8 C' `" }. I
  5. 2 g/ u. y) O+ G& }
  6. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_DISABLE_RETURN, led1_on, LD1_ON, LD1 ON);3 B( ]3 @' p, R: Q3 v! P0 A8 Y

  7. 8 H3 `0 Q% ~5 X5 ~+ a5 S! r, p
  8. void LD1_OFF(void)
      y) F/ ]; O! @9 n: O* K* c
  9. {5 `- |" K* i4 u* g
  10.   HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_RESET);
    5 D* W, F$ i7 `/ j% C
  11. }
    1 S/ P6 Z1 I4 k( e8 O" }# ]6 T
  12. $ b, r' X) `: L/ z, D" e+ m( Y# s
  13. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_DISABLE_RETURN, led1_off, LD1_OFF, LD1 OFF);
    ( I* D  u; X! R; t8 c, W% c; y
复制代码
( X, i0 O: V- V4 }' [1 c" h( _1 d
上面写了两个函数,顾名思义,LD1_ON是点亮LD1,LD1_OFF是熄灭LD1,SHELL_EXPORT_CMD 就是导出命令,各个参数分别是 命令属性,命令名,命令函数,命令描述。
9 u$ ^7 V5 Z  ~0 Y  ^: M  Y+ ?0 C& U4 R+ c7 C/ o9 l5 c4 x
  1. /**
    & s7 Z! _. }" M$ m2 H' w! `
  2.      * @brief shell 命令定义
      V" V; F8 `2 X$ b- f
  3.      *
    2 g. m7 B+ t: N( x5 v$ g) e
  4.      * @param _attr 命令属性
    * S6 ]5 Y  e8 ^5 Y2 N5 g, _  A
  5.      * @param _name 命令名
    8 S# q& `9 d8 U$ ?9 ?
  6.      * @param _func 命令函数
    1 I6 E; Y* _+ e$ h( N# z7 ~: Y% B9 p
  7.      * @param _desc 命令描述
    / ~4 U% C! [, P& o. q/ s" \
  8.      */
    1 ?. W9 e/ r5 E: K
  9.     #define SHELL_EXPORT_CMD(_attr, _name, _func, _desc) \2 q% {/ D7 R' t  P# v- w, k# }. p3 J
  10.             const char shellCmd##_name[] = #_name; \
    . E- \6 O$ _4 h, `1 f
  11.             const char shellDesc##_name[] = #_desc; \
    $ k6 _, c0 _" X+ V+ H
  12.             const ShellCommand \% S: b+ H0 C$ u; O1 c3 s) n0 B
  13.             shellCommand##_name SECTION("shellCommand") =  \
    ( u/ \* A* d) i, P2 ~" j
  14.             { \
    " `6 }$ v; Q6 V" F( n0 D
  15.                 .attr.value = _attr, \
    % [3 H  \3 I' x; P5 \
  16.                 .data.cmd.name = shellCmd##_name, \
    . L. K- p% v6 H% g+ ~; C
  17.                 .data.cmd.function = (int (*)())_func, \3 G7 E. w+ r- m+ L2 f, @
  18.                 .data.cmd.desc = shellDesc##_name \* J1 l, q; W7 h7 p* h6 r
  19.             }
复制代码
- J) E4 H" G; x9 E5 r6 O" T
5.1.1 命令属性! J; P& m9 l' P# \
命令属性 这部分在 shell.h 中进行定义,几个属性可以通过 " | " 来进行连接。属性有以下几种:
( S/ @9 F) g8 s- U5 ?3 o& F8 L6 z5 E- ]" p
  1. /**
    % T  E! b0 Q" p. @  R
  2. * @brief shell 命令权限+ Q% F2 S, M* u! x: b+ X
  3. * - {2 R5 f0 h1 j% C" t0 t
  4. * @param permission 权限级别) B5 A; Z  e  N0 t/ q; ]
  5. */0 s' Q1 v0 v8 ?2 l; ?7 u* Q
  6. #define     SHELL_CMD_PERMISSION(permission) \# J9 u" A9 u' t) C
  7.             (permission & 0x000000FF)5 n5 s" A5 I; k2 L
  8. ) v! g2 y9 I* J" x. ~- D3 P
  9. /**: M. m' Y* y, R) B
  10. * @brief shell 命令类型
    ; e- H6 V- R( f4 }1 }" T8 r
  11. * * a8 s+ {+ B$ }" q' x
  12. * @param type 类型
    9 G. g  z( I3 n' G4 X7 k
  13. */8 u% M7 M* r: d6 g6 b( A9 b1 G1 }- ~2 G
  14. #define     SHELL_CMD_TYPE(type) \' Q" W/ U- N  j
  15.             ((type & 0x0000000F) << 8)& b' j1 b! j4 G3 A9 D
  16. : {2 h0 b$ _( r% M4 h
  17. /*** p2 l+ D4 K" W& u
  18. * @brief 使能命令在未校验密码的情况下使用
    9 F6 [( Q8 O& @" K4 m- y! ^4 y
  19. */3 X" ?; k( z) T1 k; o6 Y; b* K3 g
  20. #define     SHELL_CMD_ENABLE_UNCHECKED \
    5 k  T% s: s: x, Q" Z
  21.             (1 << 12)
    + j) E3 {2 f) P+ ~! F
  22. ( o& d1 B: s+ f% i* K) j
  23. /**- o, t! f2 L* @. R; ~0 E# c
  24. * @brief 禁用返回值打印9 b& J% `6 i; l: w
  25. */
    ; f  t7 X$ C! c7 v  }# h
  26. #define     SHELL_CMD_DISABLE_RETURN \# R5 [! R) ^- ?
  27.             (1 << 13)
    ) D0 E  _" A# M% r
  28. 5 ^/ q: ]2 \! I
  29. /**
    . t: z9 P: P6 `( A8 h
  30. * @brief 只读属性(仅对变量生效)" ]" T1 c. \8 V0 e5 |  P* `  x
  31. */
    ; _& c  w* ^, c: r7 I
  32. #define     SHELL_CMD_READ_ONLY \3 K  z# _1 I( H6 l0 {1 C
  33.             (1 << 14)  @$ t8 {5 r$ F4 `  \
复制代码

) g# O% g- W8 N5 R6 T1 M0 A在上面的例子中,使用到的命令属性是
* K* T6 o1 E1 ^' N
: i/ i) |& c& G  Q6 _  w
  1. SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_DISABLE_RETURN
复制代码

- f, V, A1 f3 b. V6 z$ Q& F这个意思是这个命令任何用户均可使用、命令的类型是普通的C函数、执行完函数后,不在命令行上显示返回的结果4 Y3 s5 N6 U# ]; R" \+ @

% P& {# _# z, T5.1.2 命令名
# w; ?4 n1 D3 |1 n. b; q* m7 e1 i7 K命令名 在命令行中,输入命令名就能执行对应的C函数,可以通过命令行的 cmds 命令进行查看# m* H1 z4 c; p- |1 m
在上面的例子中,实现了两个命令名,分别是) A4 |' q& _% h" B, u; ?. }* X5 e

) v; t3 ]9 w4 _1 X
  1. led1_on
    / K# \* ?, j( V: I5 c* i. H& X
  2. led1_off
复制代码
6 q5 P1 |: y. ~) ^, q# C
5.1.3 命令函数" B% N- ]% f! q- h9 R4 K" l
命令函数 也就是我们在keil工程中,所编写的函数的函数名。! v$ ^; C/ }. ]. j7 A9 S
比如在命令行中,我们输入 led1_on ,那么实际调用的函数是 LD1_ON,输入 led1_off,那么实际调用的函数是 LD1_OFF0 V( W# ^7 A) E+ i1 v

$ U9 Z% X0 z) q6 ~. [  o: A4 s! n0 n5.1.4 命令描述
5 `4 @: G( r3 O- F2 S- D, Q, |  ~命令描述 命令描述出现在 cmds 命令中,它主要是简明扼要的说明这个函数的功能。
4 `; R4 p  k8 U2 E: x
" t: \1 z  c$ o1 Q. Q6 J5.1.5 实际效果
$ e% u) J9 y! _5 ]+ h8 @8 N如图所示,在输入cmds命令之后,会打印出我们可执行的命令,这里是多出了两个命令,led1_on 以及 led1_off,我们输入对应的命令,就可以控制LED1的亮灭了。
/ o9 L7 i* {; c( l- K
' w; o4 U' h5 F 20210126222149487.png
! R2 e/ G  p; V/ B$ K1 Q  f
) g+ H: R+ ^( V  D5.2 main函数的命令导出
! B/ e* L/ E  K0 Q# U一般我们写的程序,用普通的c函数的命令导出即可,main函数也可以,使用上也比较类似。使用此方式,一个函数定义的例子如下:' ?% Q% ~; T, J& J

- j7 V3 }* l+ b$ R5 x+ n& R
  1. int func(int argc, char *agrv[])0 T4 G, T2 x! l4 r7 F
  2. {
    5 a5 \+ ?0 {7 s
  3.     printf("%dparameter(s)\r\n", argc);+ z$ c2 N1 R6 R+ S% l+ e
  4.     for (char i = 1; i < argc; i++)# k2 `5 W+ z$ E0 p& F0 y4 ]# ~
  5.     {9 q2 k2 g% I8 L- A1 }
  6.         printf("%s\r\n", argv);8 B4 w0 J, `0 d$ x( Y
  7.     }  X# _2 t7 M: Z% _2 S6 N
  8. }/ I+ p# n# X7 Q3 z# e
  9. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN), func, func, test);
复制代码

: c1 g3 m) i& d终端调用
* U& t, c* S% Q- u* g- W# k, i2 _2 o
  1. letter:/$ func "hello world"' ^; q5 j( b, M. Z+ E
  2. 2 parameter(s)
    : c( j$ X  P! |; a: R4 c
  3. hello world
复制代码
7 _" ~7 o. h! m  d' h) B
5.3 带参的命令导出
% A. D: a1 y! }* Q% Z我们编写一个带参的函数,命令行是以空格划分传递的参数。0 M. N" @) A2 G( J6 P2 O7 p  ]
/ x. T! _( x% n; [& M
  1. void LD1_ON_OFF_ms(uint16_t on_ms,uint16_t off_ms). j) H% z: O4 F8 A' A  K2 e
  2. {5 F6 z' f. z2 O& ]( X7 m) G
  3.   HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_SET);    //点亮LD1( Q) |& X, d7 j  e4 D
  4.   HAL_Delay(on_ms);                                         //延时1 Z8 B2 }( `  O0 S" `0 u% ~1 `; Q$ g
  5.   HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_RESET);  //熄灭LD1
    5 j( f' t' C$ r- F& k
  6.   HAL_Delay(off_ms);                                        //延时# w, m- K8 {: C/ m
  7.   HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_SET);    //点亮LD13 p: k& A3 j  P
  8. }- L' M9 r. K+ e8 i: i9 d! f
  9. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_DISABLE_RETURN, led1_on_off_ms, LD1_ON_OFF_ms, LD1 on ms);6 f+ P2 d& c8 q& @, I+ t9 E  j
复制代码
- ]' c3 b( a( C* u0 y1 {
这个例子是控制LD1亮灭的时间,LD1首先点亮 on_ms 个ms,再熄灭 "off_ms"个ms,再重新点亮。# c4 r8 W$ W  W# \" c
输入以下命令,就能看到 LD1 先亮 1000ms,然后熄灭 100ms,最后又点亮的状态。6 R. c+ O( K) n( n) O4 u
3 y) @6 @8 t4 a
  1. letter:/$ led1_on_off_ms 1000 100
复制代码
这是输入一个数字的例子,也可以传递字符串,比如说我们要使用文件管理系统 FatFs 来管理文件,很多地方就要使用到字符串了,letter shell 支持伴生对象,里面可以扩展文件管理系统的功能。
' F0 g$ q& t5 l# e2 v+ O) h
0 v" u7 H8 |8 v) `fs_support作为letter shell的插件,用于实现letter shell对常见文件系统操作的支持,比如说cd,ls等命令,fs_support依赖于letter shell的伴生对象功能,并且使用到了内存分配和内存释放,所以请确认已经配置好了letter shell
3 ]# w# p3 k( b" t( N9 o$ @- p) \9 g. j4 r7 v; D
fs_support并非一个完全实现的letter shell插件,由于文件系统的接口和操作系统以及具体使用的文件系统相关,所以fs_support仅仅通过接入几个基本的接口以实现cd,ls命令,具体使用时,可能需要根据使用的文件系统接口修改fs_support,letter shell的demo/x86-gcc下有针对linux平台的移植,可以及进行参考: e% a5 G4 h: ~5 K- W7 v+ U( ]
/ t7 @! S- H, |  G1 ^3 e: \) Y* ]
因为这个功能作者还未完善,所以这部分的命令需要我们自己来实现,下面是我在 FatFs中对 mv 命令的实现,功能是在将 old_path 的文件移动到 new_path,或者是将 old_path的文件移动到 new_path,并且重命名该文件。* J( X0 Y; H# G& g! N' A* Z
0 x+ g7 i; q$ \8 r
  1. /**1 E  y/ P+ s' ?$ R$ ]1 v& h1 ], R
  2. * @brief 重命名/移动文件或子目录
    / \9 t. A' R1 `) n. `" i8 M* B- N3 }
  3. */
    5 t4 ]8 \0 [1 r4 c1 B; \
  4. void shell_mv(char *old_path,char *new_path)  c/ M5 q/ D8 G7 s4 j" Z
  5. {6 q9 |' T: D5 W* G/ B% G
  6.   FRESULT res;$ y1 K: `4 h' o% K3 g9 n$ t
  7. ) g; `- n% p% ?  y  c8 |; x3 u. @
  8.   shell_active = shellGetCurrent();   //Get the currently active shelll: R+ ]9 E6 C* _
  9.   res = f_rename(old_path, new_path);6 A- \4 B4 P" h! ^; U" C" A( {
  10.   if(res != FR_OK)
    - n; {. c4 R; h
  11.   {+ w+ g+ ]- {7 T" p2 z+ d; R/ C% J
  12.     shellWriteString(shell_active,"Operation failed! Error Code:");
    9 q$ ]$ B( ~1 C7 X2 q) l' p
  13.     shellPrint(shell_active,"%d\r\n",res);, s3 ]* ?5 h0 J& j
  14.   }
    - H% D; k' Q0 ?% S" u) j# w
  15. }& x$ U5 P, ?2 I0 ?! z
  16. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_DISABLE_RETURN, mv, shell_mv, rename or moves a file or directory);
复制代码
! e' i) ^- z# M+ R
输入以下命令,就能将 dir1目录下的 file1.txt 移动到 dir2 目录下,并且这个文件名将修改为 file2.txt。
  ^. ~0 ]! U/ q, F- G* Q. t
2 e; U0 L( U$ p& G9 B3 V
  1. mv dir1/file1.txt dir2/file2.txt
复制代码
5 b+ U! w: i& G$ o9 u& J
不过要注意一点,FatFs 的磁盘是以数字打头的,不像window,各个硬盘是以字符打头的,比如 "C:\file.txt"表示 C盘目录下有个 file.txt,在FatFs中,对应的目录是 “0:\file.txt” ,假如我们以 “0:\file.txt” 当成参数传递进去,那么接收是会存在问题的,这是因为第一个输入的是 0,在解析参数的时候,它会把这一整串字符串当成数字来解析。  R" t: w# @7 E6 X9 s  n- u% X
我们先找到解析参数的函数,可以看到 if (*string == ‘-’ || (*string >= ‘0’ && *string <= ‘9’)) 那么就是要解析数字,我们在这个判断中,再次判断,从字符开始到后面,如果出现了任何一个不属于数字的字符,我们就判定这个是字符串。而如果在空格或者回车命令前,全数字的字符,那么我们就判断这个是数字,通过这个方式,就能规避 FatFs 的硬盘号会导致参数解析异常的问题了。
2 ^5 \+ g7 _/ ~. ~; R
; P' b. E7 P* w! `( t; r
  1. /**7 q: Y5 v3 j  L& Y2 {6 d* m; m
  2. * @brief 解析参数
    & J1 [& ^4 |% m% j" v7 z
  3. *
    6 m9 W+ h, S" q+ c
  4. * @param shell shell对象
    / r5 R( y& N  X: r0 u
  5. * @param string 参数  H: g- x6 X) k2 i- f$ a+ Z$ R9 a6 {
  6. * @return unsigned int 解析结果4 r( @" r8 s# G+ b9 r6 [% V3 Q
  7. */
    ! C7 @( x1 M  l* `# h
  8. unsigned int shellExtParsePara(Shell *shell, char *string)7 V4 H1 `/ R% g8 ^
  9. {9 `; E9 t. F$ y
  10.         uint16_t i = 1;
    ; Y4 k5 I1 d# d  S* b: I
  11.     if (*string == '\'' && *(string + 1))
    7 H6 D* p2 n7 A: D
  12.     {
    ' @8 [+ K0 P. e$ }( h
  13.         return (unsigned int)shellExtParseChar(string);
    , [$ [2 u$ U5 U5 m- U0 u
  14.     }
    $ R/ d, `- Y6 N0 ]3 w3 x
  15.     else if (*string == '-' || (*string >= '0' && *string <= '9'))( U# L; H: c) ^: [5 V& x/ W. h# Q
  16.     {
    ; H3 J* i  G1 z* K: x/ J6 D4 s; Z
  17.                 while(1)6 t% d, a/ K. {6 i4 ~
  18.                 {
    ; K! c, X! L/ v
  19.                         //寻找下一个表示该参数已经结束的字符
    ! U# g* H4 S) v  M' z: c
  20.                         if((*(string + i)  == ' ')                 //下一个为空格表示该参数已经结束
    5 O" X0 c' E& O( ^% @: K  {
  21.                                 #if SHELL_ENTER_LF == 1                        // LF 表示命令结束
    . t- v/ j: T7 {+ x! o+ i9 l; a6 V. K  B1 g
  22.                                 || (*(string + i)  == 0x0A))        
    ( g2 ~6 T2 d# @! \6 w5 h
  23.                                 #endif" \2 a" B+ G- R9 e4 }$ V
  24.                                 #if SHELL_ENTER_CR == 1                        // CR 表示命令结束( |( L- W- n8 W7 ^6 `9 Y7 u. i
  25.                                 || (*(string + i)  == 0x0D))
    : V8 j" j. l9 v2 d
  26.                                 #endif
    6 T4 R9 P9 U" h* F
  27.                                 #if SHELL_ENTER_CRLF == 1                // CR LF 表示命令结束3 `7 u# E6 m0 N
  28.                                 || ((*(string + i)  == 0x0A) && (*(string + i + 1)  == 0x0D))
    : ?+ V; r8 _+ U
  29.                                 #endif+ [1 ?. y) \6 Z0 z: z9 S& u
  30.                         break;
    % L& ^: D3 p* S: U  b' k

  31. ) R7 |9 }" L2 u. l: U3 e
  32.                         //出现不为小数点或者非数字的字符,表明该参数为字符串
    1 \- D* Y; T+ m9 N' |4 d. `
  33.                         if((*(string + i) != '.') || (*(string + i) < '0') || (*(string + i) > '9'))" r7 X* {) p; s& x- S6 g
  34.                                 return (unsigned int)shellExtParseString(string);
      _+ r% u! e: E$ E# ?! r' d* a5 q
  35. + d0 [, c  h. \( g" o9 x& k
  36.                         i++;0 y: M7 f' |( m
  37.                 }9 d, c4 {7 O9 Y4 n' d; k5 O% G
  38.         return (unsigned int)shellExtParseNumber(string);
    ! Z' C. m1 @  {- s2 S" x! p
  39.     }
    7 B' y/ V1 i8 c" B/ {
  40.     else if (*string == '! b3 f+ c- y& E
  41. [b][size=3]六、其他常用的 Letter Shell 函数[/size][/b]  ^4 g: M) w  v4 z$ j
  42. [b]6.1 shellWriteString[/b]
    + x. v3 R3 r3 s3 A0 j$ O) C
  43. 函数原型如下,这个功能就是 printf 。这个应该很好理解,就不细说了。4 o- b3 L3 |" m; z, h- Y0 W

  44. 4 T3 j+ o% G2 W0 n  i9 q
  45. [code]/**( L! i  A" K8 U; B! j2 v. C
  46. * @brief shell 写字符串
    2 C0 I6 m9 X" N0 I9 ^2 k
  47. *
    . V- n$ D$ `$ i! d3 p* o
  48. * @param shell shell对象
    ' J( R1 H: l7 C) |
  49. * @param string 字符串数据% x) K' v: D: g0 h
  50. *
    - u# h: ~% I0 ~( b" B& H
  51. * @return unsigned short 写入字符的数量
    & n+ T' h, p9 n- v- L
  52. */7 Q" p, @8 N; b9 r; W6 g9 r
  53. unsigned short shellWriteString(Shell *shell, const char *string)
复制代码

) W" ]% D7 O" k. I; n6.2 shellGetCurrent
  A& g1 l) o) P! d4 pletter shell采取一个静态数组对定义的多个shell进行管理,shell数量可以修改宏SHELL_MAX_NUMBER定义(为了不使用动态内存分配,此处通过数据进行管理),从而,在shell执行的函数中,可以调用shellGetCurrent()获得当前活动的shell对象,从而可以实现某一个函数在不同的shell对象中发生不同的行为,也可以通过这种方式获得shell对象后,调用shellWriteString(shell, string)进行shell的输出。: a0 Y; D# M3 `; ^

' c# A6 X/ |8 T6 Y$ E
  1. /**+ E9 g+ k2 l8 Y, b
  2. * @brief 获取当前活动shell6 j. H- F4 }+ x" @$ V% F
  3. * 3 E$ G8 p; T0 Y8 D- [" C) k6 P; n
  4. * @return Shell* 当前活动shell对象& q) b, I# M! R+ u+ ]
  5. */$ q4 T2 A- p7 C  G! |( N
  6. Shell* shellGetCurrent(void)4 j  r. V; p% z
复制代码
  `4 f5 u# f5 Y) v$ O+ r; @
可以定义一个全局变量$ F3 _5 q# z1 f" Q' _, b9 m9 T& M

+ F7 X5 ?; s* G8 h! h' G
  1. Shell *shell_active;      //当前活动的shell
复制代码

: \0 K4 F* e2 m, _3 H如果我们使用多个串口创建shell 对象,如果通过不同的串口访问文件,那么就不容易知道应该在哪个界面进行输出,正如这个 mv 的命令,首先获取当前活动的shell,再通过 shellWriteString(shell_active,“Operation failed! Error Code:”); 进行输出,这样就可以避免冲突了。
5 T0 ~6 z; x0 p! C  q8 X( i. ~/ @% E! D
  1. /**" H' w- T: d$ ~% {5 H! ~! e9 S
  2. * @brief 重命名/移动文件或子目录$ g* l7 n& T8 G$ |2 h. I
  3. */# u% R* k* ?; s; n! P! C
  4. void shell_mv(char *old_path,char *new_path)% V/ e( J0 I2 ~% E6 v: Y
  5. {9 A( v* o0 m3 F% V* t
  6.   FRESULT res;) T' u/ G8 ?9 h8 L( u: ]+ h: F" J
  7. 5 W: n; X6 g7 r0 C) f
  8.   shell_active = shellGetCurrent();   //Get the currently active shelll  U1 y( [. R2 J6 L6 A
  9.   res = f_rename(old_path, new_path);
    0 o8 r3 `  j' w9 a+ v
  10.   if(res != FR_OK)
      d6 ^$ ?" C7 J! Q
  11.   {
    ; d5 b( R3 j/ A2 s
  12.     shellWriteString(shell_active,"Operation failed! Error Code:");
    4 a9 q6 y# S% K5 j  n
  13.     shellPrint(shell_active,"%d\r\n",res);3 t/ \2 a. R. n  D
  14.   }
    # U6 F( t, j& n1 S2 m  x( i+ }/ `& `
  15. }
    , Z. e9 c( V+ e0 W0 z$ L+ D
  16. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_DISABLE_RETURN, mv, shell_mv, rename or moves a file or directory);
复制代码
9 Z9 v$ f- G5 s, M" }
6.3 shellPrint( O( |' |" C6 I8 _9 a
这个功能就是 vsnprintf 的简单封装了,用于向字符串中打印数据、数据格式用户自定义,但是要注意,打印的大小不要超过 SHELL_PRINT_BUFFER。
, d" i) A% Y/ E1 {2 w2 [* H6 W9 K, K3 U! [
  1. #if SHELL_PRINT_BUFFER > 0- s' f2 u4 J5 E; V6 u
  2. /**
    # |. ?3 T# L2 ?3 W) ]
  3. * @brief shell格式化输出
    3 L* K. J: S6 v5 }* U4 m
  4. * / T5 m% ^/ B4 D, _( m
  5. * @param shell shell对象# R2 S& {8 Q# E6 ]
  6. * @param fmt 格式化字符串
    2 x8 b6 c$ W' p
  7. * @param ... 参数
    7 ^- c, |+ |# P  a" e5 o) B4 B, N
  8. */- M4 f* A- V9 @4 T7 U9 `9 u
  9. void shellPrint(Shell *shell, char *fmt, ...)! ], k2 @  }5 c7 H8 _
  10. {3 }) [4 X# _+ J9 Z. W6 l8 I% |" D
  11.     char buffer[SHELL_PRINT_BUFFER];' Y) o$ E, B1 g
  12.     va_list vargs;
    6 D0 j* [! f" F$ _$ \3 W

  13. ' {2 H0 h7 g$ v/ V; `7 G
  14.     SHELL_ASSERT(shell, return);
    ' @3 O5 N7 p7 C$ P9 h) f

  15. ( V, [. P3 z& }1 m
  16.     va_start(vargs, fmt);- c3 L- f1 ^0 V( h
  17.     vsnprintf(buffer, SHELL_PRINT_BUFFER - 1, fmt, vargs);6 x- b* `( U6 l* A
  18.     va_end(vargs);- s$ R: ]' {3 v
  19. + p; L" ]0 j% F- n9 S$ r
  20.     shellWriteString(shell, buffer);
    3 U7 z/ W2 s, [
  21. }
    ! L4 N: x! g* c
  22. #endif
复制代码
2 ?9 X' k( K; H1 u( E5 U
到这里,介绍就完了,而这也足够应付绝大部分的调试内容了。
$ @  X( B. d' }9 t. e3 Y1 l
" h8 I& i( v, S$ [; P* z+ u& i$ F# i8 R1 a5 n# Q: Z/ s, T6 u. t$ n
4 X$ F. r/ j6 B9 {- C
&& *(string + 1))
, {! {* X2 O/ g, Z/ F$ D    {
3 H( E4 n. p4 e3 n        return shellExtParseVar(shell, string);1 _8 s, g* k4 F) K! A
    }
# F! ~% H; t; X, [. Z* [( I- a4 y    else if (*string)
5 y% i9 A! X8 A/ `/ r8 ^% v    {
  S" v# m$ u/ C' {% h  {4 K        return (unsigned int)shellExtParseString(string);; f5 D: e5 `0 x/ N
    }
3 k) l) l/ y9 j+ V, \1 H    return 0;: h$ `! `! b# L3 v
}[/code]6 Z, `8 f) P4 x! c2 [3 G
六、其他常用的 Letter Shell 函数7 U% z0 f3 {! X: Z
6.1 shellWriteString  c: o1 ]2 _4 h( U
函数原型如下,这个功能就是 printf 。这个应该很好理解,就不细说了。
3 g' \) S; _% H2 j4 D, N) S# u' M* U& A
  1. /**9 _! f; A3 O- \( ~5 {
  2. * @brief shell 写字符串
    1 h. T* v0 j* h! Q2 p$ `& |
  3. *
    + l+ }0 b1 u$ W9 B
  4. * @param shell shell对象8 ?" t: |1 o$ R2 D! j
  5. * @param string 字符串数据
    9 [* t; w, |$ [! E5 ^0 y
  6. *
    6 `8 a! w4 b+ Y' Z
  7. * @return unsigned short 写入字符的数量8 n$ L! |7 \. C$ V9 P
  8. */6 x$ J9 d: v5 @5 g" d3 d! B7 y# [
  9. unsigned short shellWriteString(Shell *shell, const char *string)
复制代码

4 u' k$ G' \: y, H$ t" y: s6.2 shellGetCurrent
# d: T# g. q9 f# X8 L% Z' ?4 ~+ yletter shell采取一个静态数组对定义的多个shell进行管理,shell数量可以修改宏SHELL_MAX_NUMBER定义(为了不使用动态内存分配,此处通过数据进行管理),从而,在shell执行的函数中,可以调用shellGetCurrent()获得当前活动的shell对象,从而可以实现某一个函数在不同的shell对象中发生不同的行为,也可以通过这种方式获得shell对象后,调用shellWriteString(shell, string)进行shell的输出。
5 h% Z8 |5 `7 n8 S4 Z! i3 R
2 M2 f6 L. y5 V% i, |1 E
  1. /**6 S' R2 `- i: b( r) F
  2. * @brief 获取当前活动shell! E! b# a* L% x' o1 t
  3. *
    ) k8 J9 A/ [2 J" j2 w) ^: U* W
  4. * @return Shell* 当前活动shell对象7 N& @+ x" C# e! X
  5. */) ~5 Q! b4 X" H" M) p/ Y% z
  6. Shell* shellGetCurrent(void)& D  d" e) l0 Q
复制代码
  V: t/ R" s  S
可以定义一个全局变量  P! s0 `- K$ l/ l$ I- V. w$ j
2 @, ?0 x( j. ]
  1. Shell *shell_active;&nbsp; &nbsp;&nbsp; &nbsp;//当前活动的shell
复制代码

, z3 u$ r' c9 N8 o, C6 n, S$ H如果我们使用多个串口创建shell 对象,如果通过不同的串口访问文件,那么就不容易知道应该在哪个界面进行输出,正如这个 mv 的命令,首先获取当前活动的shell,再通过 shellWriteString(shell_active,“Operation failed! Error Code:”); 进行输出,这样就可以避免冲突了。
& Q3 _( d4 P# ^" M( s3 X  J, N  L9 u7 g6 X- O
  1. /**
    & d. G6 V; S- o& a; @& B
  2. * @brief 重命名/移动文件或子目录: P/ q! ]4 ^4 ]1 A& Q; S
  3. */0 p. u. C4 ~! d2 j
  4. void shell_mv(char *old_path,char *new_path)2 d. g- U8 F7 F& u  J# |0 M
  5. {
    5 p, q5 h0 h- }, X
  6. &nbsp;&nbsp;FRESULT res;, j( T" ?) M7 ~, U
  7. 2 C6 `& }5 L4 [- l- |
  8. &nbsp;&nbsp;shell_active = shellGetCurrent();&nbsp; &nbsp;//Get the currently active shelll
    * t9 M( @8 c  b+ f9 m3 L
  9. &nbsp;&nbsp;res = f_rename(old_path, new_path);* F0 n6 i  N( @. y1 X; b8 E
  10. &nbsp;&nbsp;if(res != FR_OK)! P4 s9 Y1 n, J% `) {0 \/ r
  11. &nbsp;&nbsp;{
    3 p* K8 p1 b1 U9 l* H0 ~9 J
  12. &nbsp; &nbsp; shellWriteString(shell_active,"Operation failed! Error Code:");
    1 f) }1 [- O% e  E- }( W
  13. &nbsp; &nbsp; shellPrint(shell_active,"%d\r\n",res);
    0 U2 n3 c7 P0 v6 O3 i- g5 A
  14. &nbsp;&nbsp;}
    # x. r6 P3 L: o- X+ H0 c7 s
  15. }. _# ?! P% k2 g) X8 z1 A% M! K
  16. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_DISABLE_RETURN, mv, shell_mv, rename or moves a file or directory);
复制代码

2 d7 Y  |2 m' c5 L8 K% h6.3 shellPrint  N; {2 s7 f: a+ Y
这个功能就是 vsnprintf 的简单封装了,用于向字符串中打印数据、数据格式用户自定义,但是要注意,打印的大小不要超过 SHELL_PRINT_BUFFER。. n' [5 V  U6 e6 {0 }# |: z- i

1 p" F: p1 P; @& G3 u3 ]
  1. #if SHELL_PRINT_BUFFER &gt; 03 a+ H8 c. p$ l6 ^6 Q$ `
  2. /**1 Z, x' H  B- e
  3. * @brief shell格式化输出) e8 T9 D$ q$ y+ K7 Y  w
  4. * & Y8 b& h' i2 {8 x7 }2 h
  5. * @param shell shell对象1 J; p8 t; P) R8 v0 z" i7 D
  6. * @param fmt 格式化字符串4 p% Q4 K$ P7 m6 ~, Q+ m
  7. * @param ... 参数
      b* E2 w: D  h  x) L) D/ b
  8. */- G1 m2 T! n. q# b( i* n; f7 y
  9. void shellPrint(Shell *shell, char *fmt, ...). x2 Q) C7 c( m. r, {% ]+ I+ B) C
  10. {  i. Y, d7 @: ]* y+ J
  11. &nbsp; &nbsp; char buffer[SHELL_PRINT_BUFFER];; |, G1 n2 o( G- ~4 `" R$ C4 z, f# p
  12. &nbsp; &nbsp; va_list vargs;
    8 a7 y& p' [1 ~' f  d0 S

  13. / o9 `. o8 [( q# M
  14. &nbsp; &nbsp; SHELL_ASSERT(shell, return);
    * o  }% L4 Z' m! X3 g% t

  15. 2 \" F, ~3 S4 z# l" [, J
  16. &nbsp; &nbsp; va_start(vargs, fmt);, A1 i/ T8 r( y  Z  G" |
  17. &nbsp; &nbsp; vsnprintf(buffer, SHELL_PRINT_BUFFER - 1, fmt, vargs);, d* m( ]3 `4 M* z3 Q- L0 Q
  18. &nbsp; &nbsp; va_end(vargs);
    & j: t) y* ^$ o# ]0 _: X
  19. 0 r& O, f( G2 B1 L, S" L( U
  20. &nbsp; &nbsp; shellWriteString(shell, buffer);$ C# P6 \$ w) j3 E! I& n
  21. }1 A4 p% p; G" G0 J8 m0 ?
  22. #endif
复制代码

7 @9 |! i( w4 w! b到这里,介绍就完了,而这也足够应付绝大部分的调试内容了。
3 C0 j/ y# ^. @' `5 Z1 J1 U
- x  ?0 ^5 k3 D; ]————————————————. v7 l, q9 {/ Q( x. i1 n
转载:fafuwxm0 p* l. Z$ |) G& U; m7 C+ ^- I

8 S; z4 z0 N+ G2 }% h0 O
R`)~GN97DP3}]5R[IQUN}XE.png
赞 收藏 评论0 发布时间:2022-8-23 16:13

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版