• ESP32——串口通讯应用实例

    一、简述

    串口通讯为RS232通讯，接收采用中断方式（数据处理是消息队列+消息缓冲区），发送是查询方式（利用通知确定要发送的数据内容）。

    本程序参考乐鑫官方示例，但做了如下修改：

    1. 采用消息缓冲区进行接收数据处理，是因为当数据较长时接收中断并不能一次接收到一帧完整数据（取决于默认设置）。

    2. 采用通知实现发送数据内容选择，是为了更高效的对发送进行控制。

    二、代码

    首先在一个公共头文件def.h声明一个通知变量，为的是在主函数中发送通知给串口处理源文件的发送任务函数。

    extern TaskHandle_t UartTxTask_NotifyHandle;

    串口处理头文件uhf.h中内容。

    1. #define UART_UHF UART_NUM_2
    2.  
    3. esp_err_t uart2_init(int baud,int bufSize);

    串口处理源文件uhf.c中变量定义部分

    1. static const char *UART2_TAG = "uart2_events";
    2.  
    3. static QueueHandle_t uart2_rx_queue;
    4. static uint8_t uart2_send_buf[512]={1,2,3,4,5,6,7,8};
    5. static uint8_t uart2_recv_buf[512];
    6. static int uart2_sendnum;
    7. static int uart2_recvnum;
    8.  
    9. static MessageBufferHandle_t uart2_MsgBufHandle;
    10.  
    11. TaskHandle_t UartTxTask_NotifyHandle;

    串口处理源文件uhf.c中实现串口初始化和发送接收任务创建部分

    1.  
    2.  
    3. //-------------------------串口2初始化---------------------------
    4. esp_err_t uart2_init(int baud,int bufSize)
    5. {
    6.     esp_log_level_set(UART2_TAG, ESP_LOG_INFO);
    7.  
    8.     /* Configure parameters of an UART driver,
    9.      * communication pins and install the driver */
    10.     uart_config_t uart_config = {
    11.         .baud_rate = baud,
    12.         .data_bits = UART_DATA_8_BITS,
    13.         .parity = UART_PARITY_DISABLE,
    14.         .stop_bits = UART_STOP_BITS_1,
    15.         .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
    16.         .source_clk = UART_SCLK_APB,
    17.     };
    18.     //Install UART driver, and get the queue.
    19.     uart_driver_install(UART_UHF, bufSize * 2, bufSize * 2, 20, &uart2_rx_queue, 0);
    20.     uart_param_config(UART_UHF, &uart_config);
    21.  
    22.     //Set UART log level
    23.     esp_log_level_set(UART2_TAG, ESP_LOG_INFO);
    24.     //Set UART pins 
    25.     uart_set_pin(UART_UHF, 21, 19, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
    26.     //Reset the pattern queue length to record at most 20 pattern positions.
    27.     uart_pattern_queue_reset(UART_UHF, 20);
    28.  
    29.     uart_enable_rx_intr(UART_UHF);
    30.     //创建发送和接收任务
    31.     uart2_MsgBufHandle = xMessageBufferCreate(1500);
    32.     if(uart2_MsgBufHandle != NULL){   
    33.         xTaskCreate(uart2_event_task, "uart2_event_task", bufSize*2, NULL, configMAX_PRIORITIES-1, NULL);
    34.         xTaskCreate(uart2_rx_task, "uart2_rx_task", bufSize*2, NULL, configMAX_PRIORITIES-3, NULL);
    35.         xTaskCreate(uart2_tx_task, "uart2_tx_task", bufSize*2, NULL, configMAX_PRIORITIES-5, &UartTxTask_NotifyHandle); 
    36.     }  
    37.     return ESP_OK; 
    38. }

    串口处理源文件uhf.c中接收中断处理和数据缓存和解析，根据通讯协议确定接收数据是否完成和正确（协议不同处理方式需做相应调整）。

    1. //-------------------------串口2接收任务---------------------------
    2. static void uart2_rx_task(void *arg)
    3. {
    4.     static const char *TX_TASK_TAG = "TX_TASK";
    5.     int len = 0;
    6.     uint16_t crc;
    7.     int num;
    8.     static uint8_t frame_buf[512];
    9.     static int frame_header = 0;
    10.     BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    11.  
    12.     esp_log_level_set(TX_TASK_TAG, ESP_LOG_INFO);
    13.     while (1) {
    14.         vTaskDelay(10 / portTICK_PERIOD_MS);
    15.         num = xMessageBufferReceiveFromISR(uart2_MsgBufHandle,frame_buf,sizeof(frame_buf),&xHigherPriorityTaskWoken);       
    16.         datacopy(&uart2_recv_buf[uart2_recvnum],frame_buf,num); 
    17.         uart2_recvnum += num; 
    18.         //接收数据长度需满足最小要求    
    19.         if((uart2_recvnum-frame_header) < 9) continue;
    20.         //定位帧头位置
    21.         if(uart2_recv_buf[frame_header] != 0x5A){
    22.             frame_header++;
    23.             continue;
    24.         }
    25.         //找到了正取的帧头，然后需要判断是否是一组完整的数据帧，CRC校验是否正确
    26.         len = uart2_recv_buf[frame_header+5]*256 + uart2_recv_buf[frame_header+6];
    27.         if((uart2_recvnum-frame_header) >= (len + 9))
    28.         {
    29.             // if(DEBUG_ON) printf("uart2 recv end,data len = %4d \r\n", uart2_recvnum);
    30.             // for(int i=0;i
    31.             crc = crc16_CCITT(&uart2_recv_buf[frame_header+1],len + 9-3);
    32.             if((((crc & 0xff00)>>8) != uart2_recv_buf[len + 9-2]) || ((crc & 0x00ff) != uart2_recv_buf[len + 9-1]))
    33.             {
    34.                 frame_header++;
    35.                 if(DEBUG_ON) printf("uart2 crc error!\r\n");
    36.             }
    37.             else//找到正取的数据帧
    38.             {
    39.                 datacopy(frame_buf,&uart2_recv_buf[frame_header],len + 9);
    40.                 uart2_recvnum = uart2_recvnum - frame_header - len - 9;
    41.                 if(uart2_recvnum > 0) datacopy(uart2_recv_buf,&uart2_recv_buf[frame_header+len + 9],uart2_recvnum);
    42.                 //处理接收到的数据
    43.                 frame_handing(frame_buf);
    44.                                                             
    45.             }
    46.         }      
    47.     }
    48. }
    49. //-------------------------串口2接收事件---------------------------
    50. static void uart2_event_task(void *pvParameters)
    51. {
    52.     uart_event_t event;
    53.     BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    54.  
    55.     uint8_t* dtmp = (uint8_t*) malloc(256);
    56.     for(;;) {
    57.         //Waiting for UART event.
    58.         if(xQueueReceive(uart2_rx_queue, (void * )&event, (portTickType)portMAX_DELAY)) {
    59.             bzero(dtmp, 256);
    60.             // if(DEBUG_ON) ESP_LOGI(UART2_TAG, "uart[%d] event:", UART_UHF);
    61.             switch(event.type) {
    62.                 //Event of UART receving data
    63.                 /*We'd better handler data event fast, there would be much more data events than
    64.                 other types of events. If we take too much time on data event, the queue might
    65.                 be full.*/
    66.                 case UART_DATA:
    67.                     // if(DEBUG_ON) ESP_LOGI(UART2_TAG, "[UART event DATA]: %d", event.size);
    68.                     uart_read_bytes(UART_UHF, dtmp, event.size, portMAX_DELAY);
    69.                     //xMessageBufferSend(MsgBufHandle,dtmp,event.size, portMAX_DELAY);
    70.                     xMessageBufferSendFromISR(uart2_MsgBufHandle,dtmp,event.size, &xHigherPriorityTaskWoken);
    71.                     break;
    72.                 //Event of HW FIFO overflow detected
    73.                 case UART_FIFO_OVF:
    74.                     if(DEBUG_ON) ESP_LOGI(UART2_TAG, "hw fifo overflow");
    75.                     // If fifo overflow happened, you should consider adding flow control for your application.
    76.                     // The ISR has already reset the rx FIFO,
    77.                     // As an example, we directly flush the rx buffer here in order to read more data.
    78.                     uart_flush_input(UART_UHF);
    79.                     xQueueReset(uart2_rx_queue);
    80.                     break;
    81.                 //Event of UART ring buffer full
    82.                 case UART_BUFFER_FULL:
    83.                     if(DEBUG_ON) ESP_LOGI(UART2_TAG, "ring buffer full");
    84.                     // If buffer full happened, you should consider encreasing your buffer size
    85.                     // As an example, we directly flush the rx buffer here in order to read more data.
    86.                     uart_flush_input(UART_UHF);
    87.                     xQueueReset(uart2_rx_queue);
    88.                     break;
    89.                 //Event of UART RX break detected
    90.                 case UART_BREAK:
    91.                     if(DEBUG_ON) ESP_LOGI(UART2_TAG, "uart rx break");
    92.                     break;
    93.                 //Event of UART parity check error
    94.                 case UART_PARITY_ERR:
    95.                     if(DEBUG_ON) ESP_LOGI(UART2_TAG, "uart parity error");
    96.                     break;
    97.                 //Event of UART frame error
    98.                 case UART_FRAME_ERR:
    99.                     if(DEBUG_ON) ESP_LOGI(UART2_TAG, "uart frame error");
    100.                     break;
    101.                 default:
    102.                     if(DEBUG_ON) ESP_LOGI(UART2_TAG, "uart event type: %d", event.type);
    103.                     break;
    104.             }
    105.         }
    106.     }
    107.     free(dtmp);
    108.     dtmp = NULL;
    109.     vTaskDelete(NULL);
    110. }

    串口处理源文件uhf.c中发送处理

    1. //-------------------------串口2发送任务---------------------------
    2. static void uart2_tx_task(void *arg)
    3. {
    4.     static const char *TX_TASK_TAG = "TX_TASK";
    5.     uint32_t ulNotifiedValue = 0;
    6.     esp_log_level_set(TX_TASK_TAG, ESP_LOG_INFO);
    7.     while (1) {              
    8.         vTaskDelay(10 / portTICK_PERIOD_MS); 
    9.         xTaskNotifyWait(0, ULONG_MAX,&ulNotifiedValue, pdMS_TO_TICKS(0));         
    10.         if((ulNotifiedValue & 0x0100) == 0x0100)//停止
    11.         {            
    12.             stop();
    13.             uart_write_bytes(UART_UHF, uart2_send_buf, uart2_sendnum);
    14.             if(DEBUG_ON) printf("Send stop to UHF!\n");
    15.         }
    16.         else if((ulNotifiedValue & 0x0200) == 0x0200)//读TID
    17.         {            
    18.             stop();
    19.             uart_write_bytes(UART_UHF, uart2_send_buf, uart2_sendnum);
    20.             vTaskDelay(50 / portTICK_PERIOD_MS);//发送间隔
    21.             read_tid();
    22.             uart_write_bytes(UART_UHF, uart2_send_buf, uart2_sendnum);
    23.             if(DEBUG_ON) printf("Send read TID to UHF!\n");          
    24.         }  
    25.                                     
    26.         ulNotifiedValue = 0;                        
    27.     }
    28. }

    main.c文件中主函数

    1. void app_main(void)
    2. {
    3.     uart2_init(115200,2048);
    4.     read = 1;
    5.     while (1)
    6.     {
    7.         vTaskDelay(5000 / portTICK_PERIOD_MS);
    8.         if(read){
    9.             read = 0;
    10.             xTaskNotify(UartTxTask_NotifyHandle,0x0200,eSetBits);//读TID
    11.         }
    12.         else{
    13.             read = 1;
    14.             xTaskNotify(UartTxTask_NotifyHandle,0x0100,eSetBits);//停止
    15.         }
    16.     }
    17. }
  • 相关阅读:
    pandas使用str函数和contains函数删除dataframe中单个指定字符串数据列包含特定字符串列表中的其中任何一个字符串的数据行
    垃圾回收之G1收集过程
    【云计算网络安全】僵尸网络详解：工作原理、控制和保护方法
    ARM 架构是什么？
    布谷蓝途：易知微「可视大脑助力智慧教育」主题分享精彩实录
    计算机专业英语词汇
    设备的分配与回收（考虑因素，数据结构，分配步骤）
    Move 双子星之一 Sui 生态有哪些项目值得关注
    MapReduce框架原理
    【星球】【slam】研讨会（4）你真的适合读博吗？
  • 原文地址：https://blog.csdn.net/tsliuch/article/details/125887650