前言
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
( 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
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
' 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
- 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- /* USER CODE BEGIN Header_StartDefaultTask */& S% W* d$ r4 [8 A3 N q5 k& w
- /**5 B F0 g* D/ m0 H$ a K
- * @brief Function implementing the defaultTask thread.3 O) G- U( h. a/ J# s* g
- * @param argument: Not used
. i: t4 ~5 V N1 C. R2 w' u% z - * @retval None; Q3 X4 m& M* f# m6 }2 U# h5 Q4 H
- */. Z$ U& e( T/ Q! Z" n [9 ]
- /* USER CODE END Header_StartDefaultTask */
8 P, [' A/ }$ m. o/ W4 y - void StartDefaultTask(void *argument)
9 i9 z* f H9 L! W$ @3 _ - {
6 q4 d: |2 m& l: v1 h! o+ s - /* USER CODE BEGIN StartDefaultTask */( Q/ [* E+ n; ?; t( B7 f& }
- /* Infinite loop */1 v. Q0 R0 S* Z" y: y9 l
- for(;;). ]" m$ U% `4 l+ E
- {4 y8 J3 N# @( ~
- HAL_GPIO_TogglePin(LD3_GPIO_Port,LD3_Pin);8 ^9 {- m5 \+ w" k2 U- t7 k9 [& H
- osDelay(100);, p( P# `+ l: _4 a; Q! W9 j& y) y
- }/ k3 F x8 _& T% P
- /* USER CODE END StartDefaultTask */# D. E8 Z0 Z1 ` B
- }4 z2 h3 ~- [) g) q
复制代码 2 |# M4 a, K K }1 g U$ ^! p7 ^3 u/ a
注意,配置的Keil工程,默认是没有设置下载完自动复位,我们需要按一下Nucleo 板子上面黑色的复位按钮,另外默认的配置下,有一个以太网的初始化 “MX_ETH_Init()”,需要接入网线到路由器,不然初始化不通过,会跳转到Error_Handler();- if (HAL_ETH_Init(&heth) != HAL_OK)
z% P/ X9 `; P, C: n) d" R B - {; K! |2 P8 n# G$ F) v0 V7 h
- Error_Handler();
8 q/ ? H* L6 k- f - }
复制代码 " 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
; @ 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
* ?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
' 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
- ..\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% }
- ..\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# |
- #include "shell.h"! h3 y1 T a7 \+ Y2 w: D& L% ~6 ?" Q
- #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- /*** d! B+ v) J3 u9 s# J
- * @brief 用户shell写
2 X- W! q- e! p7 j - *
" @& F2 F; v- Y9 n+ F - * @param data 数据 f, y1 d3 r% g# }1 n; u
- */$ T+ j" S+ [$ o- Z* X' O
- void userShellWrite(char data)" m' Z. n: E) H2 k6 ~5 q) W
- {- p$ e& K% u, U3 F
- serialTransmit(&debugSerial, (uint8_t *)&data, 1, 0xFF);# [! @; Y) @7 Z9 z
- }) a+ V' t- B5 E% K
}( e: u7 i( \ r- /**
U9 u" \; W& I( O - * @brief 用户shell读6 K) b4 }8 T, b1 z2 \4 u
- *
6 Y2 C# Z7 M1 A/ X2 D5 v: O - * @param data 数据! c1 q- J% E }) p; H& l
- * @return char 状态1 f2 P% k0 |3 u! `% [" ^" [
- */
8 F0 C6 Y, y1 Y v) U' [1 J' a - signed char userShellRead(char *data)% u% |3 N! U% J! q5 `( j
- {$ B% H; E, j* j: l
- if (serialReceive(&debugSerial, (uint8_t *)data, 1, 0) == 1)+ c9 C8 N8 q6 a7 l
- {0 D" j" z- n$ K0 D# F @4 {
- return 0;: J/ r8 \% g, d' {; C' R
- }8 s/ x6 b8 i W. ^% Z5 G# c
- else
% T# c% d4 r/ T: R' ` _5 W; t - {. ~ x% W; n* I6 Q: Q
- return -1;' T( s! \1 n! r. t, z5 j
- }
, [9 E: [. r& @ - / e; G: F& n* F: {6 ?3 l$ n, ]- ?$ X
- }
复制代码
. 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- /**% j$ P* Q* [/ |* i: ?
- * @brief 用户shell写
* V( g' w) c# @5 z5 g5 d; E: m3 H. K. c - * % Y/ c% D+ U: ~6 l0 C( c. } [
- * @param data 数据4 k& o6 z5 L6 x; O
- */
# z8 Q2 q5 e1 K) r2 D - void userShellWrite(char data)
) {; x) k) O" u: U. |4 { - {
, B0 L0 J/ \/ q2 i5 E8 D k - HAL_UART_Transmit(&huart3,(uint8_t *)&data, 1,1000);
+ M# C# C- R* m/ b - }! q. s8 {0 Y7 ~: G: c0 g1 `1 A
- 6 N- p: w( k- l1 S" e
7 ?- J7 S5 C$ b% n7 \' Z- /**& _6 W8 r3 O9 I0 G( a, D/ s
- * @brief 用户shell读) v9 @& x, ^) `0 W( `
- * : K3 E- L( J+ Z& R
- * @param data 数据4 ], h3 t$ @0 w- k* ]* D
- * @return char 状态. r; [' c/ {8 y' J* o
- */
* U7 b2 @7 R- t5 J9 z) p( z - signed char userShellRead(char *data)0 _8 U1 {# c# J3 q; ?& k& X* l
- {
# ^( i9 O* Q* C# U' A9 W% P: @ - 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
- {4 y; U6 i% _) @- Q+ R- f
- return 0;
8 P- ?- n9 F0 z) J- | - }
! l: L7 G% V- z2 D* ? - else& {" D( p' `& g; H# V/ d
- {
s! ~% }6 K& o( ]5 m - return -1;
2 @4 @0 m) K+ m# p - }' N6 a9 R8 A- V3 E9 L8 r# f
- }
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. 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
- /**
9 S3 N& H; h& U, {, q+ k* p( ? - * @brief shell读取数据函数原型" O+ ?/ p6 B- W7 w2 h
- *0 ?% t; F! d/ J
- * @param char shell读取的字符
% Y& P2 g+ c6 A - *' I" ?2 ^0 g, b8 E& z: i
- * @return char 0 读取数据成功
' y$ r& k& u; j$ H2 @/ v! h1 P- E - * @return char -1 读取数据失败8 J* b8 Q1 G' d1 P
- */
/ ~7 a; l# g* h7 C, g - typedef signed char (*shellRead)(char *);+ ]6 j3 N9 d. k
- $ d; P* P2 p9 z
- /**" v4 \4 f ~8 z+ R% k; f" w
- * @brief shell写数据函数原型
* o7 [+ l; x G( E6 |2 P+ B5 c* F - *
( H3 \' @8 O2 x1 ~ - * @param const char 需写的字符
" a) o! ]& p1 h$ G- }# Q9 f0 n - */2 x, U- n8 D( E5 n0 W9 {
- 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
/ ?( 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
- /**. L* y# ^' n3 D8 c
- * @brief 用户shell初始化
2 I, ^, D: [. @$ s* Q& s5 X! k - * 6 F3 f% I2 q7 d4 E( M6 n1 c
- */
1 K1 ^' o w% t$ k g1 B8 x - void userShellInit(void)
' ]0 A6 a# K8 H1 s: n - {+ Y; U% \2 ?5 V5 _: h
- shell.write = userShellWrite;6 t1 T! y3 |: f7 ]
- shell.read = userShellRead;0 _/ o. D5 E4 Q
- shellInit(&shell, shellBuffer, 512);
) O* M0 o( y" N; j - }
复制代码
. 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
- /* USER CODE BEGIN Includes */
1 F/ ~9 U2 P! u. s" Y - #include "shell_port.h"
3 W4 \7 j/ F5 _! y2 B( s - /* 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
- /* USER CODE BEGIN 2 */; E( d+ q1 U p! E5 R
- userShellInit(); //letter shell 的初始化- b {* N+ L2 G+ Q
- /* 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- ..\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
) 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
! `( _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
. 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- /**
6 n1 O0 X, i; J - * @brief 是否使用默认shell任务while循环,使能宏`SHELL_USING_TASK`后此宏有意义- V, T: m/ g. W5 `) Y
- * 使能此宏,则`shellTask()`函数会一直循环读取输入,一般使用操作系统建立shell" \4 G: y3 _7 ]" Y: |7 D: f; E; Z
- * 任务时使能此宏,关闭此宏的情况下,一般适用于无操作系统,在主循环中调用`shellTask()`
7 s, @1 B) ?8 D: l$ c4 m! X - */
5 {' u: t: L2 D; x* G2 k3 K# E% b - #define SHELL_TASK_WHILE 1: x/ z7 v) D! R# p, |3 v
# z* |& K4 c) [' H- /**
0 c" x1 W. s6 D4 C - * @brief 是否使用命令导出方式! @( c) m6 \ ]( @+ O8 j
- * 使能此宏后,可以使用`SHELL_EXPORT_CMD()`等导出命令
1 P8 K, Z) n* `$ R! s6 N, G6 Q4 D8 i# m - * 定义shell命令,关闭此宏的情况下,需要使用命令表的方式
6 Z# y' M+ @& @ L; _ - */6 j2 `( U) m& Y" M3 W; }# P
- #define SHELL_USING_CMD_EXPORT 1
0 \5 @" n/ a& g3 l
9 d1 W7 d! L0 M! k- /**
( D# z& s5 A& e$ A, ]/ b - * @brief 是否使用shell伴生对象
0 Z- E! I8 E6 D3 T! [ - * 一些扩展的组件(文件系统支持,日志工具等)需要使用伴生对象. T$ k$ L0 [# c
- */! z- H; S# _' I; i1 Q# q
- #define SHELL_USING_COMPANION 06 P+ C# q6 Y) ]" ~. K
- & I2 V% t8 s) Y
- /**
0 o/ K5 y+ d% q; c/ z5 p - * @brief 支持shell尾行模式
7 e, a+ f0 U% V) _- c# Z - */' C! N: a1 i0 `* A$ a
- #define SHELL_SUPPORT_END_LINE 0
+ t i* e8 s) c6 v# W* E, f* y
; P' S- X% ~ @7 H+ m' s* Y5 c/ z- /**
2 z; U7 a% \4 V4 O6 X0 \. e7 [ ? - * @brief 是否在输出命令列表中列出用户
1 b/ m4 K# Y) u' Y. c# z! X5 ? - */
' _; t0 W! y6 z8 f - #define SHELL_HELP_LIST_USER 05 Y# D5 B6 d5 O! S
5 | G- n% n8 i7 M- /**6 {. _) x t2 Y/ i+ X& ]. ^
- * @brief 是否在输出命令列表中列出变量
3 g' L+ `: i: {/ X+ n - */2 W" A1 x' v5 [$ F5 |2 B7 |( ^# k. h" W
- #define SHELL_HELP_LIST_VAR 0( m& q+ Y. f8 n, R9 m
- 9 g6 i* j2 l2 @- A2 u
- /**
7 ?7 w/ g# ?; F% S5 J/ | - * @brief 是否在输出命令列表中列出按键
6 m) Z- b+ F, V - */
' K: t- U# ^$ C `. q) K5 x- B - #define SHELL_HELP_LIST_KEY 0
% _8 v) F# x) _) m- z% s - 2 A2 [; B; s, `5 L! c. A
- /**
! J# q: F- j l - * @brief 是否在输出命令列表中展示命令权限) S/ U5 [! P7 S) }5 X2 K/ S) H$ `
- */
% S" B' S$ \, I& c, ^+ w - #define SHELL_HELP_SHOW_PERMISSION 1, C# T4 b) }, f1 {9 B! {
% J" c; V" D; i2 f* A9 u- /**, V- h, Q$ b0 [% d& w. o* x! P4 B
- * @brief 使用LF作为命令行回车触发# f) z7 T& {% l
- * 可以和SHELL_ENTER_CR同时开启
3 s: ?+ V1 }. v/ n! U3 W) ] - */
9 U# j0 T8 ?* A0 ~! k; p/ P6 W - #define SHELL_ENTER_LF 0$ v h7 G: t7 h
8 E- l, |; y4 b- D9 ]+ m- /**
0 F1 O3 o5 G1 f% H3 T% }' r - * @brief 使用CR作为命令行回车触发
6 D' m$ M1 N# |5 B8 ^7 [ - * 可以和SHELL_ENTER_LF同时开启) t4 ]6 U: p2 A
- */
+ p. g2 R2 r$ ]/ \2 ] - #define SHELL_ENTER_CR 0
+ v9 u& `! n( |$ s3 F - 9 X, ]2 `' {, D @( i" b
- /**! f* L1 I: c* L* j9 r9 ]2 o$ o9 f
- * @brief 使用CRLF作为命令行回车触发+ q5 Y$ \ M! `
- * 不可以和SHELL_ENTER_LF或SHELL_ENTER_CR同时开启
& R) B3 o2 n' s# z - */
$ D, P, o, G3 L+ }" L2 } - #define SHELL_ENTER_CRLF 1
; e3 p: u2 m4 K' ?! ?$ F, [ - 0 m* y. C I* T2 B1 D* m
- /**6 A w8 l2 P( ~
- * @brief 使用执行未导出函数的功能
) Z/ {2 a7 I6 ?4 l& {8 {" x0 [, v - * 启用后,可以通过`exec [addr] [args]`直接执行对应地址的函数
4 {8 Z ]& q! e2 B! w - * @attention 如果地址错误,可能会直接引起程序崩溃
# d& P9 t* c# @& r - */
4 I, @7 E" p3 S/ v c) G - #define SHELL_EXEC_UNDEF_FUNC 02 J! E# _) d- w; L! y
+ m5 @9 U, ?( l6 K3 b- /**
& |; q r/ N& K5 R - * @brief shell命令参数最大数量3 |8 A) R7 d9 j) E- T0 m. l! z
- * 包含命令名在内,超过8个参数并且使用了参数自动转换的情况下,需要修改源码
* F, e8 F- x0 t* q$ ^ - */" u5 T9 [* n' P! f% {8 ^
- #define SHELL_PARAMETER_MAX_NUMBER 81 p" c8 j: r! Z, l9 d* Q
- ' ?' l* L/ \ K' u Y+ }5 ?
- /**
. K# h7 c% X4 ?9 T& F% ]. f - * @brief 历史命令记录数量
" ]4 @& t, i: j$ M8 c" e - */ y4 F: y+ ^8 }! u
- #define SHELL_HISTORY_MAX_NUMBER 5
; M' l3 U" y9 ?- @9 W3 V - # J9 o( N" s4 P' x3 U% |
- /**# u8 `9 G" {: X# H4 J6 W! A: Q
- * @brief 双击间隔(ms)
+ Q! @% S1 m; ?: ?4 s" L( ~& h( R - * 使能宏`SHELL_LONG_HELP`后此宏生效,定义双击tab补全help的时间间隔2 P( `% g$ H; W0 b& Z/ X
- */
& O. @" y b3 c9 ?/ k( B9 ^ - #define SHELL_DOUBLE_CLICK_TIME 200
& }- F" ~# @4 N" O- w/ X
0 ]0 ]/ p4 d# [7 L6 `( _6 ?- /**4 ]7 N R& x, H B' J
- * @brief 管理的最大shell数量; s2 E0 ?$ c4 P8 M- f
- */+ Y' n# C6 s8 B" t* \
- #define SHELL_MAX_NUMBER 5
& y5 p1 d9 W# J5 N% w' ?& e
7 m, \3 t; W! D) ?1 Q+ P, J- /**
: [) I+ q" ?8 Y9 B: [2 g7 B - * @brief shell格式化输出的缓冲大小& U9 U! Y& S+ C% _6 v o& ^
- * 为0时不使用shell格式化输出1 p$ u w9 G& }7 a, W! ~( Y# G
- */
3 G% M' W# e0 s - #define SHELL_PRINT_BUFFER 128
$ _ X, _$ m( P# m$ E( J* @
7 Y+ |: Q. N- O5 H+ Z2 g1 {- /**
4 H9 X2 M5 E" B+ w+ [$ y - * @brief 获取系统时间(ms)/ E9 K2 M* r+ Z
- * 定义此宏为获取系统Tick,如`HAL_GetTick()`7 p \' r0 b3 o9 Z$ G$ x7 Y
- * @note 此宏不定义时无法使用双击tab补全命令help,无法使用shell超时锁定7 [! n% G# l* ?5 I5 C3 Q, H d
- */$ l0 {2 w! Q; D& g
- #define SHELL_GET_TICK() HAL_GetTick()) F) ]0 H% u" w( Z8 z/ K# O
) I. u. E( E& U4 p: C6 n& r$ U8 l: ?( V- /**- L+ c, Z* v* j& B1 U; t
- * @brief shell内存分配6 K' M5 g/ S& _) }9 R, h, p
- * shell本身不需要此接口,若使用shell伴生对象,需要进行定义
5 A( ]. J: x' Q& P0 @& ~ - */
& v, V; g |/ G* D ] - #define SHELL_MALLOC(size) 0! p- I$ @3 U2 ~4 R$ G5 b
4 r7 N2 {- w- @6 s" a2 q6 x6 K C" y- /**( r# A) f% `' k: }5 X; M
- * @brief shell内存释放 _4 H7 [( Z$ Y; @) X3 o, g
- * shell本身不需要此接口,若使用shell伴生对象,需要进行定义$ f$ H. ?$ r8 {
- */
& t! w) @) T, `' b1 x4 E& m1 O - #define SHELL_FREE(obj) 0
3 j: X% D# s) | - + z! I7 g$ p& o1 t: G# z
- /**
( U6 d2 ]7 c$ x# m- U - * @brief 是否显示shell信息
- G/ {9 l4 }" | d& s - */
3 a2 |; z" h& P% @4 @ - #define SHELL_SHOW_INFO 1
6 T) _1 L! l- C
6 f/ i2 Y% L$ q- A- /**
% q( {# q7 y- k" B7 |3 O% I# m - * @brief 是否在登录后清除命令行% R* g4 J3 _1 n) c# j
- */- e1 W/ Y# F% \2 v7 `* {
- #define SHELL_CLS_WHEN_LOGIN 1
% z9 y1 h$ X# [' I( h' H
8 z5 W! U d, m3 U& b. m- /**( c) F# d; i- b8 b
- * @brief shell默认用户* t! g5 ~( J$ u5 m
- */& R( u6 C* |2 S' \2 T3 z
- #define SHELL_DEFAULT_USER "letter"
6 ]5 X8 r; ^+ |0 X% W
6 x z$ @% e2 v) D+ F& p( I! H- /**1 C1 [( C* l' s, G- W
- * @brief shell默认用户密码, m3 ~2 M% V& s
- * 若默认用户不需要密码,设为""
" ~0 I. F( I/ k) h - */( t3 N& `, }/ m, p
- #define SHELL_DEFAULT_USER_PASSWORD ""
% a! E6 }( D. n O - - s" [# e2 J/ p/ S& }$ R C
- /**
c- R( S/ t8 C0 R( n1 l - * @brief shell自动锁定超时
3 B1 C6 R K) k9 ~+ s - * shell当前用户密码有效的时候生效,超时后会自动重新锁定shell0 O$ k& `" c e2 N0 z) i
- * 设置为0时关闭自动锁定功能,时间单位为`SHELL_GET_TICK()`单位
- x9 k% A; |" Z; H - * @note 使用超时锁定必须保证`SHELL_GET_TICK()`有效3 [' @9 [5 F% p0 B
- */
* u- u$ B. q0 p/ J - #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 \
- /**
" N" k0 ~3 [ M G P# M - * @brief shell 任务
: N( }5 A7 @( C2 l7 ~ - * : `. i" y }+ h% K
- * @param param 参数(shell对象)( e$ Y6 m- o1 a3 R" _
- *
* o" A) c2 a# z- h5 ^# R9 W - */
( E. d1 B2 B" H! J - void shellTask(void *param)
& L2 ?2 y, C$ i0 }( P0 J$ f" K2 T - {
. o$ f- _: r2 t - Shell *shell = (Shell *)param;: a7 M" f; z5 X% u8 d# W
- char data;, O8 ^& ?/ Z# L, L5 n7 Z% `: |$ n+ F z
- #if SHELL_TASK_WHILE == 1
9 j* D1 i3 X$ i5 z# X+ O9 w3 H - while(1)
3 R* R3 T- o5 Z/ B - {
' H& w0 l4 q- n. O" _: a l( V - #endif
" a8 b+ a( f& S7 P% \ - if (shell->read && shell->read(&data) == 0)
1 S' y) x) B5 h. i8 ?* | - { _; H3 K6 Y8 l2 ]
- shellHandler(shell, data);' Z" J: }; q" V7 x. |5 ~7 k
- }
" Z0 a W/ K- ]1 E - #if SHELL_TASK_WHILE == 1
% v% \+ h, r1 K - }6 b, F8 r. K( s, A: D9 ]5 Q$ t, Q; t
- #endif1 {! P6 a5 M" F$ F
- }
, 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
- #define SHELL_ENTER_LF 0
. Y4 D" A1 l4 N1 d/ b - #define SHELL_ENTER_CR 1* b# T5 |/ d6 z1 b2 A! @
- #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
- #define SHELL_TASK_WHILE 0
3 }1 N) `! U: [9 ~ - #define SHELL_USING_CMD_EXPORT 1( K. `$ I R5 {& t5 F% n( F
- #define SHELL_USING_COMPANION 0) ?7 r& N; h0 v5 K5 m
- #define SHELL_USING_COMPANION 0( z) B& v: G, Q3 f) p. `
- #define SHELL_SUPPORT_END_LINE 04 z5 ^$ L2 J1 T4 h7 l, V Q
- #define SHELL_HELP_LIST_USER 0
# w0 ^6 L4 v, X9 L8 ` - #define SHELL_HELP_LIST_VAR 0
4 v5 j/ G9 j& c. z7 p/ Z - #define SHELL_HELP_LIST_KEY 00 A+ S5 d# k+ Z, x# R
- #define SHELL_HELP_SHOW_PERMISSION 1& L1 {& b& N! ^* `0 h6 o. p/ q& n, _/ Q
- #define SHELL_ENTER_LF 0$ L7 C7 Z6 D, {8 b8 W( m
- #define SHELL_ENTER_CR 1
9 ~5 N6 j8 Y [2 B - #define SHELL_ENTER_CRLF 0
5 B4 I* X% c c5 ^+ ]" w - #define SHELL_EXEC_UNDEF_FUNC 0- X5 A/ B9 c) [1 X. c! i' d
- #define SHELL_PARAMETER_MAX_NUMBER 8$ l' {6 a% r3 \$ j) J5 _3 H
- #define SHELL_HISTORY_MAX_NUMBER 5- e* E* P( g* G) `3 ~+ w$ R
- #define SHELL_DOUBLE_CLICK_TIME 200) d! F: \8 h' D+ u: R% A
- #define SHELL_MAX_NUMBER 5
8 S3 A8 K; {& P8 K: T0 o - #define SHELL_PRINT_BUFFER 128
. l( h8 r- F# s- a) _/ u, Q1 P - #define SHELL_GET_TICK() HAL_GetTick()
. |4 g) @0 l% D) y! Z - #define SHELL_MALLOC(size) 0
2 Y1 W# Q* q4 W4 n! t, O2 A. c: ^ - #define SHELL_FREE(obj) 00 C; ?% B' h) T* [, `8 ?
- #define SHELL_SHOW_INFO 1
9 R( V N: v3 U7 u" ~. X8 t* o - #define SHELL_CLS_WHEN_LOGIN 16 {7 d _( c6 P0 W4 H7 ~) a/ q" Y1 x
- #define SHELL_DEFAULT_USER "letter"
' o$ B$ U+ M+ |" k4 G - #define SHELL_DEFAULT_USER_PASSWORD ""6 z( {1 E! C4 @# g" a
- #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- #define HAL_USART3_RXBUFFERSIZE 13 ^+ v9 o+ ~1 |) ~
- 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; |
- 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- void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart). T7 o: |2 }- q$ a
- {
& V; ^! z3 G T% ] D* c5 n - uint8_t udata;
0 O3 w6 x7 m' L8 w5 A$ h+ r - if(huart->Instance == USART3) //串口3的接收部分
, X' Q. b7 ]2 M7 h9 A6 a. p# a - {
# d5 |6 O6 X8 N4 L - HAL_UART_Receive_IT(&huart3,(uint8_t *)HAL_USART3_RxBuffer, HAL_USART3_RXBUFFERSIZE); //接收串口的缓存
5 R- N( n1 @: e* u- U7 X - udata = HAL_USART3_RxBuffer[0];# C& }6 I/ d( N( a1 C: M: Y
- shellHandler(&shell, udata);
4 C( a. g8 b, { - }
+ F! s" }/ |, p, k0 d9 {0 z$ A - }
复制代码 . ^7 ]) ~& ~2 P9 L) ]5 t$ i- h
编译后下载程序,复位,这时候输入cmd 命令,按下回车,就会列出可以支持的命令了。后续如果自定义了导出函数,也会在这里显示。到这里,就说明了串口的收发是正常的,shell 也移植成功了。! Q6 t/ Y. C' `2 Y2 x
+ R/ x0 N. ?. S! i
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
- void LD1_ON(void)- J2 M5 c% f' K* R! y# \
- {, T& m/ j$ {6 \; X, i/ i2 [# @+ X
- HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_SET);
" n& p6 c( J; W, Q" ]; c - }
5 A! k7 y# _6 F8 C' `" }. I - 2 g/ u. y) O+ G& }
- 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
8 H3 `0 Q% ~5 X5 ~+ a5 S! r, p- void LD1_OFF(void)
y) F/ ]; O! @9 n: O* K* c - {5 `- |" K* i4 u* g
- HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_RESET);
5 D* W, F$ i7 `/ j% C - }
1 S/ P6 Z1 I4 k( e8 O" }# ]6 T - $ b, r' X) `: L/ z, D" e+ m( Y# s
- 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
- /**
& s7 Z! _. }" M$ m2 H' w! ` - * @brief shell 命令定义
V" V; F8 `2 X$ b- f - *
2 g. m7 B+ t: N( x5 v$ g) e - * @param _attr 命令属性
* S6 ]5 Y e8 ^5 Y2 N5 g, _ A - * @param _name 命令名
8 S# q& `9 d8 U$ ?9 ? - * @param _func 命令函数
1 I6 E; Y* _+ e$ h( N# z7 ~: Y% B9 p - * @param _desc 命令描述
/ ~4 U% C! [, P& o. q/ s" \ - */
1 ?. W9 e/ r5 E: K - #define SHELL_EXPORT_CMD(_attr, _name, _func, _desc) \2 q% {/ D7 R' t P# v- w, k# }. p3 J
- const char shellCmd##_name[] = #_name; \
. E- \6 O$ _4 h, `1 f - const char shellDesc##_name[] = #_desc; \
$ k6 _, c0 _" X+ V+ H - const ShellCommand \% S: b+ H0 C$ u; O1 c3 s) n0 B
- shellCommand##_name SECTION("shellCommand") = \
( u/ \* A* d) i, P2 ~" j - { \
" `6 }$ v; Q6 V" F( n0 D - .attr.value = _attr, \
% [3 H \3 I' x; P5 \ - .data.cmd.name = shellCmd##_name, \
. L. K- p% v6 H% g+ ~; C - .data.cmd.function = (int (*)())_func, \3 G7 E. w+ r- m+ L2 f, @
- .data.cmd.desc = shellDesc##_name \* J1 l, q; W7 h7 p* h6 r
- }
复制代码 - 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
- /**
% T E! b0 Q" p. @ R - * @brief shell 命令权限+ Q% F2 S, M* u! x: b+ X
- * - {2 R5 f0 h1 j% C" t0 t
- * @param permission 权限级别) B5 A; Z e N0 t/ q; ]
- */0 s' Q1 v0 v8 ?2 l; ?7 u* Q
- #define SHELL_CMD_PERMISSION(permission) \# J9 u" A9 u' t) C
- (permission & 0x000000FF)5 n5 s" A5 I; k2 L
- ) v! g2 y9 I* J" x. ~- D3 P
- /**: M. m' Y* y, R) B
- * @brief shell 命令类型
; e- H6 V- R( f4 }1 }" T8 r - * * a8 s+ {+ B$ }" q' x
- * @param type 类型
9 G. g z( I3 n' G4 X7 k - */8 u% M7 M* r: d6 g6 b( A9 b1 G1 }- ~2 G
- #define SHELL_CMD_TYPE(type) \' Q" W/ U- N j
- ((type & 0x0000000F) << 8)& b' j1 b! j4 G3 A9 D
- : {2 h0 b$ _( r% M4 h
- /*** p2 l+ D4 K" W& u
- * @brief 使能命令在未校验密码的情况下使用
9 F6 [( Q8 O& @" K4 m- y! ^4 y - */3 X" ?; k( z) T1 k; o6 Y; b* K3 g
- #define SHELL_CMD_ENABLE_UNCHECKED \
5 k T% s: s: x, Q" Z - (1 << 12)
+ j) E3 {2 f) P+ ~! F - ( o& d1 B: s+ f% i* K) j
- /**- o, t! f2 L* @. R; ~0 E# c
- * @brief 禁用返回值打印9 b& J% `6 i; l: w
- */
; f t7 X$ C! c7 v }# h - #define SHELL_CMD_DISABLE_RETURN \# R5 [! R) ^- ?
- (1 << 13)
) D0 E _" A# M% r - 5 ^/ q: ]2 \! I
- /**
. t: z9 P: P6 `( A8 h - * @brief 只读属性(仅对变量生效)" ]" T1 c. \8 V0 e5 | P* ` x
- */
; _& c w* ^, c: r7 I - #define SHELL_CMD_READ_ONLY \3 K z# _1 I( H6 l0 {1 C
- (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- 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- led1_on
/ K# \* ?, j( V: I5 c* i. H& X - 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
! 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- int func(int argc, char *agrv[])0 T4 G, T2 x! l4 r7 F
- {
5 a5 \+ ?0 {7 s - printf("%dparameter(s)\r\n", argc);+ z$ c2 N1 R6 R+ S% l+ e
- for (char i = 1; i < argc; i++)# k2 `5 W+ z$ E0 p& F0 y4 ]# ~
- {9 q2 k2 g% I8 L- A1 }
- printf("%s\r\n", argv);8 B4 w0 J, `0 d$ x( Y
- } X# _2 t7 M: Z% _2 S6 N
- }/ I+ p# n# X7 Q3 z# e
- 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
- letter:/$ func "hello world"' ^; q5 j( b, M. Z+ E
- 2 parameter(s)
: c( j$ X P! |; a: R4 c - 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
- void LD1_ON_OFF_ms(uint16_t on_ms,uint16_t off_ms). j) H% z: O4 F8 A' A K2 e
- {5 F6 z' f. z2 O& ]( X7 m) G
- HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_SET); //点亮LD1( Q) |& X, d7 j e4 D
- HAL_Delay(on_ms); //延时1 Z8 B2 }( ` O0 S" `0 u% ~1 `; Q$ g
- HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_RESET); //熄灭LD1
5 j( f' t' C$ r- F& k - HAL_Delay(off_ms); //延时# w, m- K8 {: C/ m
- HAL_GPIO_WritePin(LD1_GPIO_Port,LD1_Pin,GPIO_PIN_SET); //点亮LD13 p: k& A3 j P
- }- L' M9 r. K+ e8 i: i9 d! f
- 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
- 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 E y/ P+ s' ?$ R$ ]1 v& h1 ], R
- * @brief 重命名/移动文件或子目录
/ \9 t. A' R1 `) n. `" i8 M* B- N3 } - */
5 t4 ]8 \0 [1 r4 c1 B; \ - void shell_mv(char *old_path,char *new_path) c/ M5 q/ D8 G7 s4 j" Z
- {6 q9 |' T: D5 W* G/ B% G
- FRESULT res;$ y1 K: `4 h' o% K3 g9 n$ t
- ) g; `- n% p% ? y c8 |; x3 u. @
- shell_active = shellGetCurrent(); //Get the currently active shelll: R+ ]9 E6 C* _
- res = f_rename(old_path, new_path);6 A- \4 B4 P" h! ^; U" C" A( {
- if(res != FR_OK)
- n; {. c4 R; h - {+ w+ g+ ]- {7 T" p2 z+ d; R/ C% J
- shellWriteString(shell_active,"Operation failed! Error Code:");
9 q$ ]$ B( ~1 C7 X2 q) l' p - shellPrint(shell_active,"%d\r\n",res);, s3 ]* ?5 h0 J& j
- }
- H% D; k' Q0 ?% S" u) j# w - }& x$ U5 P, ?2 I0 ?! z
- 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- 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- /**7 q: Y5 v3 j L& Y2 {6 d* m; m
- * @brief 解析参数
& J1 [& ^4 |% m% j" v7 z - *
6 m9 W+ h, S" q+ c - * @param shell shell对象
/ r5 R( y& N X: r0 u - * @param string 参数 H: g- x6 X) k2 i- f$ a+ Z$ R9 a6 {
- * @return unsigned int 解析结果4 r( @" r8 s# G+ b9 r6 [% V3 Q
- */
! C7 @( x1 M l* `# h - unsigned int shellExtParsePara(Shell *shell, char *string)7 V4 H1 `/ R% g8 ^
- {9 `; E9 t. F$ y
- uint16_t i = 1;
; Y4 k5 I1 d# d S* b: I - if (*string == '\'' && *(string + 1))
7 H6 D* p2 n7 A: D - {
' @8 [+ K0 P. e$ }( h - return (unsigned int)shellExtParseChar(string);
, [$ [2 u$ U5 U5 m- U0 u - }
$ R/ d, `- Y6 N0 ]3 w3 x - else if (*string == '-' || (*string >= '0' && *string <= '9'))( U# L; H: c) ^: [5 V& x/ W. h# Q
- {
; H3 J* i G1 z* K: x/ J6 D4 s; Z - while(1)6 t% d, a/ K. {6 i4 ~
- {
; K! c, X! L/ v - //寻找下一个表示该参数已经结束的字符
! U# g* H4 S) v M' z: c - if((*(string + i) == ' ') //下一个为空格表示该参数已经结束
5 O" X0 c' E& O( ^% @: K { - #if SHELL_ENTER_LF == 1 // LF 表示命令结束
. t- v/ j: T7 {+ x! o+ i9 l; a6 V. K B1 g - || (*(string + i) == 0x0A))
( g2 ~6 T2 d# @! \6 w5 h - #endif" \2 a" B+ G- R9 e4 }$ V
- #if SHELL_ENTER_CR == 1 // CR 表示命令结束( |( L- W- n8 W7 ^6 `9 Y7 u. i
- || (*(string + i) == 0x0D))
: V8 j" j. l9 v2 d - #endif
6 T4 R9 P9 U" h* F - #if SHELL_ENTER_CRLF == 1 // CR LF 表示命令结束3 `7 u# E6 m0 N
- || ((*(string + i) == 0x0A) && (*(string + i + 1) == 0x0D))
: ?+ V; r8 _+ U - #endif+ [1 ?. y) \6 Z0 z: z9 S& u
- break;
% L& ^: D3 p* S: U b' k
) R7 |9 }" L2 u. l: U3 e- //出现不为小数点或者非数字的字符,表明该参数为字符串
1 \- D* Y; T+ m9 N' |4 d. ` - if((*(string + i) != '.') || (*(string + i) < '0') || (*(string + i) > '9'))" r7 X* {) p; s& x- S6 g
- return (unsigned int)shellExtParseString(string);
_+ r% u! e: E$ E# ?! r' d* a5 q - + d0 [, c h. \( g" o9 x& k
- i++;0 y: M7 f' |( m
- }9 d, c4 {7 O9 Y4 n' d; k5 O% G
- return (unsigned int)shellExtParseNumber(string);
! Z' C. m1 @ {- s2 S" x! p - }
7 B' y/ V1 i8 c" B/ { - else if (*string == '! b3 f+ c- y& E
- [b][size=3]六、其他常用的 Letter Shell 函数[/size][/b] ^4 g: M) w v4 z$ j
- [b]6.1 shellWriteString[/b]
+ x. v3 R3 r3 s3 A0 j$ O) C - 函数原型如下,这个功能就是 printf 。这个应该很好理解,就不细说了。4 o- b3 L3 |" m; z, h- Y0 W
4 T3 j+ o% G2 W0 n i9 q- [code]/**( L! i A" K8 U; B! j2 v. C
- * @brief shell 写字符串
2 C0 I6 m9 X" N0 I9 ^2 k - *
. V- n$ D$ `$ i! d3 p* o - * @param shell shell对象
' J( R1 H: l7 C) | - * @param string 字符串数据% x) K' v: D: g0 h
- *
- u# h: ~% I0 ~( b" B& H - * @return unsigned short 写入字符的数量
& n+ T' h, p9 n- v- L - */7 Q" p, @8 N; b9 r; W6 g9 r
- 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- /**+ E9 g+ k2 l8 Y, b
- * @brief 获取当前活动shell6 j. H- F4 }+ x" @$ V% F
- * 3 E$ G8 p; T0 Y8 D- [" C) k6 P; n
- * @return Shell* 当前活动shell对象& q) b, I# M! R+ u+ ]
- */$ q4 T2 A- p7 C G! |( N
- 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- 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
- /**" H' w- T: d$ ~% {5 H! ~! e9 S
- * @brief 重命名/移动文件或子目录$ g* l7 n& T8 G$ |2 h. I
- */# u% R* k* ?; s; n! P! C
- void shell_mv(char *old_path,char *new_path)% V/ e( J0 I2 ~% E6 v: Y
- {9 A( v* o0 m3 F% V* t
- FRESULT res;) T' u/ G8 ?9 h8 L( u: ]+ h: F" J
- 5 W: n; X6 g7 r0 C) f
- shell_active = shellGetCurrent(); //Get the currently active shelll U1 y( [. R2 J6 L6 A
- res = f_rename(old_path, new_path);
0 o8 r3 ` j' w9 a+ v - if(res != FR_OK)
d6 ^$ ?" C7 J! Q - {
; d5 b( R3 j/ A2 s - shellWriteString(shell_active,"Operation failed! Error Code:");
4 a9 q6 y# S% K5 j n - shellPrint(shell_active,"%d\r\n",res);3 t/ \2 a. R. n D
- }
# U6 F( t, j& n1 S2 m x( i+ }/ `& ` - }
, Z. e9 c( V+ e0 W0 z$ L+ D - 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! [
- #if SHELL_PRINT_BUFFER > 0- s' f2 u4 J5 E; V6 u
- /**
# |. ?3 T# L2 ?3 W) ] - * @brief shell格式化输出
3 L* K. J: S6 v5 }* U4 m - * / T5 m% ^/ B4 D, _( m
- * @param shell shell对象# R2 S& {8 Q# E6 ]
- * @param fmt 格式化字符串
2 x8 b6 c$ W' p - * @param ... 参数
7 ^- c, |+ |# P a" e5 o) B4 B, N - */- M4 f* A- V9 @4 T7 U9 `9 u
- void shellPrint(Shell *shell, char *fmt, ...)! ], k2 @ }5 c7 H8 _
- {3 }) [4 X# _+ J9 Z. W6 l8 I% |" D
- char buffer[SHELL_PRINT_BUFFER];' Y) o$ E, B1 g
- va_list vargs;
6 D0 j* [! f" F$ _$ \3 W
' {2 H0 h7 g$ v/ V; `7 G- SHELL_ASSERT(shell, return);
' @3 O5 N7 p7 C$ P9 h) f
( V, [. P3 z& }1 m- va_start(vargs, fmt);- c3 L- f1 ^0 V( h
- vsnprintf(buffer, SHELL_PRINT_BUFFER - 1, fmt, vargs);6 x- b* `( U6 l* A
- va_end(vargs);- s$ R: ]' {3 v
- + p; L" ]0 j% F- n9 S$ r
- shellWriteString(shell, buffer);
3 U7 z/ W2 s, [ - }
! L4 N: x! g* c - #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
- /**9 _! f; A3 O- \( ~5 {
- * @brief shell 写字符串
1 h. T* v0 j* h! Q2 p$ `& | - *
+ l+ }0 b1 u$ W9 B - * @param shell shell对象8 ?" t: |1 o$ R2 D! j
- * @param string 字符串数据
9 [* t; w, |$ [! E5 ^0 y - *
6 `8 a! w4 b+ Y' Z - * @return unsigned short 写入字符的数量8 n$ L! |7 \. C$ V9 P
- */6 x$ J9 d: v5 @5 g" d3 d! B7 y# [
- 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- /**6 S' R2 `- i: b( r) F
- * @brief 获取当前活动shell! E! b# a* L% x' o1 t
- *
) k8 J9 A/ [2 J" j2 w) ^: U* W - * @return Shell* 当前活动shell对象7 N& @+ x" C# e! X
- */) ~5 Q! b4 X" H" M) p/ Y% z
- 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. ]
- Shell *shell_active; //当前活动的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
- /**
& d. G6 V; S- o& a; @& B - * @brief 重命名/移动文件或子目录: P/ q! ]4 ^4 ]1 A& Q; S
- */0 p. u. C4 ~! d2 j
- void shell_mv(char *old_path,char *new_path)2 d. g- U8 F7 F& u J# |0 M
- {
5 p, q5 h0 h- }, X - FRESULT res;, j( T" ?) M7 ~, U
- 2 C6 `& }5 L4 [- l- |
- shell_active = shellGetCurrent(); //Get the currently active shelll
* t9 M( @8 c b+ f9 m3 L - res = f_rename(old_path, new_path);* F0 n6 i N( @. y1 X; b8 E
- if(res != FR_OK)! P4 s9 Y1 n, J% `) {0 \/ r
- {
3 p* K8 p1 b1 U9 l* H0 ~9 J - shellWriteString(shell_active,"Operation failed! Error Code:");
1 f) }1 [- O% e E- }( W - shellPrint(shell_active,"%d\r\n",res);
0 U2 n3 c7 P0 v6 O3 i- g5 A - }
# x. r6 P3 L: o- X+ H0 c7 s - }. _# ?! P% k2 g) X8 z1 A% M! K
- 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 ]- #if SHELL_PRINT_BUFFER > 03 a+ H8 c. p$ l6 ^6 Q$ `
- /**1 Z, x' H B- e
- * @brief shell格式化输出) e8 T9 D$ q$ y+ K7 Y w
- * & Y8 b& h' i2 {8 x7 }2 h
- * @param shell shell对象1 J; p8 t; P) R8 v0 z" i7 D
- * @param fmt 格式化字符串4 p% Q4 K$ P7 m6 ~, Q+ m
- * @param ... 参数
b* E2 w: D h x) L) D/ b - */- G1 m2 T! n. q# b( i* n; f7 y
- void shellPrint(Shell *shell, char *fmt, ...). x2 Q) C7 c( m. r, {% ]+ I+ B) C
- { i. Y, d7 @: ]* y+ J
- char buffer[SHELL_PRINT_BUFFER];; |, G1 n2 o( G- ~4 `" R$ C4 z, f# p
- va_list vargs;
8 a7 y& p' [1 ~' f d0 S
/ o9 `. o8 [( q# M- SHELL_ASSERT(shell, return);
* o }% L4 Z' m! X3 g% t
2 \" F, ~3 S4 z# l" [, J- va_start(vargs, fmt);, A1 i/ T8 r( y Z G" |
- vsnprintf(buffer, SHELL_PRINT_BUFFER - 1, fmt, vargs);, d* m( ]3 `4 M* z3 Q- L0 Q
- va_end(vargs);
& j: t) y* ^$ o# ]0 _: X - 0 r& O, f( G2 B1 L, S" L( U
- shellWriteString(shell, buffer);$ C# P6 \$ w) j3 E! I& n
- }1 A4 p% p; G" G0 J8 m0 ?
- #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 |