STM32Cubemx在FreeRTOS中使用面向对象的方式使用串口

文章目录

• 前言
• 一、创建FreeRTOS工程
• 二、创建文件对串口进行封装
• 三、代码编写
• 总结

前言

本篇文章将带大家来学习使用面向对象的方式在FreeRTOS中使用串口，使用面向对象的方法非常适合编写可移植性强的代码，那么这篇文章就带大家来看一下这个代码要怎么写。

一、创建FreeRTOS工程

开启串行调试：

将systick进行替换，因为使用RTOS后会占用systick作为RTOS的心跳。

开启时钟

配置串口并且开启中断

配置时钟树：

打开FreeRTOS

添加一个队列，用于保存串口数据。

创建信号量：

生成工程

二、创建文件对串口进行封装

创建uart_driver.c和uart_driver.h文件来管理串口。

创建一个bsp文件夹用来存放串口的驱动文件：

在bsp目录下存放串口的驱动文件：

将驱动文件添加进入keil工程中:

将文件路径添加进入工程这样编译器才能正确找到这个工程：

三、代码编写

uart_driver.c

#include "uart_driver.h"

// 接收数据变量，用于接收中断处理
uint8_t rxData = 0;

// 外部 UART 句柄声明，通常在 main.c 中定义
extern UART_HandleTypeDef huart1;

// UART 设备数量
#define UART_NUM 3

// UART 设备列表
struct UART_Device_t *list[UART_NUM];

// 接收队列的大小
#define UART_SIZE 1000

// 当前操作的 UART 设备
PUART_Device current;

// UART1 设备初始化函数
void UART1_Device_Init(struct UART_Device_t *device) 
{
    // 将 UART 设备添加到设备列表中
    list[0] = device;

    // 初始化发送和接收信号量
    device->txSemaphore = osSemaphoreNew(1, 0, NULL);
    device->rxSemaphore = osSemaphoreNew(1, 0, NULL);

    // 初始化接收消息队列
    device->rxQueue = osMessageQueueNew(UART_SIZE, sizeof(uint8_t), NULL);

    // 配置接收中断
    HAL_UART_Receive_IT(device->huart, &rxData, 1);
}

// UART1 设备发送数据函数
HAL_StatusTypeDef UART1_Device_Send(struct UART_Device_t *device, uint8_t *data, uint16_t size, uint32_t timeout) 
{
    // 启动 UART 发送中断
    HAL_UART_Transmit_IT(device->huart, data, size);

    // 等待发送信号量释放，确保发送完成
    if (osSemaphoreAcquire(device->txSemaphore, timeout) == osOK) 
    {
        return HAL_OK;
    } 
    else 
    {
        return HAL_TIMEOUT;
    } 
}

// UART1 设备接收数据函数
HAL_StatusTypeDef UART1_Device_Receive(struct UART_Device_t *device, uint8_t *data, uint16_t size, uint32_t timeout) 
{
    uint16_t received = 0;
    uint32_t startTick = HAL_GetTick();
    
    while (received < size) 
    {
        // 从接收队列中获取数据
        if (osMessageQueueGet(device->rxQueue, &data[received], NULL, timeout) == osOK) 
        {
            received++;
        }
        else
        {
            return HAL_TIMEOUT;
        }
    }
    return HAL_OK;
}

// UART 接收中断回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) 
{
    if (huart->Instance == USART1)
    {
        // 从列表中获取对应的 UART 设备
        struct UART_Device_t *device = list[0];
        // 将接收到的数据放入消息队列
        osMessageQueuePut(device->rxQueue, &rxData, 0, 0);
        // 重新启动接收中断
        HAL_UART_Receive_IT(device->huart, &rxData, 1);
    }   
}

// UART 发送完成中断回调函数
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) 
{
    if (huart->Instance == USART1)
    {
        // 从列表中获取对应的 UART 设备
        struct UART_Device_t *device = list[0];
        // 释放发送信号量，表示发送完成
        osSemaphoreRelease(device->txSemaphore);
    }
}

// UART 设备数组，定义和初始化 UART 设备
static UART_Device uart_device[UART_NUM] = {
    {.uartname = "uart1", .huart = &huart1, .init = UART1_Device_Init, .send = UART1_Device_Send, .receive = UART1_Device_Receive},
};

// 获取 UART 设备函数
PUART_Device GetUartDevice(int num)
{
    return &uart_device[num];
}

uart_driver.h

#ifndef __UART_DRIVER_H__
#define __UART_DRIVER_H__

#include "main.h"
#include "cmsis_os.h"

// 定义 UART 设备结构体
typedef struct UART_Device_t 
{
    char* uartname; // UART 设备名称
    UART_HandleTypeDef* huart; // HAL UART 句柄
    osSemaphoreId_t txSemaphore; // 发送信号量
    osSemaphoreId_t rxSemaphore; // 接收信号量
    osMessageQueueId_t rxQueue;  // 接收消息队列
    
    // 初始化函数指针
    void (*init)(struct UART_Device_t *device);
    // 发送函数指针
    HAL_StatusTypeDef (*send)(struct UART_Device_t *device, uint8_t *data, uint16_t size, uint32_t timeout);
    // 接收函数指针
    HAL_StatusTypeDef (*receive)(struct UART_Device_t *device, uint8_t *data, uint16_t size, uint32_t timeout);
} UART_Device, *PUART_Device;

// 函数原型声明
HAL_StatusTypeDef UART_Device_Send(struct UART_Device_t *device, uint8_t *data, uint16_t size, uint32_t timeout);
HAL_StatusTypeDef UART_Device_Receive(struct UART_Device_t *device, uint8_t *data, uint16_t size, uint32_t timeout);
PUART_Device GetUartDevice(int num);

#endif

使用步骤;

void StartDefaultTask(void *argument)
{
  /* USER CODE BEGIN StartDefaultTask */
  /* Infinite loop */
	
	
	PUART_Device uart1_device = GetUartDevice(0);
	uart1_device->init(uart1_device);
	uart1_device->send(uart1_device, "Hello", sizeof("Hello"), 1000);
	
	
  for(;;)
  {
		HAL_StatusTypeDef status = uart1_device->receive(uart1_device, rxBuffer, 1, 1000);
		if (status == HAL_OK)
		{
				// 处理接收到的数据
				uart1_device->send(uart1_device, "Hello", sizeof("Hello"), 1000);
		}		
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}

代码编写思路：

这段代码设计了一个 UART 驱动程序，主要实现了 UART 数据的异步发送和接收。以下是其实现思路：

1. 初始化:

   • 在 UART1_Device_Init 函数中，首先将 UART 设备添加到一个全局设备列表中。
   • 使用 osSemaphoreNew 创建发送和接收信号量，这些信号量用于同步发送和接收操作的完成状态。
   • 使用 osMessageQueueNew 创建接收消息队列，用于存储接收到的数据。
   • 启动接收中断，允许 UART 在接收到数据时触发中断。

2. 发送数据:

   • UART1_Device_Send 函数启动 UART 的发送中断，异步地发送数据。
   • 发送函数会等待发送信号量的释放，确保数据已经完全发送出去。如果在指定时间内未释放信号量，则返回超时错误。

3. 接收数据:

   • UART1_Device_Receive 函数从接收消息队列中获取数据，直到接收到指定数量的数据或超时。
   • 这个函数通过消息队列来接收数据，确保接收到的数据在队列中等待处理。

4. 中断回调:

   • HAL_UART_RxCpltCallback 函数在 UART 接收中断时被调用。它将接收到的数据放入接收消息队列，并重新启动接收中断，确保持续接收数据。
   • HAL_UART_TxCpltCallback 函数在 UART 发送中断时被调用。它释放发送信号量，通知发送操作已完成。

整体思路是利用中断和 FreeRTOS 的信号量及消息队列机制，实现 UART 数据的异步发送和接收，以提高数据传输的效率和可靠性。

总结

本篇文章主要讲解了在FreeRTOS中使用面向对象的方式使用串口，掌握这种编程方式对于工程管理是非常有必要的。

工程代码公众号回复：FreeRTOS串口