RT-Thread-梁山派GD32F450/470-RT-Thread Nano 移植（三）RT-Thread问答社区

梁山派GD32F450/470-RT-Thread Nano 移植（三）

发布于 2023-09-25 16:59:53 浏览：154 订阅该版

这是梁山派移植RT-Thread Nano的第三篇文章，也是最后一篇，将FinSH组件也移植进来
还没看过前两篇的建议先去看前两篇，链接如下：
[梁山派GD32F450/470-RT-Thread Nano 移植（一）](https://club.rt-thread.org/ask/article/2d32c106484f38da.html "梁山派GD32F450/470-RT-Thread Nano 移植（一）")
[梁山派GD32F450/470-RT-Thread Nano 移植 （二）](https://club.rt-thread.org/ask/article/8e181bf9fab39879.html "梁山派GD32F450/470-RT-Thread Nano 移植 （二）")

------------

下面是FinSH组件的简介
RT-Thread FinSH 是 RT-Thread 的命令行组件（shell），提供一套供用户在命令行调用的操作接口，主要用于调试或查看系统信息。它可以使用串口 / 以太网 / USB 等与 PC 机进行通信，使用 FinSH 组件基本命令的效果图如下所示：
![i12.gif](https://oss-club.rt-thread.org/uploads/20230925/4a0c1b41144deadde5696ac32bfedaea.gif)
来源：[RT-Thread文档中心-在 Nano 上添加 FinSH 组件（实现命令输入）](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-nano/finsh-port/an0045-finsh-port?id=%e5%9c%a8-nano-%e4%b8%8a%e6%b7%bb%e5%8a%a0-finsh-%e7%bb%84%e4%bb%b6%ef%bc%88%e5%ae%9e%e7%8e%b0%e5%91%bd%e4%bb%a4%e8%be%93%e5%85%a5%ef%bc%89 "RT-Thread文档中心-在 Nano 上添加 FinSH 组件（实现命令输入）")

------------

[Nano移植文件(三).7z](https://club.rt-thread.org/file_download/767231c2c7926ff7)
老规矩，先给文件
文件信息如下
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/b621c9f0961bc67cd99c5af849f487f1.png.webp)

移植步骤如下：
1、在keil中添加FinSH源码
打开未移植FinSH的keil工程，按图中将shell勾选上，这会把FinSH组件的源码添加到工程中
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/3b683f30841890fe78e512ae1729c64a.png.webp)

然后在rtconfig.h中将#include "finsh_config.h"的注释释放掉，如下图所示
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/99c9e55e5ea2921172ff91e01a7c24bf.png.webp)

2、ringbuffer实现部分
这一部分我也不是很明白，不过也不需要太明白，官方有示例，直接复制过来即可，这个不会因为芯片不同而产生区别，只把它当作一个缓冲区就可以了

移植代码直接粘贴到finsh_port.c文件中即可
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/bff5f0f6b85e3faceef6935324ffa553.png.webp)

代码如下：

```c
/* 第一部分：ringbuffer 实现部分 */
#include <rtthread.h>
#include <string.h>

#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb))

struct rt_ringbuffer
{
    rt_uint8_t *buffer_ptr;

rt_uint16_t read_mirror : 1;
    rt_uint16_t read_index : 15;
    rt_uint16_t write_mirror : 1;
    rt_uint16_t write_index : 15;

rt_int16_t buffer_size;
};

enum rt_ringbuffer_state
{
    RT_RINGBUFFER_EMPTY,
    RT_RINGBUFFER_FULL,
    /* half full is neither full nor empty */
    RT_RINGBUFFER_HALFFULL,
};

rt_inline enum rt_ringbuffer_state rt_ringbuffer_status(struct rt_ringbuffer *rb)
{
    if (rb->read_index == rb->write_index)
    {
        if (rb->read_mirror == rb->write_mirror)
            return RT_RINGBUFFER_EMPTY;
        else
            return RT_RINGBUFFER_FULL;
    }
    return RT_RINGBUFFER_HALFFULL;
}

/**
 * get the size of data in rb
 */
rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb)
{
    switch (rt_ringbuffer_status(rb))
    {
    case RT_RINGBUFFER_EMPTY:
        return 0;
    case RT_RINGBUFFER_FULL:
        return rb->buffer_size;
    case RT_RINGBUFFER_HALFFULL:
    default:
        if (rb->write_index > rb->read_index)
            return rb->write_index - rb->read_index;
        else
            return rb->buffer_size - (rb->read_index - rb->write_index);
    };
}

void rt_ringbuffer_init(struct rt_ringbuffer *rb,
                        rt_uint8_t           *pool,
                        rt_int16_t            size)
{
    RT_ASSERT(rb != RT_NULL);
    RT_ASSERT(size > 0);

/* initialize read and write index */
    rb->read_mirror = rb->read_index = 0;
    rb->write_mirror = rb->write_index = 0;

/* set buffer pool and size */
    rb->buffer_ptr = pool;
    rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
}

/**
 * put a character into ring buffer
 */
rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{
    RT_ASSERT(rb != RT_NULL);

/* whether has enough space */
    if (!rt_ringbuffer_space_len(rb))
        return 0;

rb->buffer_ptr[rb->write_index] = ch;

/* flip mirror */
    if (rb->write_index == rb->buffer_size-1)
    {
        rb->write_mirror = ~rb->write_mirror;
        rb->write_index = 0;
    }
    else
    {
        rb->write_index++;
    }

return 1;
}
/**
 * get a character from a ringbuffer
 */
rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch)
{
    RT_ASSERT(rb != RT_NULL);

/* ringbuffer is empty */
    if (!rt_ringbuffer_data_len(rb))
        return 0;

/* put character */
    *ch = rb->buffer_ptr[rb->read_index];

if (rb->read_index == rb->buffer_size-1)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = 0;
    }
    else
    {
        rb->read_index++;
    }

return 1;
}
```
3、finsh 移植对接部分
在这一部分我们开始对接finSH组件，对接finSH组件的一个大致流程如下：
当有数据通过串口输入时，进入串口中断，在中断服务函数中将数据存入ringbuffer缓冲区，等数据传输完毕，会触发另一个串口中断并进入中断服务函数，告诉finSH组件数据接收完毕，然后finSH组件开始读取ringbuffer缓冲区中的数据
下面是该部分的移植
3.1 初始化串口中断
在前两篇中，我们已经做好了串口初始化，所以我们在这里直接剪切过来即可，将写图中代码剪切
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/8140e3597b1f453a84a1421e5372143e.png.webp)

粘贴到下图中的位置
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/d326c95f37fd70c8cd79b9aa9c590a37.png.webp)

在finsh_port.c文件中引入串口的头文件，如图所示
```c
#include "bsp_usart.h"
```
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/60490b549d1cf354f9646d4542ac13b5.png.webp)

然后我们定义几个需要用到的变量
UART_RX_BUF_LEN是串口接收数据长度宏定义
uart_rx_buf是串口接收缓冲区
uart_rxcb是ringbuffer cb（这个不是很懂，个人理解是用来管理串口接收缓冲区的）
shell_rx_sem是信号量，当串口接收完成后中断函数会释放信号量，而finSH组件会接收该信号量，然后读取接收到的数据
```c
#define UART_RX_BUF_LEN 16
rt_uint8_t uart_rx_buf[UART_RX_BUF_LEN] = {0};
struct rt_ringbuffer  uart_rxcb;         /* 定义一个 ringbuffer cb */
static struct rt_semaphore shell_rx_sem; /* 定义一个静态信号量 */
```
将他们放到下图中的位置
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/3d7d0dd9be19c6ef66a728e9c64c9404.png.webp)

在串口初始化函数中初始化ringbuffer cb变量uart_rxcb和信号量shell_rx_sem
```c
	/* 初始化串口接收 ringbuffer  */
    rt_ringbuffer_init(&uart_rxcb, uart_rx_buf, UART_RX_BUF_LEN);

/* 初始化串口接收数据的信号量 */
    rt_sem_init(&(shell_rx_sem), "shell_rx", 0, 0);
```
将他们放到下图中的位置
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/c11541bd21e4250fbf680f42d26deb4d.png.webp)

编写串口中断服务函数
```c
/* uart 中断 */
void USART0_IRQHandler(void)
{
    int ch;
    /* enter interrupt */
    rt_interrupt_enter();          //在中断中一定要调用这对函数，进入中断
	
	if (usart_interrupt_flag_get(BSP_USART,USART_INT_FLAG_RBNE) == SET)   // 接收缓冲区不为空
	{
		ch =  usart_data_receive(BSP_USART);
	}
	if (usart_interrupt_flag_get(BSP_USART,USART_INT_FLAG_IDLE) == SET)   // 检测到帧中断
	{
		usart_data_receive(BSP_USART);                                     // 必须要读，读出来的值不能要
		ch = '\0';														   // 数据接收完毕，数组结束标志
		rt_sem_release(&shell_rx_sem);
	}
	/* 读取到数据，将数据存入 ringbuffer */
	rt_ringbuffer_putchar(&uart_rxcb, ch);

/* leave interrupt */
    rt_interrupt_leave();    //在中断中一定要调用这对函数，离开中断
}
```
将他们放到下图中的位置
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/ef1dd160a24a78925fcddce7de999309.png.webp)

并将bsp_usart文件中的串口中断函数注释掉，如下面图片所示
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/bf7ddd971989aee48651bb0ad9352883.png.webp)

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/d3f2a50468f1bf15778b1cafdf10cde4.png.webp)

3.2 rt_hw_console_getchar函数实现
经过以上的步骤，已成功将官方示例的基础移植完成，这里只需要将官方示例中的rt_hw_console_getchar函数直接复制过来即可
```c
/* 移植 FinSH，实现命令行交互, 需要添加 FinSH 源码，然后再对接 rt_hw_console_getchar */
/* 中断方式 */
char rt_hw_console_getchar(void)
{
    char ch = 0;

/* 从 ringbuffer 中拿出数据 */
    while (rt_ringbuffer_getchar(&uart_rxcb, (rt_uint8_t *)&ch) != 1)
    {
        rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
    }
    return ch;
}
```
将上面代码放置到下图中的位置
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/64b16a64694a3fc8eb44bb52d01f2efc.png.webp)

以上就实现了在梁山派的Nano上添加FinSH组件（实现命令输入）

------------

这里直接烧录通过串口查看即可（记得注释掉main函数中的rt_kprintf打印函数，实验现象会明显一些）
实验现象如下图：
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230925/1ab57df9bf15b936debe500261c32147.png)

总结如下：
以上就是在梁山派的Nano上添加FinSH组件（实现命令输入）的全过程，也是梁山派GD32F450/470-RT-Thread Nano 移植的最后一篇
实现了梁山派RT-Thread Nano版本的移植，梁山派Nano上UART控制台的添加以及梁山派Nano上FinSH组件的添加
并针对每一部分的移植实现了该部分的示例

参考资料：
1、[基于 Keil MDK 移植 RT-Thread Nano](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-nano/nano-port-keil/an0039-nano-port-keil "基于 Keil MDK 移植 RT-Thread Nano")
2、[立创开发板-梁山派教程文档](https://lckfb.com/docs/lckfb_lspi/#/ "立创开发板-梁山派教程文档")
3、[立创梁山派](https://lceda001.feishu.cn/wiki/JNDHwxPWWi99CJk6SkMc6Z3Yn2e "立创梁山派")
4、[梁山派GD32F450/470-RT-Thread Nano 移植（一）](https://club.rt-thread.org/ask/article/2d32c106484f38da.html "梁山派GD32F450/470-RT-Thread Nano 移植（一）")
5、[梁山派GD32F450/470-RT-Thread Nano 移植 （二）](https://club.rt-thread.org/ask/article/8e181bf9fab39879.html "梁山派GD32F450/470-RT-Thread Nano 移植 （二）")