[国产MCU]-BL602开发实例-UART数据发送与接收

          /** * @brief UART device type
           */
          typedef struct {
              uint8_t       port;			/**< @brief UART 端口（BL602中分别为UART0和UART1) */
              hosal_uart_config_t config;		/**< @brief UART 配置 */
              hosal_uart_callback_t tx_cb;		/**< @brief UART 发送完成中断回调函数 */
              void *p_txarg;				/**< @brief UART 发送完成回调函数参数 */
              hosal_uart_callback_t rx_cb;		/**< @brief UART 接收完成中断回调函数 */
              void *p_rxarg;				/**< @brief UART rx 接收完成中断回调函数函数 */
              hosal_uart_callback_t txdma_cb;		/**< @brief UART DMA方式发送完成中断回调函数 */
              void *p_txdma_arg;				/**< @brief UART DMA方式发送完成中断回调函数参数 */
              hosal_uart_callback_t rxdma_cb;		/**< @brief UART DMA方式接收完成中断回调函数 */
              void *p_rxdma_arg;				/**< @brief UART DMA方式接收完成中断回调函数 */
              hosal_dma_chan_t dma_tx_chan;		/**< @brief UART DMA发送通道 */
              hosal_dma_chan_t dma_rx_chan;		/**< @brief UART DMA接收通道 */
              void         *priv;			/**< @brief UART 用户自定义数据 */
          } hosal_uart_dev_t;

        typedef struct {

            uint8_t                   uart_id;	/**< @brief UART id */
            uint8_t                   tx_pin;		/**< @brief UART tx pin */
            uint8_t                   rx_pin;		/**< @brief UART rx pin */
            uint8_t                   cts_pin;	/**< @brief UART cts pin */
            uint8_t                   rts_pin;	/**< @brief UART rts pin */
            uint32_t                  baud_rate;	/**< @brief UART baud rate */
            hosal_uart_data_width_t   data_width;	/**< @brief UART data width */
            hosal_uart_parity_t       parity;		/**< @brief UART parity bit */
            hosal_uart_stop_bits_t    stop_bits;	/**< @brief UART stop btis */
            hosal_uart_flow_control_t flow_control;	/**< @brief UART flow control */
            hosal_uart_mode_t         mode;		/**< @brief UART int or pull mode */
        } hosal_uart_config_t;

          HOSAL_UART_BAUD_SET ：波特率设置，p_arg 为波特率

          HOSAL_UART_BAUD_GET : 波特率获取，p_arg 是波特率的指针
          HOSAL_UART_DATA_WIDTH_SET : 设置数据宽度，p_arg 为 hosal_uart_data_width_t
          HOSAL_UART_DATA_WIDTH_GET : 获取数据宽度，p_arg为hosal_uart_data_width_t的指针
          HOSAL_UART_STOP_BITS_SET ：设置停止位，p_arg为hosal_uart_stop_bits_t
          HOSAL_UART_STOP_BITS_GET ：获取停止位，p_arg是hosal_uart_stop_bits_t的指针
          HOSAL_UART_PARITY_SET ：设置奇偶校验，p_arg为hosal_uart_parity_t
          HOSAL_UART_PARITY_GET ：获取奇偶校验，p_arg是hosal_uart_parity_t的指针
          HOSAL_UART_MODE_SET ：UART模式设置，p_arg为hosal_uart_mode_t
          HOSAL_UART_MODE_GET ：UART模式获取，p_arg是hosal_uart_mode_t的指针
          HOSAL_UART_FLOWMODE_SET ：UART流模式设置，p_arg为hosal_uart_flow_control_t
          HOSAL_UART_FLOWSTAT_GET ：UART流状态获取，p_arg是hosal_uart_flow_control_t的指针
          HOSAL_UART_FREE_TXFIFO_GET ：获取 uart 空闲 tx fifo 大小（字节）
          HOSAL_UART_FREE_RXFIFO_GET ：获取 uart 空闲 rx fifo 大小（字节）
          HOSAL_UART_FLUSH ：等待发送完成
          HOSAL_UART_TX_TRIGGER_ON ：UART TX 触发打开
          HOSAL_UART_TX_TRIGGER_OFF ：UART TX 触发关闭
          HOSAL_UART_DMA_CONFIG : p_arg 是 hosal_uart_dma_cfg_t 的指针
          HOSAL_UART_DMA_TX_START : UART DMA TX start trans p_arg 是 hosal_uart_dma_cfg_t 的指针
          HOSAL_UART_DMA_RX_START ：UART DMA RX 开始传输 p_arg 是 hosal_uart_dma_cfg_t 的指针

          HOSAL_UART_TX_CALLBACK

          HOSAL_UART_RX_CALLBACK
          HOSAL_UART_TX_DMA_CALLBACK
          HOSAL_UART_RX_DMA_CALLBACK

    #include <stdio.h>
    #include <string.h>
    #include <FreeRTOS.h>
    #include <task.h>
    #include <bl_gpio.h>
    #include <stdio.h>
    #include <hosal_gpio.h>
    #include <hosal_dma.h>
    #include <blog.h>
    #include <stdbool.h>
    #include <hosal_uart.h>
    
    #define TAG "uart_demo"
    
    // UART引脚
    #define RX_PIN 4
    #define TX_PIN 3
    
    // 创建UART配置
    HOSAL_UART_DEV_DECL(uart_dev_int, 1, TX_PIN, RX_PIN, 115200);
    
    static void uart_init(void){
    uart_dev_int.config.uart_id = 1;
    /* 初始化UART */
    hosal_uart_init(&uart_dev_int);
    
    /* UART配置为轮询模式 */
    hosal_uart_ioctl(&uart_dev_int, HOSAL_UART_MODE_SET, (void *)HOSAL_UART_MODE_POLL);
    
    }
    
    static void uart_task(void* params){
    uart_init();
    uint8_t data[32];
    int ret;
    printf("uart task inited\r\n");
    hosal_uart_send(&uart_dev_int, "hello,uart1 demo\r\n",18);
    while(true){
        memset(data,0,32);
        ret = hosal_uart_receive(&uart_dev_int, data, sizeof(data));
        if (ret > 0) {
            /* Uart send poll */
            hosal_uart_send(&uart_dev_int, data, ret);
            data[ret - 1] = '\0';
            printf("recv:%s\r\n",data);
        }
        vTaskDelay(1);
    }
    
    }
    
    void main(void) {
    printf("uart demo inited\r\n");
    xTaskCreate(uart_task, "uart_task", 1024, NULL, 15, NULL);
    }

    static int __uart_tx_callback(void *p_arg)
    {
    static uint8_t tx_counts = 0;
    char buf[] = "TX interrupt TEST\r\n";
    hosal_uart_dev_t *p_dev = (hosal_uart_dev_t *)p_arg;
    
    if (tx_counts < sizeof(buf)) {
        hosal_uart_send(p_dev, &buf[tx_counts++], 1);
    } else {
        /*如果数据传输完成，关闭TX触发模式 */
        hosal_uart_ioctl(p_dev, HOSAL_UART_TX_TRIGGER_OFF, NULL);
    }
    
    return 0;
    }

    static int __uart_rx_callback(void *p_arg)
    {
    int ret;
    
    hosal_uart_dev_t *p_dev = (hosal_uart_dev_t *)p_arg;
    
    ret = hosal_uart_receive(p_dev, data_buf, RX_DATA_SIZE);
    hosal_uart_send(p_dev, data_buf, ret);
    
    return 0;
    }

    static void uart_init(void){
    uart_dev_int.config.uart_id = 1;
    
    /* 初始化UART */
    hosal_uart_init(&uart_dev_int);
    
    /* UART配置为中断模式 */
     hosal_uart_ioctl(&uart_dev_int, HOSAL_UART_MODE_SET, (void *)HOSAL_UART_MODE_INT);
    
    
    /* 设置接收和发送中断回调函数 */
     hosal_uart_callback_set(&uart_dev_int, HOSAL_UART_RX_CALLBACK,
                           __uart_rx_callback, &uart_dev_int);
     hosal_uart_callback_set(&uart_dev_int, HOSAL_UART_TX_CALLBACK,
                           __uart_tx_callback, &uart_dev_int);
    
    /*启用发送中断 */
     hosal_uart_ioctl(&uart_dev_int, HOSAL_UART_TX_TRIGGER_ON, NULL);
    /*启用接收中断 */
     hosal_uart_ioctl(&uart_dev_int, HOSAL_UART_RX_TRIGGER_ON, NULL);
    }

    static void uart_task(void* params) {
    uart_init();
    printf("uart task start\r\n");
    hosal_uart_send(&uart_dev_int, "hello,uart1 demo\r\n", 18);
    while (true) {
       
        vTaskDelay(1);
    }
    
    }

    void main(void) {
    printf("start to init uart...\r\n");
    xTaskCreate(uart_task, "uart_task", 1024, NULL, 15, NULL);
    }

    #include <stdio.h>
    #include <string.h>
    #include <FreeRTOS.h>
    #include <task.h>
    #include <bl_gpio.h>
    #include <stdio.h>
    #include <hosal_gpio.h>
    #include <hosal_dma.h>
    #include <blog.h>
    #include <stdbool.h>
    #include <hosal_uart.h>
    
    #define RX_PIN 4
    #define TX_PIN 3
    
    #define TAG "uart_dma_demo"
    
    #define RX_DATA_SIZE 16
    
    HOSAL_UART_DEV_DECL(uart_dev, 1, TX_PIN, RX_PIN, 115200);
    
    static uint8_t rx_data_buffer[RX_DATA_SIZE + 1];
    static uint8_t tx_data_buffer[RX_DATA_SIZE + 1];
    
    static bool is_rx_done = false;
    
    static hosal_uart_dma_cfg_t txdam_cfg = {
       .dma_buf = tx_data_buffer,
       .dma_buf_size = RX_DATA_SIZE,
    };
    static hosal_uart_dma_cfg_t rxdam_cfg = {
    .dma_buf = rx_data_buffer,
    .dma_buf_size = RX_DATA_SIZE,
    };
    
    /** * hal uart DMA RX interrupt callback
     */
    static int __uart_rx_dma_callback(void* p_arg) {
    /** * If RX transmission is completed
     * g_rx_buf is received data
     */
    printf("dma recv:%s\r\n", rx_data_buffer);
    memcpy(tx_data_buffer, rx_data_buffer, RX_DATA_SIZE);
    hosal_uart_ioctl(&uart_dev, HOSAL_UART_DMA_TX_START, &txdam_cfg);
    is_rx_done = true;
    return 0;
    }
    
    /** * hal uart DMA TX interrupt callback
     */
    static int __uart_tx_dma_callback(void* p_arg) {
    /* If TX transmission is completed */
    is_rx_done = false;
    memset(rx_data_buffer, 0, RX_DATA_SIZE);
    memset(tx_data_buffer, 0, RX_DATA_SIZE);
    // 重新启动TX DMA接收
    hosal_uart_ioctl(&uart_dev, HOSAL_UART_DMA_RX_START, &rxdam_cfg);
    return 0;
    }
    
    void uart_init(void) {
    
    uart_dev.config.uart_id = 1;
    
    /* 初始化UART设备 */
    hosal_uart_init(&uart_dev);
    
    /* 配置UART为中断模式 */
    hosal_uart_ioctl(&uart_dev, HOSAL_UART_MODE_SET, (void*)HOSAL_UART_MODE_INT);
    
    /* 设置 DMA RX TX中断回调函数 */
    hosal_uart_callback_set(&uart_dev, HOSAL_UART_TX_DMA_CALLBACK,
        __uart_tx_dma_callback, &uart_dev);
    hosal_uart_callback_set(&uart_dev, HOSAL_UART_RX_DMA_CALLBACK,
        __uart_rx_dma_callback, &uart_dev);
    
    /* 启动UART TX DMA 传输 */
    //hosal_uart_ioctl(&uart_dev, HOSAL_UART_DMA_TX_START, &txdam_cfg);
    
    /* 启动 UART RX DMA 传输 */
    hosal_uart_ioctl(&uart_dev, HOSAL_UART_DMA_RX_START, &rxdam_cfg);
    
    }
    
    static void uart_task(void* params) {
    uart_init();
    printf("uart task start\r\n");
    hosal_uart_send(&uart_dev, "hello,uart1 dma demo\r\n", 22);
    while (true) {
        
        vTaskDelay(1);
    }
    
    }
    
    void main(void) {
    hosal_dma_init();
    printf("start to init uart...\r\n");
    xTaskCreate(uart_task, "uart_task", 1024, NULL, 15, NULL);
    }