RISC-V单片机快速入门04-基于RT_Thread Nano添加FinSH

小飞飞

RISC-V单片机快速入门01-开发环境搭建
RISC-V单片机快速入门02-移植RT_Thread Nano
RISC-V单片机快速入门03-基于RT_Thread Nano添加控制台
RISC-V单片机快速入门04-基于RT_Thread Nano添加FinSH
RISC-V单片机快速入门05-串口助手发送AT指令启动TCP Server
RISC-V单片机快速入门06-控制ESP8266启动Http Server
RISC-V单片机快速入门07-板载LCD显示ESP8266数据

本系列上一篇：RISC-V单片机快速入门03-基于RT_Thread Nano添加控制台

一基础知识

1.FinSH简介

RT-Thread FinSH 是 RT-Thread 的命令行组件（shell），提供一套供用户在命令行调用的操作接口，主要用于调试或查看系统信息。它可以使用串口 / 以太网 / USB 等与 PC 机进行通信，本文使用串口进行通信，使用 FinSH 组件基本命令的效果图如下所示：

二,添加步骤

1.导入工程

将上一节内容进行复制，修改.project中工程名字为FinSH，然后重新import进来新的工程

2.添加FinSH源码到工程

将rt-thread-3.1.3/components/finsh下文件添加到RT-Thread下。

添加成功后结果如下：

3.添加头文件路径

右击工程，点击 properties 进入下图所示界面，点击 C/C++ Build -> settings ，添加头文件路径

4.打开宏定义

添加号FinSH组件源码后，可以看到实际功能并没有打开，需要开启RT_USING_FINSH宏定义。

打开rtconfig.h文件，增加宏定义：#define RT_USING_FINSH

5.适配FinSH组件接口

(1) 修改GD32VF103xB.lds文件

在上图.text中添加如下代码：

1. /* section information for finsh shell */
   
2. . = ALIGN(4);
   
3. __fsymtab_start = .;
   
4. KEEP(*(FSymTab))
   
5. __fsymtab_end = .;
   
6. . = ALIGN(4);
   
7. __vsymtab_start = .;
   
8. KEEP(*(VSymTab))
   
9. __vsymtab_end = .;
   
10. . = ALIGN(4);
    
11. 
    
12. /* section information for initial. */
    
13. . = ALIGN(4);
    
14. __rt_init_start = .;
    
15. KEEP(*(SORT(.rti_fn*)))
    
16. __rt_init_end = .;
    
17. . = ALIGN(4);
    
18. 
    
19. /* section information for modules */
    
20. . = ALIGN(4);
    
21. __rtmsymtab_start = .;
    
22. KEEP(*(RTMSymTab))
    
23. __rtmsymtab_end = .;

复制代码

修改后如下所示

(2) 移植函数

本文采用中断方式获取串口接收到字符，原理是，在 uart 接收到数据时产生中断，在中断中把数据存入 ringbuffer 缓冲区，然后释放信号量，tshell 线程接收信号量，然后读取存在 ringbuffer 中的数据。

在gd32vf102c_start.c文件中，实现rt_hw_console_getchar如下:

1. #define UART_RX_BUF_LEN 128
   
2. rt_uint8_t uart_rx_buf[UART_RX_BUF_LEN] = {0};
   
3. struct rt_ringbuffer uart_rxcb; /* 定义一个 ringbuffer cb */
   
4. static struct rt_semaphore shell_rx_sem; /* 定义一个静态信号量 */
   
5. void gd_eval_com_init(uint32_t com)
   
6. {
   
7. uint32_t com_id = 0U;
   
8. if(EVAL_COM0 == com){
   
9.         com_id = 0U;
   
10.     }else if(EVAL_COM1 == com){
    
11.         com_id = 1U;
    
12.     }
    
13. 
    
14. /* 初始化串口接收 ringbuffer  */
    
15.     rt_ringbuffer_init(&uart_rxcb, uart_rx_buf, UART_RX_BUF_LEN);
    
16. 
    
17. /* 初始化串口接收数据的信号量 */
    
18.     rt_sem_init(&(shell_rx_sem), "shell_rx", 0, 0);
    
19. 
    
20.     eclic_irq_enable(USART0_IRQn, 1, 0);
    
21. 
    
22. /* enable GPIO clock */
    
23.     rcu_periph_clock_enable(COM_GPIO_CLK[com_id]);
    
24. 
    
25. /* enable USART clock */
    
26.     rcu_periph_clock_enable(COM_CLK[com_id]);
    
27. 
    
28. /* connect port to USARTx_Tx */
    
29.     gpio_init(COM_GPIO_PORT[com_id], GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, COM_TX_PIN[com_id]);
    
30. 
    
31. /* connect port to USARTx_Rx */
    
32.     gpio_init(COM_GPIO_PORT[com_id], GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, COM_RX_PIN[com_id]);
    
33. 
    
34. /* USART configure */
    
35.     usart_deinit(com);
    
36.     usart_baudrate_set(com, 115200U);
    
37.     usart_word_length_set(com, USART_WL_8BIT);
    
38.     usart_stop_bit_set(com, USART_STB_1BIT);
    
39.     usart_parity_config(com, USART_PM_NONE);
    
40.     usart_hardware_flow_rts_config(com, USART_RTS_DISABLE);
    
41.     usart_hardware_flow_cts_config(com, USART_CTS_DISABLE);
    
42.     usart_receive_config(com, USART_RECEIVE_ENABLE);
    
43.     usart_transmit_config(com, USART_TRANSMIT_ENABLE);
    
44.     usart_enable(com);
    
45.     usart_interrupt_enable(com, USART_INT_RBNE);
    
46. }
    
47. 
    
48. char rt_hw_console_getchar(const char str)
    
49. {
    
50. int ch = 0;
    
51.     / 从 ringbuffer 中拿出数据 */
    
52. while (rt_ringbuffer_getchar(&uart_rxcb, (rt_uint8_t *)&ch) != 1)
    
53.     {
    
54.         rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
    
55.     }
    
56. return ch;
    
57. }
    
58. 
    
59. void USART0_IRQHandler() {
    
60. int ch = -1;
    
61. int recv_flag = 0;
    
62. /* enter interrupt /
    
63.     rt_interrupt_enter();
    
64. if(RESET != usart_interrupt_flag_get(EVAL_COM0, USART_INT_FLAG_RBNE)){
    
65. while (1)
    
66.         {
    
67.             ch = -1;
    
68. if (RESET != usart_interrupt_flag_get(EVAL_COM0, USART_INT_FLAG_RBNE))
    
69.             {
    
70.                 ch =  usart_data_receive(EVAL_COM0);
    
71. //                rt_kprintf("recv data is :%x\r\n", ch);
    
72.             }
    
73. if (ch == -1)
    
74.             {
    
75. break;
    
76.             }
    
77.             recv_flag = 1;
    
78.             / 读取到数据，将数据存入 ringbuffer */
    
79.             rt_ringbuffer_putchar(&uart_rxcb, ch);
    
80.         }
    
81. //        if (1 == recv_flag)
    
82. //        {
    
83.             rt_sem_release(&shell_rx_sem);
    
84. //        }
    
85.     }
    
86.     rt_interrupt_leave();
    
87. }
    
88. 
    
89. 新增ringbuffer.c函数
    
90. /* 第一部分：ringbuffer 实现部分 */
    
91. #include <rtthread.h>
    
92. #include <string.h>
    
93. #include "ringbuffer.h"
    
94. rt_inline enum rt_ringbuffer_state rt_ringbuffer_status(struct rt_ringbuffer *rb)
    
95. {
    
96. if (rb->read_index == rb->write_index)
    
97.     {
    
98. if (rb->read_mirror == rb->write_mirror)
    
99. return RT_RINGBUFFER_EMPTY;
    
100. else
     
101. return RT_RINGBUFFER_FULL;
     
102.     }
     
103. return RT_RINGBUFFER_HALFFULL;
     
104. }
     
105. /**
     
106. * get the size of data in rb
     
107. */
     
108. rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb)
     
109. {
     
110. switch (rt_ringbuffer_status(rb))
     
111.     {
     
112. case RT_RINGBUFFER_EMPTY:
     
113. return 0;
     
114. case RT_RINGBUFFER_FULL:
     
115. return rb->buffer_size;
     
116. case RT_RINGBUFFER_HALFFULL:
     
117. default:
     
118. if (rb->write_index > rb->read_index)
     
119. return rb->write_index - rb->read_index;
     
120. else
     
121. return rb->buffer_size - (rb->read_index - rb->write_index);
     
122.     };
     
123. }
     
124. 
     
125. void rt_ringbuffer_init(struct rt_ringbuffer *rb,
     
126.                         rt_uint8_t           *pool,
     
127.                         rt_int16_t            size)
     
128. {
     
129.     RT_ASSERT(rb != RT_NULL);
     
130.     RT_ASSERT(size > 0);
     
131. 
     
132. /* initialize read and write index */
     
133.     rb->read_mirror = rb->read_index = 0;
     
134.     rb->write_mirror = rb->write_index = 0;
     
135. 
     
136. /* set buffer pool and size */
     
137.     rb->buffer_ptr = pool;
     
138.     rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
     
139. }
     
140. 
     
141. /**
     
142. * put a character into ring buffer
     
143. */
     
144. rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
     
145. {
     
146.     RT_ASSERT(rb != RT_NULL);
     
147. 
     
148. /* whether has enough space */
     
149. if (!rt_ringbuffer_space_len(rb))
     
150. return 0;
     
151. 
     
152.     rb->buffer_ptr[rb->write_index] = ch;
     
153. 
     
154. /* flip mirror */
     
155. if (rb->write_index == rb->buffer_size-1)
     
156.     {
     
157.         rb->write_mirror = ~rb->write_mirror;
     
158.         rb->write_index = 0;
     
159.     }
     
160. else
     
161.     {
     
162.         rb->write_index++;
     
163.     }
     
164. 
     
165. return 1;
     
166. }
     
167. /**
     
168. * get a character from a ringbuffer
     
169. */
     
170. rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch)
     
171. {
     
172.     RT_ASSERT(rb != RT_NULL);
     
173. 
     
174. /* ringbuffer is empty */
     
175. if (!rt_ringbuffer_data_len(rb))
     
176. return 0;
     
177. 
     
178. /* put character */
     
179.     *ch = rb->buffer_ptr[rb->read_index];
     
180. 
     
181. if (rb->read_index == rb->buffer_size-1)
     
182.     {
     
183.         rb->read_mirror = ~rb->read_mirror;
     
184.         rb->read_index = 0;
     
185.     }
     
186. else
     
187.     {
     
188.         rb->read_index++;
     
189.     }
     
190. 
     
191. return 1;
     
192. }

复制代码

三,运行结果

使用jlink烧录，通过控制台输入version，运行结果如下所示

四,结语

如在使用过程中有任何问题，请加QQ群进一步交流。

QQ交流群：728522642 (备注：物联网项目交流)

本篇完，感谢关注：RISC-V单片机中文网