【极光LPC845】+串口移植letter-shell

流水源

    本次研究移植letter-shell。letter-shell一个功能强大的嵌入式shell，是一个C语言编写的，可以嵌入在程序中的嵌入式shell，主要面向嵌入式设备，以C语言函数为运行单位，可以通过命令行调用，运行程序中的函数。地址：https://github.com/NevermindZZT/letter-shell

功能

• 命令自动补全
• 快捷键功能定义
• 命令权限管理
• 用户管理
• 变量支持
• 代理函数和参数代理解析
  

下面开始移植：移植流程官方仓库说明的很清晰，看说明照着做一遍基本就可以了。

//初始化接口，对接串口。

1. #include "shell_cfg_user.h"
   
2. #include "drv_uart.h"
   
3. #include "shell.h"
   
4. 
   
5. 
   
6. Shell shell;
   
7. char shellBuffer[512];
   
8. 
   
9. 
   
10. /**
    
11. * @brief 用户shell写
    
12. *
    
13. * @param data 数据
    
14. * @param len 数据长度
    
15. *
    
16. * @return short 实际写入的数据长度
    
17. */
    
18. short userShellWrite(char *data, unsigned short len)
    
19. {
    
20.     for(uint32_t i=0;i<len;i++)
    
21.         stdout_putchar(data[i]);
    
22.     return len;
    
23. }
    
24. 
    
25. 
    
26. /**
    
27. * @brief 用户shell读
    
28. *
    
29. * @param data 数据
    
30. * @param len 数据长度
    
31. *
    
32. * @return short 实际读取到
    
33. */
    
34. short userShellRead(char *data, unsigned short len)
    
35. {
    
36.     uint32_t rlen = 0;
    
37.     for(uint32_t i=0;i<len;i++)
    
38.     {
    
39.         if(shell_uart_rx.read_i != shell_uart_rx.write_i)
    
40.         {
    
41.             data[rlen++] = shell_uart_rx.buff[shell_uart_rx.read_i++];
    
42.             shell_uart_rx.read_i &= 0x7f;
    
43.         }
    
44.     }
    
45.     return rlen;
    
46. }
    
47. 
    
48. /**
    
49. * @brief 用户shell上锁
    
50. *
    
51. * @param shell shell
    
52. *
    
53. * @return int 0
    
54. */
    
55. int userShellLock(Shell *shell)
    
56. {
    
57.     return 0;
    
58. }
    
59. 
    
60. /**
    
61. * @brief 用户shell解锁
    
62. *
    
63. * @param shell shell
    
64. *
    
65. * @return int 0
    
66. */
    
67. int userShellUnlock(Shell *shell)
    
68. {
    
69.     return 0;
    
70. }
    
71. 
    
72. /**
    
73. * @brief 用户shell初始化
    
74. *
    
75. */
    
76. void userShellInit(void)
    
77. {
    
78.     shell.write = userShellWrite;
    
79.     shell.read = userShellRead;
    
80. //    shell.lock = userShellLock;
    
81. //    shell.unlock = userShellUnlock;
    
82.     shellInit(&shell, shellBuffer, 512);
    
83. 
    
84. }

复制代码

串口部分：
初始化调用：userShellInit(); //letter shell
主循环中调用：shell_usart_loop();调用shellHandler()处理串口接收的字符。

1. void drv_usart_gpio_init(void)
   
2. {
   
3.     usart_config_t   USART_InitStructure;
   
4.    
   
5.     CLOCK_Select(kUART0_Clk_From_MainClk);
   
6.     RESET_PeripheralReset(kUART0_RST_N_SHIFT_RSTn);
   
7.    
   
8.     USART_GetDefaultConfig(&USART_InitStructure);
   
9.     USART_InitStructure.baudRate_Bps = 115200;
   
10.     USART_InitStructure.enableRx     = 1U;
    
11.     USART_InitStructure.enableTx     = 1U;
    
12.     USART_Init(USART0, &USART_InitStructure, CLOCK_GetMainClkFreq());
    
13.    
    
14.     //使能UARTx RC中断
    
15.     USART_EnableInterrupts(USART0, kUSART_RxReadyInterruptEnable);
    
16.     //优先级，无优先级分组
    
17.     NVIC_SetPriority(USART0_IRQn, 0);
    
18.     //UARTx中断使能
    
19.     NVIC_EnableIRQ(USART0_IRQn);
    
20. 
    
21. #if UART_SHELL == LETTER_SHELL
    
22.     userShellInit(); //letter shell
    
23. #elif UART_SHELL == NR_MICRO_SHELL
    
24.     shell_init();
    
25. #endif
    
26. }
    
27. 
    
28. int stdout_putchar (int ch)
    
29. {
    
30.     while (0 == (USART_GetStatusFlags(USART0) & USART_STAT_TXRDY_MASK));
    
31.     USART_WriteByte(USART0, (uint8_t)ch);
    
32.    
    
33.     return ch;
    
34. }
    
35. 
    
36. int fputc(int ch,FILE *f)
    
37. {
    
38.     return stdout_putchar(ch);
    
39. }
    
40. 
    
41. fifo_buffer  shell_uart_rx=
    
42. {
    
43.     .read_i = 0,
    
44.     .write_i = 0,
    
45. };
    
46. 
    
47. void shell_usart_loop(void)
    
48. {
    
49.     if(shell_uart_rx.read_i != shell_uart_rx.write_i)
    
50.     {
    
51.       #if UART_SHELL == LETTER_SHELL
    
52.             shellHandler(&shell, shell_uart_rx.buff[shell_uart_rx.read_i++]); //letter shell
    
53.         #elif UART_SHELL == NR_MICRO_SHELL
    
54.             shell(shell_uart_rx.buff[shell_uart_rx.read_i++]);
    
55.         #endif
    
56.         shell_uart_rx.read_i &= 0x7f;
    
57.     }
    
58. }
    
59. 
    
60. void USART0_IRQHandler(void)
    
61. {
    
62.     uint32_t statusFlag;
    
63.     uint32_t ch;
    
64.    
    
65.     statusFlag = USART0->STAT;
    
66.     if((statusFlag & USART_STAT_RXRDY_MASK) != 0)
    
67.     {
    
68.         ch = USART_ReadByte(USART0);
    
69.         if(((shell_uart_rx.write_i+1)&0x7f) != shell_uart_rx.read_i)
    
70.         {
    
71.             shell_uart_rx.buff[shell_uart_rx.write_i++] = ch & 0xff;
    
72.             shell_uart_rx.write_i &= 0x7f;
    
73.         }
    
74.     }
    
75.     USART0->STAT |= statusFlag;
    
76. }
    

复制代码

使用方法，仓库内也有说明和例子。
例如添加用户的定义：
//测试添加用户：
SHELL_EXPORT_USER(SHELL_CMD_PERMISSION(0xFF), root, 666666, root user);
SHELL_EXPORT_USER(SHELL_CMD_PERMISSION(0x01), LSY,  666666, test user);

这里添加了2个用户，root和LSY。密码都是666666.但是2个用户权限不同。

letter-shell有2种添加函数命令方式。
第一种main函数形式。看如下例子，使用int argc, char *argv[]参数，并给函数添加不同权限。
默认的letter用户是使用不了下面函数命令的，
新加的root拥有下面2个函数func和func2权限.
新加的LSY只拥有func的权限。

1. //测试添加mian命令
   
2. int func(int argc, char *argv[])
   
3. {
   
4.     printf("%d parameter(s)\r\n", argc);
   
5.     for (char i = 1; i < argc; i++)
   
6.     {
   
7.         printf("%s\r\n", argv[i]);
   
8.     }
   
9.     return  0;
   
10. }
    
11. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0x01)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN), func, func, test1);
    
12. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0x02)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN), func2, func, test2);
    
13. //letter:/$ func "hello world"
    
14. //2 parameter(s)
    
15. //hello world

复制代码

第二种是普通C函数形式：
如下例子：主要是函数参数方式不同。在输入命令参数时的方式就不同。
这个例子设置函数权限为0，意思是所有用户都拥有这个函数权限。

1. //测试添加func命令
   
2. int func1(int i, char ch, char *str)
   
3. {
   
4.     printf("input int: %d, char: %c, string: %s\r\n", i, ch, str);
   
5.     return  0;
   
6. }
   
7. SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC), func1, func1, test3);
   
8. //letter:/$ func1 666 'A' "hello world"
   
9. //input int: 666, char: A, string: hello world
   
10. 
    

复制代码

添加变量方式：
这里权限使用0xFF，标识除了权限为0的用户，其他用户都可以操作这个变量。

1. uint32_t    muzhu_cnt；
   
2. 
   
3. SHELL_EXPORT_VAR(SHELL_CMD_PERMISSION(0xFF) | SHELL_CMD_TYPE(SHELL_TYPE_VAR_INT),muzhu_cnt,&muzhu_cnt,muzhu-count);
   

复制代码

下面测试一下效果：
这是默认用户letter时效果。


下面切换到root用户看看，直接输入root回车，然后输入密码666666.



下面切换LSY用户效果：


可以看到不同用户下，命令根据权限的不同。执行的命令也不同。

工程添加的文件：shell_port.c,shell_port.h,shell_cfg_user.h为添加的接口文件。


shell_cfg_user.h添加的配置：

1. 
   
2. #if 0
   
3. #define     SHELL_TASK_WHILE                //是否使用默认shell任务while循环
   
4. #define     SHELL_USING_CMD_EXPORT          //是否使用命令导出方式
   
5. #define     SHELL_USING_COMPANION           //是否使用shell伴生对象功能
   
6. #define     SHELL_SUPPORT_END_LINE          //是否支持shell尾行模式
   
7. #define     SHELL_HELP_LIST_USER            //是否在输入命令列表中列出用户
   
8. #define     SHELL_HELP_LIST_VAR             //是否在输入命令列表中列出变量
   
9. #define     SHELL_HELP_LIST_KEY             //是否在输入命令列表中列出按键
   
10. #define     SHELL_ENTER_LF                  //使用LF作为命令行回车触发
    
11. #define     SHELL_ENTER_CR                  //使用CR作为命令行回车触发
    
12. #define     SHELL_ENTER_CRLF                //使用CRLF作为命令行回车触发
    
13. #define     SHELL_EXEC_UNDEF_FUNC           //使用执行未导出函数的功能
    
14. #define     SHELL_COMMAND_MAX_LENGTH        //shell命令最大长度
    
15. #define     SHELL_PARAMETER_MAX_NUMBER      //shell命令参数最大数量
    
16. #define     SHELL_HISTORY_MAX_NUMBER        //历史命令记录数量
    
17. #define     SHELL_DOUBLE_CLICK_TIME         //双击间隔(ms)
    
18. #define     SHELL_QUICK_HELP                //快速帮助
    
19. #define     SHELL_MAX_NUMBER                //管理的最大shell数量
    
20. #define     SHELL_GET_TICK()                //获取系统时间(ms)
    
21. #define     SHELL_USING_LOCK                //是否使用锁
    
22. #define     SHELL_MALLOC(size)              //内存分配函数(shell本身不需要)
    
23. #define     SHELL_FREE(obj)                 //内存释放函数(shell本身不需要)
    
24. #define     SHELL_SHOW_INFO                 //是否显示shell信息
    
25. #define     SHELL_CLS_WHEN_LOGIN            //是否在登录后清除命令行
    
26. #define     SHELL_DEFAULT_USER              //shell默认用户
    
27. #define     SHELL_DEFAULT_USER_PASSWORD     //默认用户密码
    
28. #define     SHELL_LOCK_TIMEOUT              //shell自动锁定超时
    
29. 
    
30. #endif
    
31. 
    
32. /**
    
33. * @brief 是否使用shell伴生对象
    
34. *        一些扩展的组件(文件系统支持，日志工具等)需要使用伴生对象
    
35. */
    
36. #define     SHELL_USING_COMPANION       1
    
37. 
    
38. 
    
39. /**
    
40. * @brief 支持shell尾行模式
    
41. */
    
42. #define     SHELL_SUPPORT_END_LINE      1
    
43. 
    
44. 
    
45. /**
    
46. * @brief 使用LF作为命令行回车触发
    
47. *        可以和SHELL_ENTER_CR同时开启
    
48. */
    
49. #define     SHELL_ENTER_LF              1
    
50. 
    
51. /**
    
52. * @brief 使用CR作为命令行回车触发
    
53. *        可以和SHELL_ENTER_LF同时开启
    
54. */
    
55. #define     SHELL_ENTER_CR              1
    
56. 
    
57. /**
    
58. * @brief 使用CRLF作为命令行回车触发
    
59. *        不可以和SHELL_ENTER_LF或SHELL_ENTER_CR同时开启
    
60. */
    
61. #define     SHELL_ENTER_CRLF            0
    
62. 
    
63. /**
    
64. * @brief shell格式化输入的缓冲大小
    
65. *        为0时不使用shell格式化输入
    
66. * @note shell格式化输入会阻塞shellTask, 仅适用于在有操作系统的情况下使用
    
67. */
    
68. //#define     SHELL_SCAN_BUFFER          0
    
69. 
    
70. /**
    
71. * @brief 获取系统时间(ms)
    
72. *        定义此宏为获取系统Tick，如`HAL_GetTick()`
    
73. * @note 此宏不定义时无法使用双击tab补全命令help，无法使用shell超时锁定
    
74. */
    
75. //#define     SHELL_GET_TICK()            HAL_GetTick()
    
76. 
    
77. /**
    
78. * @brief 使用锁
    
79. * @note 使用shell锁时，需要对加锁和解锁进行实现
    
80. */
    
81. //#define     SHELL_USING_LOCK            0
    
82. 
    
83. /**
    
84. * @brief shell内存分配
    
85. *        shell本身不需要此接口，若使用shell伴生对象，需要进行定义
    
86. */
    
87. #define     SHELL_MALLOC(size)          malloc(size)
    
88. 
    
89. /**
    
90. * @brief shell内存释放
    
91. *        shell本身不需要此接口，若使用shell伴生对象，需要进行定义
    
92. */
    
93. #define     SHELL_FREE(obj)             free(obj)
    
94. 
    

复制代码

阅读全文

NXP管管

这篇很丰富，已经开始期待下一篇了。（坏笑）

流水源

NXP管管 发表于 2023-6-15 16:50
这篇很丰富，已经开始期待下一篇了。（坏笑）

下一篇也会来的

mgn

棒棒哒

az158

厉害呀，看起来不错

jobszheng5

这个shell 看起来还是挺漂亮的

xiaoshen-372360

厉害呀，看起来不错

andeyqi

学习了解下  感谢分享

eefocus_3865752

666666666666666