stm32之hal库串口中断和ringbuffer的结合

2024-05-04 11:36
文章标签 中断 stm32 结合 串口 hal ringbuffer

本文主要是介绍stm32之hal库串口中断和ringbuffer的结合，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

  1. 结合hal库封装的中断处理函数
  2. 使用rt-thread内部的rt-ringbuffer数据结构源码
  3. 改造hal库串口部分的源码，将内部静态方法变为弱引用的函数，方便重写
  4. 标志位采用信号量或变量的两种方式，内部数据分配方式采用动态和静态两种方式

hal库部分串口调整(两个函数由外部重新修改)

vv

串口代码

头文件

/** Copyright (c) 2024-2024,shchl** SPDX-License-Identifier: Apache-2.0** Change Logs:* Date           Author       Notes* 2024-5-2     shchl   first version*/#ifndef TX_STM32_F4_DRV_UART_OS_H
#define TX_STM32_F4_DRV_UART_OS_H#include "drv_common.h"
/*串口配置控制器个数,限制串口个数*/
// 使用os标志，来进行通讯，0表示使用内部提供的标志位
#define UART_USE_OS_FLAG (0)// 静态分配方式; (0)表示动态分配方式
#define UART_BUF_STATIC_METHOD (1)
// 串口控制器个数
#ifndef UART_CONTROLLER_NUM
#define UART_CONTROLLER_NUM 1
#endif
#define BAUD_RATE_2400                  2400
#define BAUD_RATE_4800                  4800
#define BAUD_RATE_9600                  9600
#define BAUD_RATE_19200                 19200
#define BAUD_RATE_38400                 38400
#define BAUD_RATE_57600                 57600
#define BAUD_RATE_115200                115200
#define BAUD_RATE_230400                230400
#define BAUD_RATE_460800                460800
#define BAUD_RATE_500000                500000
#define BAUD_RATE_921600                921600
#define BAUD_RATE_2000000               2000000
#define BAUD_RATE_2500000               2500000
#define BAUD_RATE_3000000               3000000#define DATA_BITS_5                     5
#define DATA_BITS_6                     6
#define DATA_BITS_7                     7
#define DATA_BITS_8                     8
#define DATA_BITS_9                     9#define STOP_BITS_1                     0
#define STOP_BITS_2                     1
#define STOP_BITS_3                     2
#define STOP_BITS_4                     3#define PARITY_NONE                     0
#define PARITY_ODD                      1
#define PARITY_EVEN                     2#define SERIAL_FLOWCONTROL_CTSRTS     1
#define SERIAL_FLOWCONTROL_NONE       0#define UART_FLAG_IT_TX    (1<<1)
#define UART_FLAG_IT_RX    (1<<2)
#define UART_FLAG_IT_TX_RX     (UART_FLAG_IT_TX|UART_FLAG_IT_RX)
#define UART_FLAG_DMA_TX    (1<<3)
#define UART_FLAG_DMA_RX    (1<<4)
#define UART_FLAG_DMA_TX_RX     (UART_FLAG_DMA_TX|UART_FLAG_DMA_RX)
/*** @brief 串口配置*/
struct uart_configuration {uint32_t baud_rate;uint32_t data_bits: 4;uint32_t stop_bits: 2;uint32_t parity: 2;uint32_t flowcontrol: 1;uint32_t reserved: 23;
};
typedef struct stm32_uart_controller *uart_controller_t;typedef void (*uart_rx_notify)(uart_controller_t controller, uint32_t size);typedef void (*uart_tx_cpt_notify)(uart_controller_t controller);/*** @brief 串口控制器结构体*/
struct stm32_uart_controller {/*串口句柄*/UART_HandleTypeDef handle;
#if UART_USE_OS_FLAGTX_SEMAPHORE *tx_sem;TX_SEMAPHORE *rx_sem;
#elsevolatile uint32_t tx_sem_flag;volatile uint32_t rx_sem_flag;
#endif/* 通知回调函数 */uart_rx_notify rx_indicate;uart_tx_cpt_notify tx_complete;/* 缓冲区指针 */struct rt_ringbuffer *tx_buffer;struct rt_ringbuffer *rx_buffer;};void bsp_UartParDefaultSet(USART_TypeDef *uart);void bsp_UartParSet(USART_TypeDef *uart, struct uart_configuration *configuration);void bsp_UartParNotifySet(USART_TypeDef *uart, uart_rx_notify rx_notify, uart_tx_cpt_notify tx_cpt_notify);void bsp_UartParSemSet(USART_TypeDef *uart, uint8_t rx_sem_flag, uint8_t tx_sem_flag);void bsp_InitUart(USART_TypeDef *uart, uint16_t tx_size, uint16_t rx_size);void bsp_DeInitUart(USART_TypeDef *uart);uint16_t uart_read_data(USART_TypeDef *uart, uint8_t *data, uint16_t len);uint16_t uart_write_data(USART_TypeDef *uart, uint8_t *data, uint16_t len);#endif //TX_STM32_F4_DRV_UART_OS_H

源文件

/** Copyright (c) 2024-2024,shchl** SPDX-License-Identifier: Apache-2.0** Change Logs:* Date           Author       Notes* 2024-5-2     shchl   first version*/
#include "drv_common.h"
#include "drv_uart_os.h"#define SEM_NOTIFY_FLAG (1)
#define SET_UN_NOTIFY_FLAG (0)// 串口索引检查
#define uart_idx_check(uart) do{idx = stm32_uart_controller_idx_get(uart);if (idx < 0 || idx >= UART_CONTROLLER_NUM) return;}while(0)enum {UART1_IDX,UART2_IDX,UART3_IDX,UART4_IDX,UART5_IDX,UART6_IDX,
};
#if(UART_BUF_STATIC_METHOD)#if(UART_CONTROLLER_NUM >= 1)#define COM1_TX_LEN 2048
#define COM1_RX_LEN 2048static uint8_t buf_0_tx[COM1_TX_LEN], buf_0_rx[COM1_RX_LEN];
static struct rt_ringbuffer ringbuffer_tx_0 = {.buffer_size=COM1_TX_LEN};
static struct rt_ringbuffer ringbuffer_rx_0 = {.buffer_size=COM1_RX_LEN};
#endif
#if(UART_CONTROLLER_NUM >= 2)
#define COM2_TX_LEN 1024
#define COM2_RX_LEN 1024
static uint8_t buf_1_tx[COM2_TX_LEN], buf_1_rx[COM2_RX_LEN];
static struct rt_ringbuffer ringbuffer_tx_1={.buffer_size=COM2_TX_LEN};
static struct rt_ringbuffer ringbuffer_rx_1={.buffer_size=COM2_RX_LEN};
#endif
#if(UART_CONTROLLER_NUM >= 3)
#define COM3_TX_LEN 1024
#define COM3_RX_LEN 1024
static uint8_t buf_2_tx[COM3_TX_LEN], buf_2_rx[COM3_RX_LEN];
static struct rt_ringbuffer ringbuffer_tx_2={.buffer_size=COM3_TX_LEN};
static struct rt_ringbuffer ringbuffer_rx_2={.buffer_size=COM3_RX_LEN};
#endif
#if(UART_CONTROLLER_NUM >= 4)#define COM4_TX_LEN 1024
#define COM4_RX_LEN 1024
static uint8_t buf_3_tx[COM4_TX_LEN], buf_3_rx[COM4_RX_LEN];
static struct rt_ringbuffer ringbuffer_tx_3={.buffer_size=COM4_TX_LEN};
static struct rt_ringbuffer ringbuffer_rx_3={.buffer_size=COM4_RX_LEN};
#endifstatic uint8_t *uart_static_buf[][4] = {
#define buf_item(tx, rx, tx_buf, rx_buf) (uint8_t *) &(tx),(uint8_t *)&(rx), tx_buf,rx_buf
#if(UART_CONTROLLER_NUM >= 1){buf_item(ringbuffer_tx_0, ringbuffer_rx_0, buf_0_tx, buf_0_rx)},
#endif
#if(UART_CONTROLLER_NUM >= 2){buf_item(ringbuffer_tx_1, ringbuffer_rx_1, buf_1_tx, buf_1_rx)},
#endif
#if(UART_CONTROLLER_NUM >= 3){buf_item(ringbuffer_tx_2, ringbuffer_rx_2, buf_2_tx, buf_2_rx)},
#endif
#if(UART_CONTROLLER_NUM >= 4){buf_item(ringbuffer_tx_3, ringbuffer_rx_2, buf_3_tx, buf_3_rx)},
#endif
};
#endifstatic struct stm32_uart_controller controllers[UART_CONTROLLER_NUM] = {0};/*** @brief 下标获取,每个串口对应唯一值(从0开始,默认是连续的)* @param uart* @return*/
static inline int stm32_uart_controller_idx_get(USART_TypeDef *uart) {
#define idx_return(val) {return val;}switch ((uint32_t) uart) {case (uint32_t) USART1: idx_return(UART1_IDX)case (uint32_t) USART2: idx_return(UART2_IDX)case (uint32_t) USART3: idx_return(UART3_IDX)case (uint32_t) UART4: idx_return(UART4_IDX)case (uint32_t) UART5: idx_return(UART5_IDX)case (uint32_t) USART6: idx_return(UART6_IDX)}
#undef idx_returnreturn -1;
}static inline void stm32_uart_irq_enable_cnf(USART_TypeDef *uart) {#define uart_irq_cnf(irq, pp, sp)  {HAL_NVIC_SetPriority(irq, pp, sp);HAL_NVIC_EnableIRQ(irq);}switch ((uint32_t) uart) {case (uint32_t) USART1: uart_irq_cnf(USART1_IRQn, 0, 0)case (uint32_t) USART2: uart_irq_cnf(USART2_IRQn, 0, 0)case (uint32_t) USART3: uart_irq_cnf(USART3_IRQn, 0, 0)case (uint32_t) UART4: uart_irq_cnf(UART4_IRQn, 0, 0)case (uint32_t) UART5: uart_irq_cnf(UART5_IRQn, 0, 0)case (uint32_t) USART6: uart_irq_cnf(USART6_IRQn, 0, 0)}
#undef uart_irq_cnf}static inline void stm32_uart_irq_disable_cnf(USART_TypeDef *uart) {
#define uart_irq_disable_cnf(irq)  {HAL_NVIC_DisableIRQ(irq);}switch ((uint32_t) uart) {case (uint32_t) USART1: uart_irq_disable_cnf(USART1_IRQn)case (uint32_t) USART2: uart_irq_disable_cnf(USART2_IRQn)case (uint32_t) USART3: uart_irq_disable_cnf(USART3_IRQn)case (uint32_t) UART4: uart_irq_disable_cnf(UART4_IRQn)case (uint32_t) UART5: uart_irq_disable_cnf(UART5_IRQn)case (uint32_t) USART6: uart_irq_disable_cnf(USART6_IRQn)}
#undef uart_irq_disable_cnf}/*** @brief 串口默认设置* @param uart*/
void bsp_UartParDefaultSet(USART_TypeDef *uart) {struct uart_configuration default_cnf = {.baud_rate=BAUD_RATE_115200,.parity=PARITY_NONE,.data_bits=DATA_BITS_8,.flowcontrol=SERIAL_FLOWCONTROL_NONE,.stop_bits = STOP_BITS_1};bsp_UartParSet(uart, &default_cnf);bsp_UartParSemSet(uart, 1, 1);
}/*** @brief 串口参数设置* @param uart * @param configuration */
void bsp_UartParSet(USART_TypeDef *uart, struct uart_configuration *cfg) {int idx;uart_idx_check(uart);if (cfg == NULL) return;controllers[idx].handle.Instance = uart;controllers[idx].handle.Init.BaudRate = cfg->baud_rate;controllers[idx].handle.Init.Mode = UART_MODE_TX_RX;controllers[idx].handle.Init.OverSampling = UART_OVERSAMPLING_16;// 参数配置{switch (cfg->flowcontrol) {case SERIAL_FLOWCONTROL_NONE:controllers[idx].handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;break;case SERIAL_FLOWCONTROL_CTSRTS:controllers[idx].handle.Init.HwFlowCtl = UART_HWCONTROL_RTS_CTS;break;default:controllers[idx].handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;break;}switch (cfg->data_bits) {case DATA_BITS_8:if (cfg->parity == PARITY_ODD || cfg->parity == PARITY_EVEN)controllers[idx].handle.Init.WordLength = UART_WORDLENGTH_9B;elsecontrollers[idx].handle.Init.WordLength = UART_WORDLENGTH_8B;break;case DATA_BITS_9:controllers[idx].handle.Init.WordLength = UART_WORDLENGTH_9B;break;default:controllers[idx].handle.Init.WordLength = UART_WORDLENGTH_8B;break;}switch (cfg->stop_bits) {case STOP_BITS_1:controllers[idx].handle.Init.StopBits = UART_STOPBITS_1;break;case STOP_BITS_2:controllers[idx].handle.Init.StopBits = UART_STOPBITS_2;break;default:controllers[idx].handle.Init.StopBits = UART_STOPBITS_1;break;}switch (cfg->parity) {case PARITY_NONE:controllers[idx].handle.Init.Parity = UART_PARITY_NONE;break;case PARITY_ODD:controllers[idx].handle.Init.Parity = UART_PARITY_ODD;break;case PARITY_EVEN:controllers[idx].handle.Init.Parity = UART_PARITY_EVEN;break;default:controllers[idx].handle.Init.Parity = UART_PARITY_NONE;break;}}
}/*** @brief 串口参数通知回调参数设置* @param uart 串口* @param rx_notify* @param tx_cpt_notify*/
void bsp_UartParNotifySet(USART_TypeDef *uart, uart_rx_notify rx_notify, uart_tx_cpt_notify tx_cpt_notify) {int idx;uart_idx_check(uart);// 为了保证在任意时刻调用,进行中断禁用的方式TX_INTERRUPT_SAVE_AREA/* enter interrupt */TX_DISABLEcontrollers[idx].rx_indicate = rx_notify;controllers[idx].tx_complete = tx_cpt_notify;TX_RESTORE
}/*** @brief 串口信号量设置* @param uart* @param rx_sem_flag 是否创建接收完成信号量* @param tx_sem_flag 是否创建发送完成信号量*/
void bsp_UartParSemSet(USART_TypeDef *uart, uint8_t rx_sem_flag, uint8_t tx_sem_flag) {int idx;uart_idx_check(uart);
#if UART_USE_OS_FLAGif (tx_sem_flag) {controllers[idx].tx_sem = tx_malloc(sizeof(TX_SEMAPHORE));tx_semaphore_create(controllers[idx].tx_sem, "tx_sem", 1);}if (rx_sem_flag) {controllers[idx].rx_sem = tx_malloc(sizeof(TX_SEMAPHORE));tx_semaphore_create(controllers[idx].rx_sem, "rx_sem", 1);}
#elsecontrollers[idx].tx_sem_flag = SET_UN_NOTIFY_FLAG;controllers[idx].rx_sem_flag = SET_UN_NOTIFY_FLAG;
#endif
}/*** @brief 初始化串口对象(必须调用)* @param uart 串口* @param tx_size 发送缓冲区大小,0,表示使用阻塞模式* @param rx_size 接收数据缓冲区大小,0：表示使用阻塞模式*/
void bsp_InitUart(USART_TypeDef *uart, uint16_t tx_size, uint16_t rx_size) {int idx;uart_idx_check(uart);void *buf;HAL_UART_Init(&(controllers[idx].handle));if (tx_size != 0 || rx_size != 0) {stm32_uart_irq_enable_cnf(uart); /*开启串口中断*/}if (tx_size != 0) {
#if UART_BUF_STATIC_METHODcontrollers[idx].tx_buffer = (struct rt_ringbuffer *) uart_static_buf[idx][0];rt_ringbuffer_init(controllers[idx].tx_buffer, uart_static_buf[idx][2],controllers[idx].tx_buffer->buffer_size);
#elsecontrollers[idx].tx_buffer = tx_malloc(sizeof(struct rt_ringbuffer));buf = tx_malloc(tx_size);rt_ringbuffer_init(controllers[idx].tx_buffer, buf, tx_size);
#endif}if (rx_size != 0) {
#if UART_BUF_STATIC_METHODcontrollers[idx].rx_buffer = (struct rt_ringbuffer *) uart_static_buf[idx][1];rt_ringbuffer_init(controllers[idx].rx_buffer, uart_static_buf[idx][3],controllers[idx].rx_buffer->buffer_size);
#elsecontrollers[idx].rx_buffer = tx_malloc(sizeof(struct rt_ringbuffer));buf = tx_malloc(tx_size);rt_ringbuffer_init(controllers[idx].rx_buffer, buf, rx_size);
#endifif (controllers[idx].handle.Init.Parity != UART_PARITY_NONE) {/* Enable the UART Parity Error Interrupt */__HAL_UART_ENABLE_IT(&controllers[idx].handle, UART_IT_PE);}/* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */__HAL_UART_ENABLE_IT(&controllers[idx].handle, UART_IT_ERR);/* Enable the UART Data Register not empty Interrupt */__HAL_UART_ENABLE_IT(&controllers[idx].handle, UART_IT_RXNE);}
}/*** @brief 复位串口* @param uart*/
void bsp_DeInitUart(USART_TypeDef *uart) {int idx;uart_idx_check(uart);if (controllers[idx].rx_buffer || controllers[idx].tx_buffer) {stm32_uart_irq_disable_cnf(uart);}HAL_UART_DeInit(&(controllers[idx].handle));
#if UART_BUF_STATIC_METHOD
#elseif (controllers[idx].rx_buffer)tx_free(controllers[idx].rx_buffer);if (controllers[idx].tx_buffer)tx_free(controllers[idx].tx_buffer);
#endif
#if UART_USE_OS_FLAGif (controllers[idx].rx_sem) {tx_semaphore_delete(controllers[idx].rx_sem);tx_free(controllers[idx].rx_sem);}if (controllers[idx].tx_sem) {tx_semaphore_delete(controllers[idx].tx_sem);tx_free(controllers[idx].tx_sem);}
#endifmemset(controllers + idx, 0, sizeof(struct stm32_uart_controller));
}/*** @brief 读取数据* @param uart 串口* @param data 保存数据位置* @param len 读取数据长度* @return 实际读取数据长度(数据长度,以返回值为准)*/
uint16_t uart_read_data(USART_TypeDef *uart, uint8_t *data, uint16_t len) {int idx;idx = stm32_uart_controller_idx_get(uart);if (idx < 0 || idx >= UART_CONTROLLER_NUM) return 0;if (controllers[idx].rx_buffer) {return rt_ringbuffer_get(controllers[idx].rx_buffer, data, len);}HAL_UART_Receive(&(controllers[idx].handle), data, len, HAL_MAX_DELAY);return len;
}/*** @brief 写入数据(阻塞或中断方式,根据初始化的方式决定)* @param uart* @param data* @param len* @return*/
uint16_t uart_write_data(USART_TypeDef *uart, uint8_t *data, uint16_t len) {int idx;idx = stm32_uart_controller_idx_get(uart);if (idx < 0 || idx >= UART_CONTROLLER_NUM) return 0;if (controllers[idx].tx_buffer) {
#if (UART_USE_OS_FLAG == 0)controllers[idx].tx_sem_flag = SEM_NOTIFY_FLAG;
#endifrt_ringbuffer_put(controllers[idx].tx_buffer, data, len);
//        HAL_UART_Transmit_IT(&controllers[idx].handle, data, len);__HAL_UART_ENABLE_IT(&(controllers[idx].handle), UART_IT_TXE);
#if UART_USE_OS_FLAGif (controllers[idx].tx_sem) {tx_semaphore_get((controllers[idx].tx_sem), TX_WAIT_FOREVER);} else {while (controllers[idx].handle.gState != HAL_UART_STATE_READY); /*使用hal库状态标识位来判断是否传输完成*/}
#elsewhile (controllers[idx].tx_sem_flag != SEM_NOTIFY_FLAG) {}
#endif} else {HAL_UART_Transmit(&controllers[idx].handle, data, len, HAL_MAX_DELAY);}return len;
}void USART1_IRQHandler(void) {TX_INTERRUPT_SAVE_AREA/* enter interrupt */TX_DISABLEHAL_UART_IRQHandler(&controllers[UART1_IDX].handle);/* leave interrupt */TX_RESTORE
}void USART2_IRQHandler(void) {TX_INTERRUPT_SAVE_AREA/* enter interrupt */TX_DISABLEHAL_UART_IRQHandler(&controllers[UART2_IDX].handle);/* leave interrupt */TX_RESTORE
}void USART3_IRQHandler(void) {TX_INTERRUPT_SAVE_AREA/* enter interrupt */TX_DISABLEHAL_UART_IRQHandler(&controllers[UART3_IDX].handle);/* leave interrupt */TX_RESTORE
}HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart) {uint8_t pdata8bits;uint16_t pdata16bits;rt_size_t (*write_call)(struct rt_ringbuffer *rb, const rt_uint8_t *ptr, rt_uint32_t length);write_call = rt_ringbuffer_put;struct stm32_uart_controller *control = rt_container_of(huart, struct stm32_uart_controller, handle);// 判断是否数据已满，如果已满，换成覆盖数据函数if (rt_ringbuffer_data_len(control->rx_buffer) == control->rx_buffer->buffer_size) {write_call = rt_ringbuffer_put_force;}if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE)) {pdata16bits = (uint16_t) (huart->Instance->DR & (uint16_t) 0x01FF);write_call(control->rx_buffer, (const rt_uint8_t *) &pdata16bits, 2);} else {if ((huart->Init.WordLength == UART_WORDLENGTH_9B) ||((huart->Init.WordLength == UART_WORDLENGTH_8B) && (huart->Init.Parity == UART_PARITY_NONE))) {pdata8bits = (uint8_t) (huart->Instance->DR & (uint8_t) 0x00FF);} else {pdata8bits = (uint8_t) (huart->Instance->DR & (uint8_t) 0x007F);}write_call(control->rx_buffer, (const rt_uint8_t *) &pdata8bits, 1);}uint32_t data_len = rt_ringbuffer_data_len(control->rx_buffer);if (data_len == control->rx_buffer->buffer_size) {// 通知接收缓冲区已满
#if UART_USE_OS_FLAGif (control->rx_sem) {tx_semaphore_put(control->rx_sem);}
#elsecontrol->rx_sem_flag = SEM_NOTIFY_FLAG;
#endif}if (data_len && control->rx_indicate) {control->rx_indicate(control, data_len);}return HAL_OK;
}/*** @brief  Sends an amount of data in non blocking mode.* @param  huart  Pointer to a UART_HandleTypeDef structure that contains*                the configuration information for the specified UART module.* @retval HAL status*/
HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart) {struct stm32_uart_controller *control = rt_container_of(huart, struct stm32_uart_controller, handle);/* Check that a Tx process is ongoing */
//    if (huart->gState == HAL_UART_STATE_BUSY_TX){
#if 0static uint8_t tmp;if (rt_ringbuffer_getchar((control->tx_buffer), (rt_uint8_t *) &tmp)) {huart->Instance->DR = tmp;} else {__HAL_UART_DISABLE_IT(huart, UART_IT_TXE);__HAL_UART_ENABLE_IT(huart, UART_IT_TC);}
#elsestatic uint16_t tmp;static uint8_t read_cnt;if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE)) {read_cnt = 2;} else {read_cnt = 1;}if (rt_ringbuffer_get(control->tx_buffer, (rt_uint8_t *) &tmp, read_cnt) == read_cnt) {huart->Instance->DR = read_cnt == 2? (uint16_t) (tmp & (uint16_t) 0x01FF): (uint8_t) (tmp & (uint8_t) 0x00FF);} else {__HAL_UART_DISABLE_IT(huart, UART_IT_TXE);__HAL_UART_ENABLE_IT(huart, UART_IT_TC);}
#endifreturn HAL_OK;}
//    else {
//        return HAL_BUSY;
//    }
}/*** @brief  Tx Transfer completed callbacks.* @param  huart  Pointer to a UART_HandleTypeDef structure that contains*                the configuration information for the specified UART module.* @retval None*/
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {struct stm32_uart_controller *control = rt_container_of(huart, struct stm32_uart_controller, handle);if (huart->hdmatx == NULL) { // 发送采用中断方式
#if UART_USE_OS_FLAG// 通知if (control->tx_sem) {tx_semaphore_put(control->tx_sem);}
#elsecontrol->tx_sem_flag = SEM_NOTIFY_FLAG;
#endifif (control->tx_complete) {control->tx_complete(control);}} else { // 发送采用dma的方式}}/*** @brief  Tx Half Transfer completed callbacks.* @param  huart  Pointer to a UART_HandleTypeDef structure that contains*                the configuration information for the specified UART module.* @retval None*/
void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart) {/* Prevent unused argument(s) compilation warning */UNUSED(huart);/* NOTE: This function should not be modified, when the callback is needed,the HAL_UART_TxHalfCpltCallback could be implemented in the user file*/
}/*** @brief  Rx Transfer completed callbacks.* @param  huart  Pointer to a UART_HandleTypeDef structure that contains*                the configuration information for the specified UART module.* @retval None*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {if (huart->hdmarx != NULL) { // 使用DMA方式}
}/*** @brief  Rx Half Transfer completed callbacks.* @param  huart  Pointer to a UART_HandleTypeDef structure that contains*                the configuration information for the specified UART module.* @retval None*/
void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) {/* Prevent unused argument(s) compilation warning */UNUSED(huart);/* NOTE: This function should not be modified, when the callback is needed,the HAL_UART_RxHalfCpltCallback could be implemented in the user file*/
}/*** @brief  UART error callbacks.* @param  huart  Pointer to a UART_HandleTypeDef structure that contains*                the configuration information for the specified UART module.* @retval None*/
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {/* Prevent unused argument(s) compilation warning */UNUSED(huart);// 重新开启接收struct stm32_uart_controller *control = rt_container_of(huart, struct stm32_uart_controller, handle);if (huart->hdmarx == NULL) {#if UART_USE_OS_FLAG// 通知if (control->rx_sem) {tx_semaphore_put(control->rx_sem);}
#elsecontrol->rx_sem_flag = SEM_NOTIFY_FLAG;
#endifif (huart->Init.Parity != UART_PARITY_NONE) {/* Enable the UART Parity Error Interrupt */__HAL_UART_ENABLE_IT(huart, UART_IT_PE);}/* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */__HAL_UART_ENABLE_IT(huart, UART_IT_ERR);/* Enable the UART Data Register not empty Interrupt */__HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);}if (huart->hdmatx == NULL) {
#if UART_USE_OS_FLAG// 通知if (control->tx_sem) {tx_semaphore_put(control->tx_sem);}
#elsecontrol->tx_sem_flag = SEM_NOTIFY_FLAG;
#endif}}/*** @brief  UART Abort Complete callback.* @param  huart UART handle.* @retval None*/
void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart) {/* Prevent unused argument(s) compilation warning */UNUSED(huart);/* NOTE : This function should not be modified, when the callback is needed,the HAL_UART_AbortCpltCallback can be implemented in the user file.*/
}/*** @brief  UART Abort Complete callback.* @param  huart UART handle.* @retval None*/
void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart) {/* Prevent unused argument(s) compilation warning */UNUSED(huart);/* NOTE : This function should not be modified, when the callback is needed,the HAL_UART_AbortTransmitCpltCallback can be implemented in the user file.*/
}/*** @brief  UART Abort Receive Complete callback.* @param  huart UART handle.* @retval None*/
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart) {/* Prevent unused argument(s) compilation warning */UNUSED(huart);/* NOTE : This function should not be modified, when the callback is needed,the HAL_UART_AbortReceiveCpltCallback can be implemented in the user file.*/
}/*** @brief  中断空闲方式和dma 空闲方式共用* @param  huart UART handle* @param  Size  Number of data available in application reception buffer (indicates a position in*               reception buffer until which, data are available)* @retval None*/
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {/* Prevent unused argument(s) compilation warning */UNUSED(huart);UNUSED(Size);/* NOTE : This function should not be modified, when the callback is needed,the HAL_UARTEx_RxEventCallback can be implemented in the user file.*/
}

硬件初始化

//
// Created by shchl on 2024/3/11.
// 串口硬件初始化
#include "drv_common.h"
/*** @brief  UART MSP Init.* @param  huart  Pointer to a UART_HandleTypeDef structure that contains*                the configuration information for the specified UART module.* @retval None*/
void HAL_UART_MspInit(UART_HandleTypeDef *huart) {GPIO_InitTypeDef GPIO_InitStruct = {0};switch ((uint32_t) huart->Instance) {case (uint32_t) USART1:__HAL_RCC_USART1_CLK_ENABLE();__HAL_RCC_GPIOA_CLK_ENABLE();/**USART1 GPIO配置PA9 ------> USART1_TXPA10 ------> USART1_RX*/GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10;GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;GPIO_InitStruct.Pull = GPIO_NOPULL;GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;GPIO_InitStruct.Alternate = GPIO_AF7_USART1;HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);break;case (uint32_t) USART2:__HAL_RCC_USART2_CLK_ENABLE();/* Peripheral clock enable */__HAL_RCC_USART2_CLK_ENABLE();__HAL_RCC_GPIOA_CLK_ENABLE();/**USART2 GPIO ConfigurationPA2     ------> USART2_TXPA3     ------> USART2_RX*/GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;GPIO_InitStruct.Pull = GPIO_NOPULL;GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;GPIO_InitStruct.Alternate = GPIO_AF7_USART2;HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);break;default:// todo 按理不会执行到此处break;}}

测试

    // 设置串口bsp_UartParDefaultSet(USART1);// 静态分配,后面两个参数无效bsp_UartParSemSet(USART1,0,1);// 静态分配,后面两个参数无效bsp_InitUart(USART1, 2048, 2048);

结果(测试ok，方便移植)

在这里插入图片描述

说明

  1. 如果是裸机的话,只需要改动hal库源码，把对应的函数改成弱引用，由外部重写。并使用静态分配的方式和内部变量的标志位。
  2. 驱动依赖了一个缓冲数据结构体，将hal库内部的数据指针的部分替换为使用循环缓冲区进行存取，驱动只涉及到中断的方式，dma的方式，可通过对应的回调函数中进行添加（dma和中断共用一套回调函数，通过判断串口内部dma指针的引用是否为NULL进行推断使用的是中断还是dma方式即可）

这篇关于stm32之hal库串口中断和ringbuffer的结合的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/959107。

相关文章

Python结合requests和Cheerio处理网页内容的操作步骤

Python结合requests和Cheerio处理网页内容的操作步骤

《Python结合requests和Cheerio处理网页内容的操作步骤》Python因其简洁明了的语法和强大的库支持,成为了编写爬虫程序的首选语言之一,requests库是Python中用于发送HT... 目录一、前言二、环境搭建三、requests库的基本使用四、Cheerio库的基本使用五、结合req
阅读更多...
如何用Java结合经纬度位置计算目标点的日出日落时间详解

如何用Java结合经纬度位置计算目标点的日出日落时间详解

《如何用Java结合经纬度位置计算目标点的日出日落时间详解》这篇文章主详细讲解了如何基于目标点的经纬度计算日出日落时间,提供了在线API和Java库两种计算方法,并通过实际案例展示了其应用,需要的朋友... 目录前言一、应用示例1、天安门升旗时间2、湖南省日出日落信息二、Java日出日落计算1、在线API2
阅读更多...
第10章 中断和动态时钟显示

第10章 中断和动态时钟显示

第10章 中断和动态时钟显示 从本章开始，按照书籍的划分，第10章开始就进入保护模式（Protected Mode）部分了，感觉从这里开始难度突然就增加了。 书中介绍了为什么有中断（Interrupt）的设计，中断的几种方式：外部硬件中断、内部中断和软中断。通过中断做了一个会走的时钟和屏幕上输入字符的程序。 我自己理解中断的一些作用： 为了更好的利用处理器的性能。协同快速和慢速设备一起工作
阅读更多...
【STM32】SPI通信-软件与硬件读写SPI

【STM32】SPI通信-软件与硬件读写SPI

SPI通信-软件与硬件读写SPI 软件SPI一、SPI通信协议1、SPI通信2、硬件电路3、移位示意图4、SPI时序基本单元(1)开始通信和结束通信(2)模式0---用的最多(3)模式1(4)模式2(5)模式3 5、SPI时序(1)写使能(2)指定地址写(3)指定地址读 二、W25Q64模块介绍１、W25Q64简介２、硬件电路３、W25Q64框图４、Flash操作注意事项软件SPI读写W2
阅读更多...
STM32(十一)：ADC数模转换器实验

STM32(十一)：ADC数模转换器实验

AD单通道： 1.RCC开启GPIO和ADC时钟。配置ADCCLK分频器。 2.配置GPIO，把GPIO配置成模拟输入的模式。 3.配置多路开关，把左面通道接入到右面规则组列表里。 4.配置ADC转换器， 包括AD转换器和AD数据寄存器。单次转换，连续转换；扫描、非扫描；有几个通道，触发源是什么，数据对齐是左对齐还是右对齐。 5.ADC_CMD 开启ADC。 void RCC_AD
阅读更多...
STM32内部闪存FLASH（内部ROM）、IAP

STM32内部闪存FLASH（内部ROM）、IAP

1 FLASH简介  1 利用程序存储器的剩余空间来保存掉电不丢失的用户数据 2 通过在程序中编程(IAP)实现程序的自我更新 （OTA） 3在线编程（ICP把整个程序都更新掉） 1 系统的Bootloader写死了，只能用串口下载到指定的位置，启动方式也不方便需要配置BOOT引脚触发启动  4 IAP(自己写的Bootloader，实现程序升级) 1 比如蓝牙转串口，
阅读更多...
FreeRTOS-基本介绍和移植STM32

FreeRTOS-基本介绍和移植STM32

FreeRTOS-基本介绍和STM32移植 一、裸机开发和操作系统开发介绍二、任务调度和任务状态介绍2.1 任务调度2.1.1 抢占式调度2.1.2 时间片调度 2.2 任务状态 三、FreeRTOS源码和移植STM323.1 FreeRTOS源码3.2 FreeRTOS移植STM323.2.1 代码移植3.2.2 时钟中断配置 一、裸机开发和操作系统开发介绍 裸机：前后台系
阅读更多...
寻迹模块TCRT5000的应用原理和功能实现（基于STM32）

寻迹模块TCRT5000的应用原理和功能实现（基于STM32）

目录 概述 1 认识TCRT5000 1.1 模块介绍 1.2 电气特性 2 系统应用 2.1 系统架构 2.2 STM32Cube创建工程 3 功能实现 3.1 代码实现 3.2 源代码文件 4 功能测试 4.1 检测黑线状态 4.2 未检测黑线状态 概述 本文主要介绍TCRT5000模块的使用原理，包括该模块的硬件实现方式，电路实现原理，还使用STM32类
阅读更多...
STM32 ADC+DMA导致写FLASH失败

STM32 ADC+DMA导致写FLASH失败

最近用STM32G070系列的ADC+DMA采样时，遇到了一些小坑记录一下； 一、ADC+DMA采样时进入死循环； 解决方法：ADC-dma死循环问题_stm32 adc dma死机-CSDN博客 将ADC的DMA中断调整为最高，且增大ADCHAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buffer, ADC_Buffer_Size); 的ADC_Bu
阅读更多...
Go 语言中Select与for结合使用break

Go 语言中Select与for结合使用break

func test(){i := 0for {select {case <-time.After(time.Second * time.Duration(2)):i++if i == 5{fmt.Println("break now")break }fmt.Println("inside the select: ")}fmt.Println("inside the for: ")}} 执行后
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2