【STM32L4】FreeRTOS消息队列三串口接收发送

环境

• STM32L476G-DISCO 开发板
• STM32CubeIDE 1.1.0
• STM32CubeMX 5.4.0

STM32CubeIDE配置

移植FreeRTOS，选择CMSIS_V2。

FreeRTOS的所有配置的选择默认，后面手动修改FreeRTOSConfig.h文件修改配置。如果想直接在IDE中修改配置也可以直接修改。

开启三个串口，异步模式。

由于接收采用空闲中断接收，所以要打开DMA接收和串口总中断。

重要文件

• FreeRTOSConfigure.h FreeRTOS的配置文件。修改一些关于FreeRTOS的配置信息。
• freertos.c FreeRTOS任务主文件，可以在void MX_FREERTOS_Init(void)函数中定义任务。

默认STM32CubeIDE在生成代码的时候是会在MA_FREERTOS_Init函数创建一个默认任务。该任务的功能仅仅做一个延时。

代码

FreeRTOSConfigure.h

#define configTOTAL_HEAP_SIZE       ((size_t)1024 * 24)
//修改Total Heap Size，该参数决定内存池的总大小，当FreeRTOS任务启动后总是进入HardFault_Handler中断程序时，可以考虑Debug看一下任务句柄地址的分配，很可能是因为内存池资源用完，没有空间分配导致的硬件异常中断。

main.h

/* USER CODE BEGIN Private defines */
#define UARTRXBUFFERSIZE 512     //串口接收的缓存区大小
#define UARTQUEUENUM  3          //消息队列的数量
#define UARTQUEUESIZE (uint32_t)UARTRXBUFFERSIZE * UARTQUEUENUM

typedef struct {
	uint8_t uartRxTemp[UARTRXBUFFERSIZE];
	uint8_t uartRxName[7];
} UARTMessageQueue_TypeDef;
/* USER CODE END Private defines */
//自己定义了一些宏和结构体

stm32l4xx_it.c

/* USER CODE BEGIN EV */
//在main.c文件中定义的串口接收缓存区，大小为UARTRXBUFFERSIZE
extern uint8_t uart1RxBuffer[UARTRXBUFFERSIZE];
extern uint8_t uart2RxBuffer[UARTRXBUFFERSIZE];
extern uint8_t uart4RxBuffer[UARTRXBUFFERSIZE];

//在freertos.c文件中定义的消息队列句柄
extern osMessageQueueId_t osQueueUart1;
extern osMessageQueueId_t osQueueUart2;
extern osMessageQueueId_t osQueueUart4;
/* USER CODE END EV */

/**
 * @brief This function handles USART1 global interrupt.
 */
void USART1_IRQHandler(void) {
	/* USER CODE BEGIN USART1_IRQn 0 */
	uint8_t temp;
	UARTMessageQueue_TypeDef msg;
	uint8_t str[7] = "USART1";
	if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE) != RESET) {
		//空闲中断
		//temp = huart4.Instance->ISR;
		__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		temp = huart1.Instance->RDR;
		temp = temp;
		HAL_UART_DMAStop(&huart1);
        //进入串口空闲中断之后，确定串口数据缓存区有数据，将串口数据存入结构体的数据存储数组，结构体的uartRxName成员存放消息来源的串口名称。
        //osMessageQueuePut将结构体推入osQueueUart1消息队列中。
        //其实可以将三个串口放入一个消息队列，用结构体中uartRxName成员区分来源。这里为了简单明了，没有做更多的优化。有兴趣可以自行修改。
		if (strlen(uart1RxBuffer) != 0) {
			memset(msg.uartRxTemp, 0x00, sizeof(msg.uartRxTemp));
			memcpy(msg.uartRxTemp, uart1RxBuffer, strlen(uart1RxBuffer));
			memcpy(msg.uartRxName, str, strlen(str));
			memset(uart1RxBuffer, 0x00, strlen(uart1RxBuffer));
			osMessageQueuePut(osQueueUart1, &msg, 0, 0);
		}

		__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
		HAL_UART_Receive_DMA(&huart1, uart1RxBuffer, UARTRXBUFFERSIZE);
	}
	/* USER CODE END USART1_IRQn 0 */
	HAL_UART_IRQHandler(&huart1);
	/* USER CODE BEGIN USART1_IRQn 1 */

	/* USER CODE END USART1_IRQn 1 */
}

/**
 * @brief This function handles USART2 global interrupt.
 */
void USART2_IRQHandler(void) {
	/* USER CODE BEGIN USART2_IRQn 0 */
	uint8_t temp;
	UARTMessageQueue_TypeDef msg;
	uint8_t str[7] = "USART2";
	if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE) != RESET) {
		//空闲中断
		//temp = huart4.Instance->ISR;
		__HAL_UART_CLEAR_IDLEFLAG(&huart2);
		temp = huart2.Instance->RDR;
		temp = temp;
		HAL_UART_DMAStop(&huart2);

		if (strlen(uart2RxBuffer) != 0) {
			memset(msg.uartRxTemp, 0x00, sizeof(msg.uartRxTemp));
			memcpy(msg.uartRxTemp, uart2RxBuffer, strlen(uart2RxBuffer));
			memcpy(msg.uartRxName, str, strlen(str));
			memset(uart2RxBuffer, 0x00, strlen(uart2RxBuffer));
			osMessageQueuePut(osQueueUart2, &msg, 0, 0);
		}

		__HAL_UART_CLEAR_IDLEFLAG(&huart2);
		__HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
		HAL_UART_Receive_DMA(&huart2, uart2RxBuffer, UARTRXBUFFERSIZE);
	}
	/* USER CODE END USART2_IRQn 0 */
	HAL_UART_IRQHandler(&huart2);
	/* USER CODE BEGIN USART2_IRQn 1 */

	/* USER CODE END USART2_IRQn 1 */
}

/**
 * @brief This function handles UART4 global interrupt.
 */
void UART4_IRQHandler(void) {
	/* USER CODE BEGIN UART4_IRQn 0 */
	uint8_t temp;
	UARTMessageQueue_TypeDef msg;
	uint8_t str[7] = "UART4";
	if (__HAL_UART_GET_FLAG(&huart4, UART_FLAG_IDLE) != RESET) {
		//空闲中断
		//temp = huart4.Instance->ISR;
		__HAL_UART_CLEAR_IDLEFLAG(&huart4);
		temp = huart4.Instance->RDR;
		temp = temp;
		HAL_UART_DMAStop(&huart4);

		if (strlen(uart4RxBuffer) != 0) {
			memset(msg.uartRxTemp, 0x00, sizeof(msg.uartRxTemp));
			memcpy(msg.uartRxTemp, uart4RxBuffer, strlen(uart4RxBuffer));
			memcpy(msg.uartRxName, str, strlen(str));
			memset(uart4RxBuffer, 0x00, strlen(uart4RxBuffer));
			osMessageQueuePut(osQueueUart4, &msg, 0, 0);
		}

		__HAL_UART_CLEAR_IDLEFLAG(&huart4);
		__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
		HAL_UART_Receive_DMA(&huart4, uart4RxBuffer, UARTRXBUFFERSIZE);
	}
	/* USER CODE END UART4_IRQn 0 */
	HAL_UART_IRQHandler(&huart4);
	/* USER CODE BEGIN UART4_IRQn 1 */

	/* USER CODE END UART4_IRQn 1 */
}

main.c

/* USER CODE BEGIN PV */
uint8_t uart1RxBuffer[UARTRXBUFFERSIZE] = { 0 };
uint8_t uart2RxBuffer[UARTRXBUFFERSIZE] = { 0 };
uint8_t uart4RxBuffer[UARTRXBUFFERSIZE] = { 0 };

/* USER CODE END PV */
//定义串口数据的缓存区，DMA将串口接收的数据搬运到这个缓存区中。

/* USER CODE BEGIN 4 */
/* 开启IDLE空闲中断、错误中断和DMA接收。
 *
 */
void uartEnableIDLE(void) {
	__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
	__HAL_UART_ENABLE_IT(&huart1, UART_IT_ERR);
	HAL_UART_Receive_DMA(&huart1, uart1RxBuffer, UARTRXBUFFERSIZE);
	__HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
	__HAL_UART_ENABLE_IT(&huart2, UART_IT_ERR);
	HAL_UART_Receive_DMA(&huart2, uart2RxBuffer, UARTRXBUFFERSIZE);
	__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
	__HAL_UART_ENABLE_IT(&huart4, UART_IT_ERR);
	HAL_UART_Receive_DMA(&huart4, uart4RxBuffer, UARTRXBUFFERSIZE);
}

/**
 * @brief  UART error callback.
 * @param  huart UART handle.
 * @retval None
 */
 //错误接收中断回调函数，用于处理ORE溢出中断。其他错误中断也可以在这个函数中处理。
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
	/* Prevent unused argument(s) compilation warning */
	UNUSED(huart);
	uint8_t temp;
	/* NOTE : This function should not be modified, when the callback is needed,
	 the HAL_UART_ErrorCallback can be implemented in the user file.
	 */
	if (huart->Instance == USART1) {
		if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_ORE) != RESET) {
			temp = huart1.Instance->RDR;
			temp = temp;
			__HAL_UART_CLEAR_OREFLAG(&huart1);
			HAL_UART_Receive_DMA(&huart1, uart1RxBuffer, UARTRXBUFFERSIZE);
		}
	} else if (huart->Instance == USART2) {
		if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_ORE) != RESET) {
			temp = huart2.Instance->RDR;
			temp = temp;
			__HAL_UART_CLEAR_OREFLAG(&huart2);
			HAL_UART_Receive_DMA(&huart2, uart2RxBuffer, UARTRXBUFFERSIZE);
		}
	} else if (huart->Instance == UART4) {
		if (__HAL_UART_GET_FLAG(&huart4, UART_FLAG_ORE) != RESET) {
			temp = huart4.Instance->RDR;
			temp = temp;
			__HAL_UART_CLEAR_OREFLAG(&huart4);
			HAL_UART_Receive_DMA(&huart4, uart4RxBuffer, UARTRXBUFFERSIZE);
		}
	}
}
/* USER CODE END 4 */

freertos.c

/* USER CODE BEGIN Variables */
osMessageQueueId_t osQueueUart1;
osMessageQueueId_t osQueueUart2;
osMessageQueueId_t osQueueUart4;

osThreadId_t uart1TaskHandle;
osThreadId_t uart2TaskHandle;
osThreadId_t uart4TaskHandle;
/* USER CODE END Variables */
//定义三个消息队列句柄，三个任务句柄

/* USER CODE BEGIN FunctionPrototypes */
void uart1RxTask(void *argument);
void uart2RxTask(void *argument);
void uart4RxTask(void *argument);
/* USER CODE END FunctionPrototypes */
//声明任务函数

/**
 * @brief  FreeRTOS initialization
 * @param  None
 * @retval None
 */
void MX_FREERTOS_Init(void) {
	/* USER CODE BEGIN Init */

	/* USER CODE END Init */
	osKernelInitialize();

	/* USER CODE BEGIN RTOS_MUTEX */
	/* add mutexes, ... */
	/* USER CODE END RTOS_MUTEX */

	/* USER CODE BEGIN RTOS_SEMAPHORES */
	/* add semaphores, ... */
	/* USER CODE END RTOS_SEMAPHORES */

	/* USER CODE BEGIN RTOS_TIMERS */
	/* start timers, add new ones, ... */
	/* USER CODE END RTOS_TIMERS */

	/* USER CODE BEGIN RTOS_QUEUES */
	/* add queues, ... */
    //新建队列
    //osMessageQueueNew参数分别为队列中消息数量，消息的大小，队列的参数配置 
	osQueueUart1 = osMessageQueueNew(UARTQUEUENUM, sizeof(UARTMessageQueue_TypeDef), NULL);
	osQueueUart2 = osMessageQueueNew(UARTQUEUENUM, sizeof(UARTMessageQueue_TypeDef), NULL);
	osQueueUart4 = osMessageQueueNew(UARTQUEUENUM, sizeof(UARTMessageQueue_TypeDef), NULL);
	/* USER CODE END RTOS_QUEUES */

	/* Create the thread(s) */
	/* definition and creation of defaultTask */
	//const osThreadAttr_t defaultTask_attributes = { .name = "defaultTask",
	//		.priority = (osPriority_t) osPriorityNormal, .stack_size = 128 };
	//defaultTaskHandle = osThreadNew(StartDefaultTask, NULL,
	//		&defaultTask_attributes);

    //osThreadAttr_t 任务线程的结构体
    //.name 任务的名字
    //.priority 任务的优先级
    //.stack_size 任务堆栈的大小

	const osThreadAttr_t uart1RxTask_attributes = { .name = "uart1RxTask",
			.priority = (osPriority_t) osPriorityNormal, .stack_size = 1024 };
    //osThreadNew 创建任务函数，参数分别为任务处理函数，需要传入任务的参数，任务的参数属性
	uart1TaskHandle = osThreadNew(uart1RxTask, NULL, &uart1RxTask_attributes);
	const osThreadAttr_t uart2RxTask_attributes = { .name = "uart2RxTask",
			.priority = (osPriority_t) osPriorityNormal, .stack_size = 1024 };
	uart2TaskHandle = osThreadNew(uart2RxTask, NULL, &uart2RxTask_attributes);
	const osThreadAttr_t uart4RxTask_attributes = { .name = "uart4RxTask",
			.priority = (osPriority_t) osPriorityNormal, .stack_size = 1024 };
	uart4TaskHandle = osThreadNew(uart4RxTask, NULL, &uart4RxTask_attributes);
	/* USER CODE BEGIN RTOS_THREADS */
	/* add threads, ... */
	/* USER CODE END RTOS_THREADS */

}

/* USER CODE BEGIN Application */
void uart1RxTask(void *argument) {
	UARTMessageQueue_TypeDef msg;
	osStatus_t status;
	while (1) {
        //不断的请求消息队列
		status = osMessageQueueGet(osQueueUart1, &msg, NULL, 0);
        //请求到消息队列，将消息中的数据转发出去。
		if (status == osOK) {
			HAL_UART_Transmit(&huart1, msg.uartRxTemp, strlen(msg.uartRxTemp),
					1000);
			memset(msg.uartRxTemp, 0x00, strlen(msg.uartRxTemp));
		}
		osThreadYield();
	}
}

void uart2RxTask(void *argument) {
	UARTMessageQueue_TypeDef msg;
	osStatus_t status;
	while (1) {
		status = osMessageQueueGet(osQueueUart2, &msg, NULL, 0);

		if (status == osOK) {
			HAL_UART_Transmit(&huart2, msg.uartRxTemp, strlen(msg.uartRxTemp),
					1000);
			memset(msg.uartRxTemp, 0x00, strlen(msg.uartRxTemp));
		}
		osThreadYield();
	}
}

void uart4RxTask(void *argument) {
	UARTMessageQueue_TypeDef msg;
	osStatus_t status;
	while (1) {
		status = osMessageQueueGet(osQueueUart4, &msg, NULL, 0);

		if (status == osOK) {
			HAL_UART_Transmit(&huart4, msg.uartRxTemp, strlen(msg.uartRxTemp),
					1000);
			memset(msg.uartRxTemp, 0x00, strlen(msg.uartRxTemp));
		}
		osThreadYield();
	}
}
/* USER CODE END Application */

工程代码

如果愿意支持一下可以选择在CSDN下载，下载地址:
//download.csdn.net/download/JoelYang1997/12013095
同时如果没有下载币提供GIthub地址:
https://github.com/joelyang97/32L4_FreeRTOSandUART