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

ops/2024/10/21 6:45:23/

前言

  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方式即可）

http://www.ppmy.cn/ops/32543.html

相关文章

【ARM Cortex-M3指南】3：Cortex-M3基础

【ARM Cortex-M3指南】3：Cortex-M3基础

文章目录 三、Cortex-M3基础3.1 寄存器3.1.1 通用目的寄存器 R0~R73.1.2 通用目的寄存器 R8~R123.1.3 栈指针 R133.1.4 链接寄存器 R143.1.5 程序计数器 R15 3.2 特殊寄存器3.2.1 程序状态寄存器3.2.2 PRIMASK、FAULTMASK和BASEPRI寄存器3.2.3 控制寄存器 3.3 操作模式3.4 异常…
阅读更多...
将要上市的自动驾驶新书《自动驾驶系统开发》中摘录各章片段 1

将要上市的自动驾驶新书《自动驾驶系统开发》中摘录各章片段 1

以下摘录一些章节片段&#xff1a; 1. 概论 自动驾驶系统的认知中有一些模糊的地方&#xff0c;比如自动驾驶系统如何定义的问题&#xff0c;自动驾驶的研发为什么会有那么多的子模块&#xff0c;怎么才算自动驾驶落地等等。本章想先给读者一个概括介绍&#xff0c;了解自动驾…
阅读更多...
ZooKeeper详解

ZooKeeper详解

文章目录 ZooKeeper作用举例 设计原理Znodes的状态变化具体步骤ZooKeeper原理ZooKeeper数据结构(了解)ZooKeeper CLIZooKeeper 端口号Zookeeper角色ZooKeeper选举机制半数机制leader选举触发时机补充 ZooKeeper 作用 ZooKeeper在大数据组件中起着重要的协调作用&#xff0c;帮…
阅读更多...
给Ollama套个WebUI，方便使用

给Ollama套个WebUI，方便使用

Ollama 基本的安装使用参考前文 https://xugaoxiang.com/2024/05/01/ollama-offline-deploy/&#xff0c;前文使用的模型是 llama2&#xff0c;本篇将使用 llama3&#xff0c;因此在启动时&#xff0c;命令是 ollama run llama3。 Ollama Llama3 Llama3 是 Meta 发布的大语言模…
阅读更多...
JSON解析

JSON解析

JSON简介 JSON是一种轻量级的数据交换格式&#xff0c;它采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得JSON成为理想的数据交换语言&#xff0c;易于人的阅读和编写&#xff0c;同时也有利于机器解析和生成&#xff0c;并有效地提升网络传输效率…
阅读更多...
快速了解Django：核心概念解析与实践指南

快速了解Django：核心概念解析与实践指南

title: 快速了解Django&#xff1a;核心概念解析与实践指南 date: 2024/5/1 20:31:41 updated: 2024/5/1 20:31:41 categories: 后端开发 tags: Django核心路由系统视图系统ORM管理中间件Web框架登录装饰器 第一章&#xff1a;Django简介 背景和发展历程&#xff1a; Djan…
阅读更多...
Python | Leetcode Python题解之第65题有效数字

Python | Leetcode Python题解之第65题有效数字

题目&#xff1a; 题解&#xff1a; from enum import Enumclass Solution:def isNumber(self, s: str) -> bool:State Enum("State", ["STATE_INITIAL","STATE_INT_SIGN","STATE_INTEGER","STATE_POINT","STATE_…
阅读更多...
Android 安装过程三 MSG_ON_SESSION_SEALED、MSG_STREAM_VALIDATE_AND_COMMIT的处理

Android 安装过程三 MSG_ON_SESSION_SEALED、MSG_STREAM_VALIDATE_AND_COMMIT的处理

Android 安装过程一 界面跳转 知道&#xff0c;在InstallInstalling Activity中&#xff0c;PackageInstallerSession对象创建之后&#xff0c;接着会打开它&#xff0c;然后将安装文件进行拷贝&#xff0c;拷贝完成之后&#xff0c;会对Session对象确认。   从Session对象确…
阅读更多...
最新文章

Copyright @ 2022~2023