wangyan/CCU621M
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: CCU621_M firmware project with BLE debug link support.

Browse Source 
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jiankalka
2026-07-08 17:28:36 +08:00
commit 9ceb218f80
1597 changed files with 724159 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
BSP/com/usart.c
+715
View File
@@ -0,0 +1,715 @@
/*!
\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;
}
BSP/com/usart.h
+68
View File
@@ -0,0 +1,68 @@
/*!
\file usart.h
\brief the header file of USART
\version 2025-01-24, V1.4.0, firmware for GD32H7xx
*/
/*
Copyright (c) 2025, GigaDevice Semiconductor Inc.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
#ifndef USART_H
#define USART_H
#include <stdint.h>
#include "main.h"
#include "publicdata/public_define.h"
typedef enum{
E_USART_0 = 0,
E_USART_2 = 2,
E_USART_3 = 3,
E_USART_4 = 4,
E_USART_5 = 5,
E_USART_6 = 6,
E_USART_7 = 7
}E_USART_ID;
/* 批量初始化所有串口 */
int v_usart_init_all(void);
/* 兼容层原子接口（meter_coll_task 等模块直接调用） */
int v_usart_send_data(uint8_t usart_num, uint8_t *data, uint16_t len);
int v_usart_read_rx_buffer(uint8_t usart_num, uint8_t *data, uint16_t len);
/* 对外二进制收发统一接口 */
uint16_t u16_usart_recv(E_USART_ID usart_id ,uint8_t* u8_recvBuf ,uint16_t u16_len);
uint16_t u16_usart_send(E_USART_ID usart_id ,uint8_t* u8_sendBuf ,uint16_t u16_len);
void printf_hex(const char *mag , U8_T *data , U16_T len);
/* Shell: usart_printf <slot 0~6> <0|1> 对应物理口 USART0,USART2,3,4,5,6,7；与 CCU601E_D 行为一致，按 slot 下标。 */
#define USART_NUM_PRINT_CNT (7U)
extern U8_T u8_uasrt_print[USART_NUM_PRINT_CNT];
#endif /* USART_H */