716 lines
22 KiB
C
716 lines
22 KiB
C
/*!
|
||
\file usart.c
|
||
\brief 串口（USART/UART）统一驱动入口（集中式）
|
||
|
||
目标：把 `BSP\com\` 下分散的串口实现整理为“单入口/统一API”，形态上尽量贴近
|
||
`CCU601E_RUN\BSP\ST_HAL\usart.c`（集中管理各串口初始化、发送、接收缓存、中断）。
|
||
*/
|
||
|
||
#include "usart.h"
|
||
|
||
#include <stdarg.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
#include "gd32h7xx.h"
|
||
#include "publicdata/public_define.h"
|
||
#include "ringfifo/ringfifo.h"
|
||
|
||
#ifndef DEBUG_SHELL_USART_NULL
|
||
#define DEBUG_SHELL_USART_NULL (0xFFU)
|
||
#endif
|
||
#ifndef DEBUG_SHELL_USART_ID
|
||
#define DEBUG_SHELL_USART_ID DEBUG_SHELL_USART_NULL
|
||
#endif
|
||
|
||
/* ===== 通用：ringfifo 接收缓存（每路一套）===== */
|
||
#define UART0_RX_BUFFER_SIZE 256U
|
||
#define UART2_RX_BUFFER_SIZE 256U
|
||
#define UART3_RX_BUFFER_SIZE 256U
|
||
#define UART4_RX_BUFFER_SIZE 256U
|
||
#define UART5_RX_BUFFER_SIZE 256U
|
||
#define UART6_RX_BUFFER_SIZE 4096U
|
||
#define UART7_RX_BUFFER_SIZE 256U
|
||
|
||
#define UART0_BAUDRATE 115200U
|
||
#define UART2_BAUDRATE 115200U
|
||
#define UART3_BAUDRATE 2400U
|
||
#define UART4_BAUDRATE 2400U
|
||
#define UART5_BAUDRATE 115200U
|
||
#define UART6_BAUDRATE 115200U
|
||
#define UART7_BAUDRATE 115200U
|
||
|
||
static _fifo_t s_uart0_rx;
|
||
static _fifo_t s_uart2_rx;
|
||
static _fifo_t s_uart3_rx;
|
||
static _fifo_t s_uart4_rx;
|
||
static _fifo_t s_uart5_rx;
|
||
static _fifo_t s_uart6_rx;
|
||
static _fifo_t s_uart7_rx;
|
||
|
||
static uint8_t s_uart0_rx_mem[UART0_RX_BUFFER_SIZE];
|
||
static uint8_t s_uart2_rx_mem[UART2_RX_BUFFER_SIZE];
|
||
static uint8_t s_uart3_rx_mem[UART3_RX_BUFFER_SIZE];
|
||
static uint8_t s_uart4_rx_mem[UART4_RX_BUFFER_SIZE];
|
||
static uint8_t s_uart5_rx_mem[UART5_RX_BUFFER_SIZE];
|
||
static uint8_t s_uart6_rx_mem[UART6_RX_BUFFER_SIZE];
|
||
static uint8_t s_uart7_rx_mem[UART7_RX_BUFFER_SIZE];
|
||
|
||
/* 前置声明：避免 usart6_init 中调用时出现隐式声明 */
|
||
void uart6_init(void);
|
||
/* 与 CCU601E_D 一致：按 slot 0~6 对应 7 路物理串口（实际编号 0/2/3/4/5/6/7），Shell 用 usart_printf 配置。 */
|
||
U8_T u8_uasrt_print[USART_NUM_PRINT_CNT] = {0};
|
||
|
||
static uint8_t usart_hw_num_to_slot(uint8_t usart_num)
|
||
{
|
||
switch (usart_num) {
|
||
case 0: return 0U;
|
||
case 2: return 1U;
|
||
case 3: return 2U;
|
||
case 4: return 3U;
|
||
case 5: return 4U;
|
||
case 6: return 5U;
|
||
case 7: return 6U;
|
||
default: return 0xFFU;
|
||
}
|
||
}
|
||
|
||
static void usart_dump_line(const char *tag, uint8_t usart_num, const uint8_t *data, uint16_t len)
|
||
{
|
||
uint16_t i;
|
||
|
||
if (data == NULL || len == 0U) {
|
||
return;
|
||
}
|
||
(void)printf("\r\n--------------usart(%u) %s :\r\n", (unsigned)usart_num, tag);
|
||
for (i = 0U; i < len; i++) {
|
||
(void)printf("%02X ", (unsigned int)data[i]);
|
||
}
|
||
(void)printf("\r\n---------------%s end\r\n", tag);
|
||
}
|
||
/**
|
||
* @brief 根据串口编号返回对应 ringfifo 句柄
|
||
* @param usart_num 串口编号
|
||
* @retval 对应的 _fifo_t 指针；不支持时返回 NULL
|
||
*/
|
||
static _fifo_t *get_fifo_by_id(uint8_t usart_num)
|
||
{
|
||
switch (usart_num) {
|
||
case 0: return &s_uart0_rx;
|
||
case 2: return &s_uart2_rx;
|
||
case 3: return &s_uart3_rx;
|
||
case 4: return &s_uart4_rx;
|
||
case 5: return &s_uart5_rx;
|
||
case 6: return &s_uart6_rx;
|
||
case 7: return &s_uart7_rx;
|
||
default: return NULL;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 注册全部串口接收 FIFO（仅执行一次）
|
||
* @retval none
|
||
*/
|
||
static void usart_fifo_register_all(void)
|
||
{
|
||
static uint8_t registered = 0U;
|
||
if (registered) {
|
||
return;
|
||
}
|
||
fifo_register(&s_uart0_rx, s_uart0_rx_mem, UART0_RX_BUFFER_SIZE, NULL, NULL);
|
||
fifo_register(&s_uart2_rx, s_uart2_rx_mem, UART2_RX_BUFFER_SIZE, NULL, NULL);
|
||
fifo_register(&s_uart3_rx, s_uart3_rx_mem, UART3_RX_BUFFER_SIZE, NULL, NULL);
|
||
fifo_register(&s_uart4_rx, s_uart4_rx_mem, UART4_RX_BUFFER_SIZE, NULL, NULL);
|
||
fifo_register(&s_uart5_rx, s_uart5_rx_mem, UART5_RX_BUFFER_SIZE, NULL, NULL);
|
||
fifo_register(&s_uart6_rx, s_uart6_rx_mem, UART6_RX_BUFFER_SIZE, NULL, NULL);
|
||
fifo_register(&s_uart7_rx, s_uart7_rx_mem, UART7_RX_BUFFER_SIZE, NULL, NULL);
|
||
registered = 1U;
|
||
}
|
||
|
||
/* ===== 通用：阻塞式发送 ===== */
|
||
/**
|
||
* @brief 阻塞发送指定长度数据
|
||
* @param periph 串口外设基地址
|
||
* @param data 待发送数据指针
|
||
* @param len 待发送长度
|
||
* @retval none
|
||
*/
|
||
static void usart_send_blocking(uint32_t periph, const uint8_t *data, uint16_t len)
|
||
{
|
||
for (uint16_t i = 0; i < len; i++) {
|
||
while (RESET == usart_flag_get(periph, USART_FLAG_TBE)) {}
|
||
usart_data_transmit(periph, data[i]);
|
||
}
|
||
while (RESET == usart_flag_get(periph, USART_FLAG_TC)) {}
|
||
}
|
||
|
||
static uint32_t usart_periph_from_id(uint8_t usart_id)
|
||
{
|
||
switch (usart_id) {
|
||
case E_USART_0: return USART0;
|
||
case E_USART_2: return USART2;
|
||
case E_USART_3: return UART3;
|
||
case E_USART_4: return UART4;
|
||
case E_USART_5: return USART5;
|
||
case E_USART_6: return UART6;
|
||
case E_USART_7: return UART7;
|
||
default: return 0U;
|
||
}
|
||
}
|
||
|
||
/* ===== 各串口硬件初始化（集中在同一个文件里）===== */
|
||
/**
|
||
* @brief USART0 初始化：PF4/PF5，115200，8N1
|
||
* @retval none
|
||
*/
|
||
void usart0_init(void)
|
||
{
|
||
rcu_periph_clock_enable(RCU_GPIOF);
|
||
rcu_periph_clock_enable(RCU_USART0);
|
||
|
||
gpio_af_set(GPIOF, GPIO_AF_4, GPIO_PIN_4);
|
||
gpio_mode_set(GPIOF, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_4);
|
||
gpio_output_options_set(GPIOF, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_4);
|
||
|
||
gpio_af_set(GPIOF, GPIO_AF_4, GPIO_PIN_5);
|
||
gpio_mode_set(GPIOF, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_5);
|
||
|
||
usart_deinit(USART0);
|
||
usart_word_length_set(USART0, USART_WL_8BIT);
|
||
usart_stop_bit_set(USART0, USART_STB_1BIT);
|
||
usart_parity_config(USART0, USART_PM_NONE);
|
||
usart_baudrate_set(USART0, UART0_BAUDRATE);
|
||
usart_hardware_flow_rts_config(USART0, USART_RTS_DISABLE);
|
||
usart_hardware_flow_cts_config(USART0, USART_CTS_DISABLE);
|
||
usart_receive_config(USART0, USART_RECEIVE_ENABLE);
|
||
usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
|
||
|
||
// nvic_irq_enable(USART0_IRQn, 3U, 1U); /* 已迁移到 sys_drv_init.c:nvic_configuration() */
|
||
usart_interrupt_enable(USART0, USART_INT_RBNE);
|
||
usart_enable(USART0);
|
||
}
|
||
|
||
/**
|
||
* @brief USART2 初始化：PD8/PD9，115200，8N1
|
||
* @retval none
|
||
*/
|
||
void usart2_init(void)
|
||
{
|
||
rcu_periph_clock_enable(RCU_GPIOD);
|
||
rcu_periph_clock_enable(RCU_USART2);
|
||
|
||
gpio_af_set(GPIOD, GPIO_AF_7, GPIO_PIN_8);
|
||
gpio_mode_set(GPIOD, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_8);
|
||
gpio_output_options_set(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_8);
|
||
|
||
gpio_af_set(GPIOD, GPIO_AF_7, GPIO_PIN_9);
|
||
gpio_mode_set(GPIOD, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_9);
|
||
gpio_output_options_set(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_9);
|
||
|
||
usart_deinit(USART2);
|
||
usart_word_length_set(USART2, USART_WL_8BIT);
|
||
usart_stop_bit_set(USART2, USART_STB_1BIT);
|
||
usart_parity_config(USART2, USART_PM_NONE);
|
||
usart_baudrate_set(USART2, UART2_BAUDRATE);
|
||
|
||
usart_receive_config(USART2, USART_RECEIVE_ENABLE);
|
||
usart_transmit_config(USART2, USART_TRANSMIT_ENABLE);
|
||
|
||
// nvic_irq_enable(USART2_IRQn, 3U, 2U); /* 已迁移到 sys_drv_init.c:nvic_configuration() */
|
||
usart_interrupt_enable(USART2, USART_INT_RBNE);
|
||
usart_enable(USART2);
|
||
}
|
||
|
||
/**
|
||
* @brief UART3 初始化：PC10/PC11，2400，8E1
|
||
* @retval none
|
||
*/
|
||
void uart3_init(void)
|
||
{
|
||
rcu_periph_clock_enable(RCU_GPIOC);
|
||
rcu_periph_clock_enable(RCU_UART3);
|
||
|
||
gpio_af_set(GPIOC, GPIO_AF_8, GPIO_PIN_10);
|
||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_10);
|
||
gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_10);
|
||
|
||
gpio_af_set(GPIOC, GPIO_AF_8, GPIO_PIN_11);
|
||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
|
||
|
||
usart_deinit(UART3);
|
||
/* 8E1: data(8) + parity(1) -> word length must be 9-bit on this peripheral */
|
||
usart_word_length_set(UART3, USART_WL_9BIT);
|
||
usart_stop_bit_set(UART3, USART_STB_1BIT);
|
||
usart_parity_config(UART3, USART_PM_EVEN);
|
||
usart_baudrate_set(UART3, UART3_BAUDRATE);
|
||
usart_hardware_flow_rts_config(UART3, USART_RTS_DISABLE);
|
||
usart_hardware_flow_cts_config(UART3, USART_CTS_DISABLE);
|
||
usart_receive_config(UART3, USART_RECEIVE_ENABLE);
|
||
usart_transmit_config(UART3, USART_TRANSMIT_ENABLE);
|
||
|
||
// nvic_irq_enable(UART3_IRQn, 3U, 0U); /* 已迁移到 sys_drv_init.c:nvic_configuration() */
|
||
usart_interrupt_enable(UART3, USART_INT_RBNE);
|
||
usart_enable(UART3);
|
||
}
|
||
|
||
/**
|
||
* @brief UART4 初始化：PC12/PD2，2400，8E1
|
||
* @retval none
|
||
*/
|
||
void uart4_init(void)
|
||
{
|
||
rcu_periph_clock_enable(RCU_GPIOC);
|
||
rcu_periph_clock_enable(RCU_GPIOD);
|
||
rcu_periph_clock_enable(RCU_UART4);
|
||
|
||
gpio_af_set(GPIOC, GPIO_AF_8, GPIO_PIN_12);
|
||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_12);
|
||
gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_12);
|
||
|
||
gpio_af_set(GPIOD, GPIO_AF_8, GPIO_PIN_2);
|
||
gpio_mode_set(GPIOD, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_2);
|
||
|
||
usart_deinit(UART4);
|
||
/* 8E1: data(8) + parity(1) -> word length must be 9-bit on this peripheral */
|
||
usart_word_length_set(UART4, USART_WL_9BIT);
|
||
usart_stop_bit_set(UART4, USART_STB_1BIT);
|
||
usart_parity_config(UART4, USART_PM_EVEN);
|
||
usart_baudrate_set(UART4, UART4_BAUDRATE);
|
||
usart_hardware_flow_rts_config(UART4, USART_RTS_DISABLE);
|
||
usart_hardware_flow_cts_config(UART4, USART_CTS_DISABLE);
|
||
usart_receive_config(UART4, USART_RECEIVE_ENABLE);
|
||
usart_transmit_config(UART4, USART_TRANSMIT_ENABLE);
|
||
|
||
// nvic_irq_enable(UART4_IRQn, 2U, 0U); /* 已迁移到 sys_drv_init.c:nvic_configuration() */
|
||
usart_interrupt_enable(UART4, USART_INT_RBNE);
|
||
usart_enable(UART4);
|
||
}
|
||
|
||
/**
|
||
* @brief USART5 初始化：PC6/PC7，115200，8N1
|
||
* @retval none
|
||
*/
|
||
void usart5_init(void)
|
||
{
|
||
rcu_periph_clock_enable(RCU_GPIOC);
|
||
rcu_periph_clock_enable(RCU_USART5);
|
||
|
||
gpio_af_set(GPIOC, GPIO_AF_7, GPIO_PIN_6);
|
||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_6);
|
||
gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_6);
|
||
|
||
gpio_af_set(GPIOC, GPIO_AF_7, GPIO_PIN_7);
|
||
gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_7);
|
||
|
||
usart_deinit(USART5);
|
||
usart_oversample_config(USART5, USART_OVSMOD_16);
|
||
usart_word_length_set(USART5, USART_WL_8BIT);
|
||
usart_stop_bit_set(USART5, USART_STB_1BIT);
|
||
usart_parity_config(USART5, USART_PM_NONE);
|
||
usart_baudrate_set(USART5, UART5_BAUDRATE);
|
||
usart_hardware_flow_rts_config(USART5, USART_RTS_DISABLE);
|
||
usart_hardware_flow_cts_config(USART5, USART_CTS_DISABLE);
|
||
usart_receive_config(USART5, USART_RECEIVE_ENABLE);
|
||
usart_transmit_config(USART5, USART_TRANSMIT_ENABLE);
|
||
|
||
// nvic_irq_enable(USART5_IRQn, 1U, 0U); /* 已迁移到 sys_drv_init.c:nvic_configuration() */
|
||
usart_interrupt_enable(USART5, USART_INT_RBNE);
|
||
usart_enable(USART5);
|
||
}
|
||
|
||
/**
|
||
* @brief 兼容接口：旧代码调用 usart6_init，内部转到 uart6_init
|
||
* @retval none
|
||
*/
|
||
void usart6_init(void)
|
||
{
|
||
/* 兼容旧头文件声明：usart6_init -> uart6_init */
|
||
uart6_init();
|
||
}
|
||
|
||
/**
|
||
* @brief UART6 初始化：PB4/PB3，115200，8N1
|
||
* @retval none
|
||
*/
|
||
void uart6_init(void)
|
||
{
|
||
rcu_periph_clock_enable(RCU_GPIOB);
|
||
rcu_periph_clock_enable(RCU_UART6);
|
||
|
||
gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_4);
|
||
gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_4);
|
||
gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_4);
|
||
|
||
gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_3);
|
||
gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_3);
|
||
|
||
usart_deinit(UART6);
|
||
usart_word_length_set(UART6, USART_WL_8BIT);
|
||
usart_stop_bit_set(UART6, USART_STB_1BIT);
|
||
usart_parity_config(UART6, USART_PM_NONE);
|
||
usart_baudrate_set(UART6, UART6_BAUDRATE);
|
||
usart_hardware_flow_rts_config(UART6, USART_RTS_DISABLE);
|
||
usart_hardware_flow_cts_config(UART6, USART_CTS_DISABLE);
|
||
usart_receive_config(UART6, USART_RECEIVE_ENABLE);
|
||
usart_transmit_config(UART6, USART_TRANSMIT_ENABLE);
|
||
|
||
// nvic_irq_enable(UART6_IRQn, 0U, 0U); /* 已迁移到 sys_drv_init.c:nvic_configuration() */
|
||
usart_interrupt_enable(UART6, USART_INT_RBNE);
|
||
usart_enable(UART6);
|
||
}
|
||
|
||
/**
|
||
* @brief UART7 初始化：PE1/PE0，115200，8N1
|
||
* @retval none
|
||
*/
|
||
void uart7_init(void)
|
||
{
|
||
rcu_periph_clock_enable(RCU_GPIOE);
|
||
rcu_periph_clock_enable(RCU_UART7);
|
||
|
||
gpio_af_set(GPIOE, GPIO_AF_8, GPIO_PIN_1);
|
||
gpio_mode_set(GPIOE, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_1);
|
||
gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_1);
|
||
|
||
gpio_af_set(GPIOE, GPIO_AF_8, GPIO_PIN_0);
|
||
gpio_mode_set(GPIOE, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_0);
|
||
|
||
usart_deinit(UART7);
|
||
usart_word_length_set(UART7, USART_WL_8BIT);
|
||
usart_stop_bit_set(UART7, USART_STB_1BIT);
|
||
usart_parity_config(UART7, USART_PM_NONE);
|
||
usart_baudrate_set(UART7, UART7_BAUDRATE);
|
||
usart_hardware_flow_rts_config(UART7, USART_RTS_DISABLE);
|
||
usart_hardware_flow_cts_config(UART7, USART_CTS_DISABLE);
|
||
usart_receive_config(UART7, USART_RECEIVE_ENABLE);
|
||
usart_transmit_config(UART7, USART_TRANSMIT_ENABLE);
|
||
|
||
// nvic_irq_enable(UART7_IRQn, 3U, 7U); /* 已迁移到 sys_drv_init.c:nvic_configuration() */
|
||
usart_interrupt_enable(UART7, USART_INT_RBNE);
|
||
usart_enable(UART7);
|
||
}
|
||
|
||
/* ===== 中断服务程序（集中管理）===== */
|
||
/**
|
||
* @brief USART0 中断处理函数，接收数据压入 FIFO
|
||
* @retval none
|
||
*/
|
||
void USART0_IRQHandler(void)
|
||
{
|
||
if (RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) {
|
||
uint8_t b = usart_data_receive(USART0);
|
||
fifo_write(&s_uart0_rx, &b, 1U);
|
||
usart_interrupt_flag_clear(USART0, USART_INT_FLAG_RBNE);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief USART2 中断处理函数，接收数据压入 FIFO
|
||
* @retval none
|
||
*/
|
||
void USART2_IRQHandler(void)
|
||
{
|
||
if (RESET != usart_interrupt_flag_get(USART2, USART_INT_FLAG_RBNE)) {
|
||
uint8_t b = usart_data_receive(USART2);
|
||
fifo_write(&s_uart2_rx, &b, 1U);
|
||
usart_interrupt_flag_clear(USART2, USART_INT_FLAG_RBNE);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief UART3 中断处理函数，接收数据压入 FIFO
|
||
* @retval none
|
||
*/
|
||
void UART3_IRQHandler(void)
|
||
{
|
||
if (RESET != usart_flag_get(UART3, USART_FLAG_RBNE)) {
|
||
uint8_t b = usart_data_receive(UART3);
|
||
fifo_write(&s_uart3_rx, &b, 1U);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief UART4 中断处理函数，接收数据压入 FIFO
|
||
* @retval none
|
||
*/
|
||
void UART4_IRQHandler(void)
|
||
{
|
||
if (RESET != usart_flag_get(UART4, USART_FLAG_RBNE)) {
|
||
uint8_t b = usart_data_receive(UART4);
|
||
fifo_write(&s_uart4_rx, &b, 1U);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief USART5 中断处理函数，接收数据压入 FIFO
|
||
* @retval none
|
||
*/
|
||
void USART5_IRQHandler(void)
|
||
{
|
||
if (RESET != usart_interrupt_flag_get(USART5, USART_INT_FLAG_RBNE)) {
|
||
uint8_t b = usart_data_receive(USART5);
|
||
fifo_write(&s_uart5_rx, &b, 1U);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief UART6 中断处理函数，接收数据压入 FIFO
|
||
* @retval none
|
||
*/
|
||
void UART6_IRQHandler(void)
|
||
{
|
||
if (RESET != usart_interrupt_flag_get(UART6, USART_INT_FLAG_RBNE)) {
|
||
uint8_t b = usart_data_receive(UART6);
|
||
fifo_write(&s_uart6_rx, &b, 1U);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief UART7 中断处理函数，接收数据压入 FIFO
|
||
* @retval none
|
||
*/
|
||
void UART7_IRQHandler(void)
|
||
{
|
||
if (RESET != usart_interrupt_flag_get(UART7, USART_INT_FLAG_RBNE)) {
|
||
uint8_t b = usart_data_receive(UART7);
|
||
fifo_write(&s_uart7_rx, &b, 1U);
|
||
}
|
||
}
|
||
|
||
/* ===== 对外：兼容现有统一API ===== */
|
||
/**
|
||
* @brief 初始化指定串口
|
||
* @param usart_num 串口编号（0/2/3/4/5/6/7）
|
||
* @retval 0 初始化成功；-1 参数不支持
|
||
*/
|
||
int v_usart_init(uint8_t usart_num)
|
||
{
|
||
usart_fifo_register_all();
|
||
switch (usart_num) {
|
||
case 0: usart0_init(); return 0;
|
||
case 2: usart2_init(); return 0;
|
||
case 3: uart3_init(); return 0;
|
||
case 4: uart4_init(); return 0;
|
||
case 5: usart5_init(); return 0;
|
||
case 6: uart6_init(); return 0;
|
||
case 7: uart7_init(); return 0;
|
||
default: return -1;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 批量初始化全部串口
|
||
* @retval 0
|
||
*/
|
||
int v_usart_init_all(void)
|
||
{
|
||
usart_fifo_register_all();
|
||
usart0_init();
|
||
usart2_init();
|
||
uart3_init();
|
||
uart4_init();
|
||
usart5_init();
|
||
uart6_init();
|
||
uart7_init();
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 统一发送二进制数据接口
|
||
* @param usart_num 串口编号
|
||
* @param data 发送缓冲区
|
||
* @param len 发送长度
|
||
* @retval 0 发送成功；-1 参数或编号不支持
|
||
*/
|
||
int v_usart_send_data(uint8_t usart_num, uint8_t *data, uint16_t len)
|
||
{
|
||
if (data == NULL || len == 0U) return -1;
|
||
switch (usart_num) {
|
||
case 0: usart_send_blocking(USART0, data, len); return 0;
|
||
case 2: usart_send_blocking(USART2, data, len); return 0;
|
||
case 3: usart_send_blocking(UART3, data, len); return 0;
|
||
case 4: usart_send_blocking(UART4, data, len); return 0;
|
||
case 5: usart_send_blocking(USART5, data, len); return 0;
|
||
case 6: usart_send_blocking(UART6, data, len); return 0;
|
||
case 7: usart_send_blocking(UART7, data, len); return 0;
|
||
default: return -1;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 查询指定串口接收 FIFO 的有效数据长度
|
||
* @param usart_num 串口编号
|
||
* @retval >=0 有效数据长度；-1 编号不支持
|
||
*/
|
||
int v_usart_get_rx_data_count(uint8_t usart_num)
|
||
{
|
||
_fifo_t *f = get_fifo_by_id(usart_num);
|
||
if (f == NULL) return -1;
|
||
return (int)fifo_get_occupy_size(f);
|
||
}
|
||
|
||
/**
|
||
* @brief 从指定串口 FIFO 读取数据
|
||
* @param usart_num 串口编号
|
||
* @param data 读取目标缓冲区
|
||
* @param len 期望读取长度
|
||
* @retval >=0 实际读取长度；-1 参数或编号不支持
|
||
*/
|
||
int v_usart_read_rx_buffer(uint8_t usart_num, uint8_t *data, uint16_t len)
|
||
{
|
||
if (data == NULL || len == 0U) return -1;
|
||
_fifo_t *f = get_fifo_by_id(usart_num);
|
||
if (f == NULL) return -1;
|
||
return (int)fifo_read(f, data, len);
|
||
}
|
||
|
||
/**
|
||
* @brief 快速读取接口（当前复用普通读取实现）
|
||
* @param usart_num 串口编号
|
||
* @param data 读取目标缓冲区
|
||
* @param len 期望读取长度
|
||
* @retval >=0 实际读取长度；-1 参数或编号不支持
|
||
*/
|
||
int v_usart_read_rx_buffer_fast(uint8_t usart_num, uint8_t *data, uint16_t len)
|
||
{
|
||
return v_usart_read_rx_buffer(usart_num, data, len);
|
||
}
|
||
|
||
/**
|
||
* @brief 清空指定串口接收 FIFO
|
||
* @param usart_num 串口编号
|
||
* @retval 0 清空成功；-1 编号不支持
|
||
*/
|
||
int v_usart_clear_rx_buffer(uint8_t usart_num)
|
||
{
|
||
_fifo_t *f = get_fifo_by_id(usart_num);
|
||
if (f == NULL) return -1;
|
||
fifo_release(f);
|
||
switch (usart_num) {
|
||
case 0: fifo_register(f, s_uart0_rx_mem, UART0_RX_BUFFER_SIZE, NULL, NULL); break;
|
||
case 2: fifo_register(f, s_uart2_rx_mem, UART2_RX_BUFFER_SIZE, NULL, NULL); break;
|
||
case 3: fifo_register(f, s_uart3_rx_mem, UART3_RX_BUFFER_SIZE, NULL, NULL); break;
|
||
case 4: fifo_register(f, s_uart4_rx_mem, UART4_RX_BUFFER_SIZE, NULL, NULL); break;
|
||
case 5: fifo_register(f, s_uart5_rx_mem, UART5_RX_BUFFER_SIZE, NULL, NULL); break;
|
||
case 6: fifo_register(f, s_uart6_rx_mem, UART6_RX_BUFFER_SIZE, NULL, NULL); break;
|
||
case 7: fifo_register(f, s_uart7_rx_mem, UART7_RX_BUFFER_SIZE, NULL, NULL); break;
|
||
default: return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 对外统一二进制接收接口
|
||
* @param usart_id 串口ID
|
||
* @param u8_recvBuf 接收缓存
|
||
* @param u16_len 期望读取长度
|
||
* @retval 实际读取长度，失败返回0
|
||
*/
|
||
uint16_t u16_usart_recv(E_USART_ID usart_id ,uint8_t* u8_recvBuf ,uint16_t u16_len)
|
||
{
|
||
if(usart_id == E_USART_3)
|
||
{
|
||
//printf("\r\n");
|
||
}
|
||
int ret = v_usart_read_rx_buffer((uint8_t)usart_id, u8_recvBuf, u16_len);
|
||
if (ret <= 0) {
|
||
return 0U;
|
||
}
|
||
#if 1
|
||
{
|
||
uint8_t slot = usart_hw_num_to_slot((uint8_t)usart_id);
|
||
if ((ret > 0) && (slot < USART_NUM_PRINT_CNT) && (u8_uasrt_print[slot] != 0U)) {
|
||
usart_dump_line("recv", (uint8_t)usart_id, u8_recvBuf, (uint16_t)ret);
|
||
}
|
||
}
|
||
#endif
|
||
return (uint16_t)ret;
|
||
}
|
||
|
||
/**
|
||
* @brief 对外统一二进制发送接口
|
||
* @param usart_id 串口ID
|
||
* @param u8_sendBuf 发送缓存
|
||
* @param u16_len 待发送长度
|
||
* @retval 实际发送长度，失败返回0
|
||
*/
|
||
uint16_t u16_usart_send(E_USART_ID usart_id ,uint8_t* u8_sendBuf ,uint16_t u16_len)
|
||
{
|
||
int ret;
|
||
|
||
#if 1
|
||
{
|
||
uint8_t slot = usart_hw_num_to_slot((uint8_t)usart_id);
|
||
if ((u16_len > 0U) && (slot < USART_NUM_PRINT_CNT) && (u8_uasrt_print[slot] != 0U)) {
|
||
usart_dump_line("send", (uint8_t)usart_id, u8_sendBuf, u16_len);
|
||
}
|
||
}
|
||
#endif
|
||
ret = v_usart_send_data((uint8_t)usart_id, u8_sendBuf, u16_len);
|
||
if (ret < 0) {
|
||
return 0U;
|
||
}
|
||
return u16_len;
|
||
}
|
||
|
||
/**
|
||
* @brief 按串口编号打印格式化字符串
|
||
* @param usart_num 串口编号
|
||
* @param format 格式化字符串
|
||
* @param ... 可变参数
|
||
* @retval >0 输出长度；<=0 表示失败或无输出
|
||
*/
|
||
int v_usart_printf(uint8_t usart_num, const char *format, ...)
|
||
{
|
||
char buf[256];
|
||
va_list args;
|
||
va_start(args, format);
|
||
int n = vsnprintf(buf, sizeof(buf), format, args);
|
||
va_end(args);
|
||
if (n <= 0) return n;
|
||
if ((size_t)n >= sizeof(buf)) n = (int)(sizeof(buf) - 1U);
|
||
v_usart_send_data(usart_num, (uint8_t *)buf, (uint16_t)n);
|
||
return n;
|
||
}
|
||
|
||
void printf_hex(const char *mag , U8_T *data , U16_T len)
|
||
{
|
||
U16_T i;
|
||
const char *tag = (mag != NULL) ? mag : "";
|
||
|
||
if (data == NULL) {
|
||
printf("%s (00): <null>\r\n", tag);
|
||
return;
|
||
}
|
||
|
||
printf("%s (%02u): ", tag, (unsigned int)len);
|
||
for (i = 0U; i < len; i++) {
|
||
printf("%02X ", (unsigned int)data[i]);
|
||
}
|
||
printf("\r\n");
|
||
}
|
||
|
||
/**
|
||
* @brief printf 重定向接口，默认输出到 USART5
|
||
* @param ch 字符
|
||
* @param f 文件指针（未使用）
|
||
* @retval 原字符 ch
|
||
*/
|
||
int fputc(int ch, FILE *f)
|
||
{
|
||
(void)f;
|
||
uint8_t b = (uint8_t)ch;
|
||
uint32_t debug_periph;
|
||
|
||
if ((uint8_t)DEBUG_SHELL_USART_ID == (uint8_t)DEBUG_SHELL_USART_NULL) {
|
||
return ch;
|
||
}
|
||
|
||
debug_periph = usart_periph_from_id((uint8_t)DEBUG_SHELL_USART_ID);
|
||
if (debug_periph != 0U) {
|
||
usart_send_blocking(debug_periph, &b, 1U);
|
||
}
|
||
return ch;
|
||
}
|
||
|