【Linux开发】串口接收不定长数据，接收中断+超时判断方案

/*
 * uart interrupt source register bits definition
 */
#define UIS_TX_FIFO_EMPTY       (1UL<<0)
#define UIS_TX_FIFO             (1UL<<1)
#define UIS_RX_FIFO             (1UL<<2)
#define UIS_RX_FIFO_TIMEOUT     (1UL<<3)
#define UIS_CTS_CHNG            (1UL<<4)
#define UIS_BREAK               (1UL<<5)
#define UIS_FRM_ERR             (1UL<<6)
#define UIS_PARITY_ERR          (1UL<<7)
#define UIS_OVERRUN             (1UL<<8)

// 存储接收到的数据
char rx_fifo_buf[1024] = {0};
// 存储收到数据的长度
uint16_t rx_length = 0;
// 定义一个信号量
tls_os_sem_t *sem_rx = NULL;

// 接收回调函数
s16 uart1_rx_callback(u16 len, void *user_data)
{
    // 将接收到字符累加
    rx_length += len;
    tls_os_sem_release(sem_rx);
    return WM_SUCCESS;
}

// 串口初始化
void uart1_init()
{
    // 初始化uart1引脚，函数内部会自动开启串口时钟，
    wm_uart1_rx_config(WM_IO_PB_07);
    wm_uart1_tx_config(WM_IO_PB_06);

    // 配置uart参数
    tls_uart_options_t opt;
    opt.baudrate = UART_BAUDRATE_B115200;     // 波特率
    opt.paritytype = TLS_UART_PMODE_DISABLED; // 无奇偶校验
    opt.stopbits = TLS_UART_ONE_STOPBITS;     // 一个停止位
    opt.charlength = TLS_UART_CHSIZE_8BIT;    // 数据长度
    opt.flow_ctrl = TLS_UART_FLOW_CTRL_NONE;  // 没有流控制

    // 初始化串口,这个函数内部会开启串口中断
    // 当第二个参数为NULL的时候，串口会按默认参数初始化这个串口，具体请看SDK函数tls_uart_port_init的实现
    if (WM_SUCCESS != tls_uart_port_init(TLS_UART_1, &opt, 0))
    {
        printf("uart1 init error\n");
    }

    // 另一种方式初始化串口：使用默认方式初始化，在定制参数。默认初始化可能不符合要求，那么就用sdk来修改uart参数
    // if (WM_SUCCESS != tls_uart_port_init(TLS_UART_1, NULL, 0))
    // {
    //     printf("uart1 init error\n");
    // }
    // tls_uart_set_baud_rate(TLS_UART_1, UART_BAUDRATE_B9600)//波特率
    // tls_uart_set_parity(TLS_UART_1, TLS_UART_PMODE_DISABLED);//无奇偶校验
    // tls_uart_set_stop_bits(TLS_UART_1, TLS_UART_ONE_STOPBITS);//一个停止位

    // 为串口绑定接收回调函数
    tls_uart_rx_callback_register((u16)TLS_UART_1, (s16(*)(u16, void *))uart1_rx_callback, NULL);
}

#define UART_RX_INT_FLAG (UIS_RX_FIFO | UIS_RX_FIFO_TIMEOUT | UIS_BREAK |\
        UIS_OVERRUN | UIS_FRM_ERR | UIS_PARITY_ERR)
#define UART_RX_ERR_INT_FLAG (UIS_BREAK | UIS_FRM_ERR | \
        UIS_PARITY_ERR)

#define UART_TX_INT_FLAG (UIS_TX_FIFO | UIS_TX_FIFO_EMPTY)

ATTRIBUTE_ISR void UART1_IRQHandler(void)
{
    struct tls_uart_port *port = &uart_port[1];
    struct tls_uart_circ_buf *recv = &port->recv;
    u8 rx_byte_cb_flag = uart_rx_byte_cb_flag[1];
    u32 intr_src;
    u32 rx_fifocnt;
    u32 fifos;
    u8 ch = 0;
    u8 escapefifocnt = 0;
    u32 rxlen = 0;
    csi_kernel_intrpt_enter();

    intr_src = port->regs->UR_INTS;
	
    if ((intr_src & UIS_RX_FIFO) && (0 == (port->regs->UR_INTM & UIS_RX_FIFO)))
    {
	    // 处理接收中断
        rx_fifocnt = (port->regs->UR_FIFOS >> 6) & 0x3F; // 从UART FIFO状态寄存器读取数据个数
        escapefifocnt = rx_fifocnt;
        port->plus_char_cnt = 0;
        rxlen = rx_fifocnt;
        
        // 检查环形缓冲区`recv`的可用空间是否小于或等于`RX_CACHE_LIMIT`。如果是，则更新缓冲区尾部指针以限制接收的数据量。
        if (CIRC_SPACE(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE) <= RX_CACHE_LIMIT)
        {
            recv->tail = (recv->tail + RX_CACHE_LIMIT) & (TLS_UART_RX_BUF_SIZE - 1);
        }
        
        while (rx_fifocnt-- > 0)
        {
	        // UR_RXW是UART RX 起始地址寄存器，读取接收数据存入缓存区
            ch = (u8) port->regs->UR_RXW;
            recv->buf[recv->head] = ch; // 将接收到的字符`ch`存储到环形缓存区`recv->buf`的头部位置。
            recv->head = (recv->head + 1) & (TLS_UART_RX_BUF_SIZE - 1); // 更新环形缓存区的头部指针，准备下一次数据存储。
        }

		// 调用接收回调函数
        if (port->rx_callback!=NULL && !rx_byte_cb_flag)
        {
            port->rx_callback(rxlen, port->priv_data); // 传递接收到的数据长度，和私有数据（这里并没有使用）
        }
    }
    
    csi_kernel_intrpt_exit();	
}

// uart线程
void uart1_task(void *sdata)
{
    uint16_t rx_len = 0;
    // 用于判断信号量是否成功获取
    tls_os_status_t os_status = TLS_OS_ERROR;
    // 创建信号量，用于回调函数和线程之间通信
    tls_os_sem_create(&sem_rx, 0);
    // 初始化串口
    uart1_init();

    for (;;)
    {
        os_status = tls_os_sem_acquire(sem_rx, 20); // 等待信号量到来,等待20个系统时钟周期
        // 若发生错误（不为0），即在20个周期内未收到sem_rx信号，这表示这个串口在20个时钟周期内没有收到数据，接收超时，已收到一个完整帧
        if (os_status)
        {
            // 如果串口有数据，表示一个包已经接收完了。
            if (rx_length > 0)
            {
                // 读出这个包的数据，注意这个包不能超过1024个字节
                rx_len = tls_uart_read(TLS_UART_1, rx_fifo_buf, rx_length);
                rx_length = 0;
                tls_uart_write(TLS_UART_1, rx_fifo_buf, rx_len); // 发送
            }
        }
    }
}