RT-Thread-RT-Thread开发GD32F450 添加串口外设，以及一种串口接收数据处理的方法RT-Thread问答社区

RT-Thread开发GD32F450 添加串口外设，以及一种串口接收数据处理的方法

发布于 2023-03-27 16:16:14 浏览：777 订阅该版

开发板使用的是gd32f450zk，env工具使用的版本是1.3.5，rtthread版本是5.0.0。
  添加串口外设的方法，串口2是打印口，串口0是数据收发口。
  串口2的引脚是PB10和PD9，串口0的引脚是PA9和PA10.
  使用env工具，menuconfig进行配置，修改调试打印口的名称为uart2，如下图：
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230327/c7b8412f8f6c8aacec611b9c0ef3a64f.png.webp)
  串口的配置，如下图：
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230327/f51f763556c333409d6a7479650ea0c0.png.webp)
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230327/3db4a5dea037854b630ae809c62ba5ab.png.webp)
保存之后，生成工程。打开工程进行查看，如下图：
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230327/5781394fdb49ceb10613efc3fdfa90af.png.webp)
 对串口2的代码进行修改，修改之后如下：
```
#ifdef BSP_USING_UART2
    {
        USART2,                                 // uart peripheral index
        USART2_IRQn,                            // uart iqrn
        RCU_USART2, RCU_GPIOB, RCU_GPIOD,       // periph clock, tx gpio clock, rt gpio clock
#if defined SOC_SERIES_GD32F4xx
        GPIOB, GPIO_AF_7, GPIO_PIN_10,          // tx port, tx alternate, tx pin
        //GPIOB, GPIO_AF_7, GPIO_PIN_11,          // rx port, rx alternate, rx pin
        GPIOD, GPIO_AF_7, GPIO_PIN_9,          // rx port, rx alternate, rx pin
        //GPIOC, GPIO_AF_7, GPIO_PIN_11,          // rx port, rx alternate, rx pin
#else
        GPIOB, GPIO_PIN_10,          // tx port, tx pin
        GPIOB, GPIO_PIN_11,          // rx port, rx pin
#endif
        &serial2,
        "uart2",
    },
    #endif
```
  对工程进行编译，下载到开发板运行，可以看到串口2打印的信息，如下图，
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230327/2a4a698ad263567ca9e482f24d34d56d.png)
  串口0数据收发口的测试，直接复制官方文档的测试demo，进行修改，改成串口0，代码如下：
```
/*
 * 程序清单：这是一个 串口 设备使用例程
 * 例程导出了 uart_sample 命令到控制终端
 * 命令调用格式：uart_sample uart2
 * 命令解释：命令第二个参数是要使用的串口设备名称，为空则使用默认的串口设备
 * 程序功能：通过串口输出字符串"hello RT-Thread!"，然后错位输出输入的字符
*/

#include <rtthread.h>

#define SAMPLE_UART_NAME       "uart0"

/* 用于接收消息的信号量 */
static struct rt_semaphore rx_sem;
static rt_device_t serial;

/* 接收数据回调函数 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    /* 串口接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
    rt_sem_release(&rx_sem);

return RT_EOK;
}

static void serial_thread_entry(void *parameter)
{
    char ch;

while (1)
    {
        /* 从串口读取一个字节的数据，没有读取到则等待接收信号量 */
        while (rt_device_read(serial, -1, &ch, 1) != 1)
        {
            /* 阻塞等待接收信号量，等到信号量后再次读取数据 */
            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
        }
        /* 读取到的数据通过串口错位输出 */
        ch = ch + 1;
        rt_device_write(serial, 0, &ch, 1);
    }
}

static int uart_sample(int argc, char *argv[])
{
    rt_err_t ret = RT_EOK;
    char uart_name[RT_NAME_MAX];
    char str[] = "hello RT-Thread!\r\n";

if (argc == 2)
    {
        rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
    }
    else
    {
        rt_strncpy(uart_name, SAMPLE_UART_NAME, RT_NAME_MAX);
    }

/* 查找系统中的串口设备 */
    serial = rt_device_find(uart_name);
    if (!serial)
    {
        rt_kprintf("find %s failed!\n", uart_name);
        return RT_ERROR;
    }

/* 初始化信号量 */
    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
    /* 以中断接收及轮询发送模式打开串口设备 */
    rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
    /* 设置接收回调函数 */
    rt_device_set_rx_indicate(serial, uart_input);
    /* 发送字符串 */
    rt_device_write(serial, 0, str, (sizeof(str) - 1));

return ret;
}
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(uart_sample, uart device sample);
```
  测试，可以看到串口0发送了信息"hello RT-Thread!"，用串口调试助手进行数据发送，可以看到串口0接收到数据并且返回数据。
  在此基础上进行修改，使用3个信号量，设计一种带超时的数据接收处理方式，修改后的代码如下：
```
/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-02-03     XYZ       the first version
 */

#include <rtthread.h>
#include <stdlib.h>
#include <string.h>
#include <rtdevice.h>

#define SAMPLE_UART_NAME       "uart0"
#define LRNGTH 256

/* 用于接收消息的信号量 */
static struct rt_semaphore rx_sem;
static struct rt_semaphore rx_semRx;
static struct rt_semaphore rx_semRxTimeOut;
static rt_device_t serial;

static uint8_t bufTemp[LRNGTH]={0};
static uint8_t bufTempNum=0;

//发送函数
static int Bsp_Tx(uint8_t *buf,int size)
{
    rt_device_write(serial, 0, buf, size);
//    for(int k=0;k < size;k++)
//    {
//      rt_kprintf("send_buf[%d]=%02x\r\n",k,buf[k]);
//    }
    return 0;
}
//调用此函数，获取接收数据,带超时
static int Bsp_Rx(uint8_t *buf,int size)
{
    rt_err_t ret;
  
//    struct timeval tv = { 0 };
//    struct timezone tz = { 0 };
//    gettimeofday(&tv, &tz);
//    rt_kprintf("time1:%d\r\n",tv.tv_sec);
    ret=rt_sem_take(&rx_semRxTimeOut, 1000);//1秒超时
//    gettimeofday(&tv, &tz);
//    rt_kprintf("time2:%d\r\n",tv.tv_sec);
    if( ret == RT_EOK)
    {
        rt_memcpy(buf,bufTemp,bufTempNum);
        size=bufTempNum;
        bufTempNum=0;
        return size;
    }
    else if(ret == -RT_ETIMEOUT)
    {
      bufTempNum=0;
      return 0;
    }
    bufTempNum=0;
    return -1;
}

return RT_EOK;
}

static void serial_thread_entry(void *parameter)
{
    int len=0;
    while (1)
    {
        rt_sem_take(&rx_semRx, RT_WAITING_FOREVER);
        if( (bufTemp[0] == 0x01) && (bufTempNum==5) )//这里需要根据实际修改，判断是否接收到了一包数据
        {
            rt_sem_release(&rx_semRxTimeOut);//数据接收成功
        }
    }
}

static void serial_threadRx_entry(void *parameter)
{
    char ch[LRNGTH]={0};
    int len=0;

while (1)
    {
        /* 从串口读取一个字节的数据，没有读取到则等待接收信号量 */
        rt_memset(ch,0,sizeof(ch));
        while ( ( len = rt_device_read(serial, -1, ch, sizeof(ch)) )== 0)
        {
            /* 阻塞等待接收信号量，等到信号量后再次读取数据 */
            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
        }
        //rt_kprintf("len=%d,ch=%s\r\n",len,ch);
        rt_memcpy(&bufTemp[bufTempNum],ch,len);
        bufTempNum += len;
        rt_sem_release(&rx_semRx);
    }
}

static int Bsp_init(void)
{
    rt_err_t ret = RT_EOK;
    //char str[] = "hello RT-Thread!\r\n";
    /* 查找系统中的串口设备 */
    serial = rt_device_find(SAMPLE_UART_NAME);
    if (!serial)
    {
        rt_kprintf("find %s failed!\n", SAMPLE_UART_NAME);
        return RT_ERROR;
    }
    //这里进行串口配置
    /* 初始化信号量 */
    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
    rt_sem_init(&rx_semRx, "rx_semRx", 0, RT_IPC_FLAG_FIFO);
    rt_sem_init(&rx_semRxTimeOut, "rx_semRxTimeOut", 0, RT_IPC_FLAG_FIFO);
    /* 以中断接收及轮询发送模式打开串口设备 */
    rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
    /* 设置接收回调函数 */
    rt_device_set_rx_indicate(serial, uart_input);
    /* 发送字符串 */
    //rt_device_write(serial, 0, str, (sizeof(str) - 1));

/* 创建 serial 线程 */
    rt_thread_t thread = rt_thread_create("serial", serial_thread_entry, RT_NULL, 1024, 25, 10);
    /* 创建成功则启动线程 */
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }
    else
    {
        ret = RT_ERROR;
    }
    /* 创建 serial 线程 */
    thread = rt_thread_create("serialRx", serial_threadRx_entry, RT_NULL, 1024, 25, 10);
    /* 创建成功则启动线程 */
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }
    else
    {
        ret = RT_ERROR;
    }

return ret;
    return 0;
}
```