From 8d6b78232728d7a987a2cae690fdd820cf8cf36a Mon Sep 17 00:00:00 2001 From: Wangjialin Date: Tue, 1 Nov 2016 09:22:09 +0800 Subject: [PATCH] Modify UART driver: 1. Add a ring buffer for UART TX. If the buffer size is set to zero, driver will not use a buffer. But we need a task to send data from buffer to fifo. I tried directly copy data in ISR, but the code looked too long for ISR. 2. Modify the format in uart.h --- components/driver/include/driver/uart.h | 706 +++++++++++++----------- components/driver/uart.c | 421 ++++++++------ 2 files changed, 630 insertions(+), 497 deletions(-) diff --git a/components/driver/include/driver/uart.h b/components/driver/include/driver/uart.h index dafdf54a84..3ea77b2d02 100644 --- a/components/driver/include/driver/uart.h +++ b/components/driver/include/driver/uart.h @@ -24,175 +24,168 @@ extern "C" { #include "soc/uart_struct.h" #include "esp_err.h" #include "driver/periph_ctrl.h" +#include "freertos/FreeRTOS.h" +#include "freertos/semphr.h" +#include "freertos/xtensa_api.h" +#include "freertos/task.h" +#include "freertos/queue.h" +#include "freertos/ringbuf.h" #include extern const char* UART_TAG; #define UART_FIFO_LEN (128) //Do not change this, this value describes the length of the gardware FIFO in the ESP32 #define UART_INTR_MASK 0x1ff #define UART_LINE_INV_MASK (0x3f << 19) +#define UART_BITRATE_MAX 5000000 typedef enum { - UART_DATA_5_BITS = 0x0, //word length: 5bits - UART_DATA_6_BITS = 0x1, //word length: 6bits - UART_DATA_7_BITS = 0x2, //word length: 7bits - UART_DATA_8_BITS = 0x3, //word length: 8bits + UART_DATA_5_BITS = 0x0, /*!< word length: 5bits*/ + UART_DATA_6_BITS = 0x1, /*!< word length: 6bits*/ + UART_DATA_7_BITS = 0x2, /*!< word length: 7bits*/ + UART_DATA_8_BITS = 0x3, /*!< word length: 8bits*/ UART_DATA_MAX_BITS = 0X4, } uart_word_length_t; typedef enum { - UART_STOP_BITS_1 = 0x1, //stop bit: 1bit - UART_STOP_BITS_1_5 = 0x2, //stop bit: 1.5bits - UART_STOP_BITS_2 = 0x3, //stop bit: 2bits + UART_STOP_BITS_1 = 0x1, /*!< stop bit: 1bit*/ + UART_STOP_BITS_1_5 = 0x2, /*!< stop bit: 1.5bits*/ + UART_STOP_BITS_2 = 0x3, /*!< stop bit: 2bits*/ UART_STOP_BITS_MAX = 0x4, } uart_stop_bits_t; typedef enum { - UART_NUM_0 = 0x0, //base address 0x3ff40000 - UART_NUM_1 = 0x1, //base address 0x3ff50000 - UART_NUM_2 = 0x2, //base address 0x3ff6E000 + UART_NUM_0 = 0x0, /*!< UART base address 0x3ff40000*/ + UART_NUM_1 = 0x1, /*!< UART base address 0x3ff50000*/ + UART_NUM_2 = 0x2, /*!< UART base address 0x3ff6E000*/ UART_NUM_MAX, } uart_port_t; typedef enum { - UART_PARITY_DISABLE = 0x0, //Disable UART parity - UART_PARITY_EVEN = 0x10, //Enable UART even parity - UART_PARITY_ODD = 0x11 //Enable UART odd parity + UART_PARITY_DISABLE = 0x0, /*!< Disable UART parity*/ + UART_PARITY_EVEN = 0x10, /*!< Enable UART even parity*/ + UART_PARITY_ODD = 0x11 /*!< Enable UART odd parity*/ } uart_parity_t; typedef enum { - UART_BITRATE_300 = 300, - UART_BITRATE_600 = 600, - UART_BITRATE_1200 = 1200, - UART_BITRATE_2400 = 2400, - UART_BITRATE_4800 = 4800, - UART_BITRATE_9600 = 9600, - UART_BITRATE_19200 = 19200, - UART_BITRATE_38400 = 38400, - UART_BITRATE_57600 = 57600, - UART_BITRATE_74880 = 74880, - UART_BITRATE_115200 = 115200, - UART_BITRATE_230400 = 230400, - UART_BITRATE_460800 = 460800, - UART_BITRATE_921600 = 921600, - UART_BITRATE_1843200 = 1843200, - UART_BITRATE_3686400 = 3686400, - UART_BITRATE_MAX = 5000000, -} uart_baudrate_t; //you can set any rate you need in this range - -typedef enum { - UART_HW_FLOWCTRL_DISABLE = 0x0, //disable hardware flow control - UART_HW_FLOWCTRL_RTS = 0x1, //enable RX hardware flow control (rts) - UART_HW_FLOWCTRL_CTS = 0x2, //enable TX hardware flow control (cts) - UART_HW_FLOWCTRL_CTS_RTS = 0x3, //enable hardware flow control + UART_HW_FLOWCTRL_DISABLE = 0x0, /*!< disable hardware flow control*/ + UART_HW_FLOWCTRL_RTS = 0x1, /*!< enable RX hardware flow control (rts)*/ + UART_HW_FLOWCTRL_CTS = 0x2, /*!< enable TX hardware flow control (cts)*/ + UART_HW_FLOWCTRL_CTS_RTS = 0x3, /*!< enable hardware flow control*/ UART_HW_FLOWCTRL_MAX = 0x4, } uart_hw_flowcontrol_t; typedef enum { - UART_INVERSE_DISABLE = 0x0, //Disable UART wire output inverse - UART_INVERSE_RXD = (uint32_t)UART_RXD_INV_M, //UART RXD input inverse - UART_INVERSE_CTS = (uint32_t)UART_CTS_INV_M, //UART CTS input inverse - UART_INVERSE_TXD = (uint32_t)UART_TXD_INV_M, //UART TXD output inverse - UART_INVERSE_RTS = (uint32_t)UART_RTS_INV_M, //UART RTS output inverse + UART_INVERSE_DISABLE = 0x0, /*!< Disable UART wire output inverse*/ + UART_INVERSE_RXD = (uint32_t)UART_RXD_INV_M, /*!< UART RXD input inverse*/ + UART_INVERSE_CTS = (uint32_t)UART_CTS_INV_M, /*!< UART CTS input inverse*/ + UART_INVERSE_TXD = (uint32_t)UART_TXD_INV_M, /*!< UART TXD output inverse*/ + UART_INVERSE_RTS = (uint32_t)UART_RTS_INV_M, /*!< UART RTS output inverse*/ } uart_inverse_t; typedef struct { - uart_baudrate_t baud_rate; //UART baudrate - uart_word_length_t data_bits; //UART byte size - uart_parity_t parity; //UART parity mode - uart_stop_bits_t stop_bits; //UART stop bits - uart_hw_flowcontrol_t flow_ctrl; //UART hw flow control mode(cts/rts) - uint8_t rx_flow_ctrl_thresh ; //UART hw RTS threshold + int baud_rate; /*!< UART baudrate*/ + uart_word_length_t data_bits; /*!< UART byte size*/ + uart_parity_t parity; /*!< UART parity mode*/ + uart_stop_bits_t stop_bits; /*!< UART stop bits*/ + uart_hw_flowcontrol_t flow_ctrl; /*!< UART hw flow control mode(cts/rts)*/ + uint8_t rx_flow_ctrl_thresh ; /*!< UART hw RTS threshold*/ } uart_config_t; typedef struct { - uint32_t intr_enable_mask; //UART interrupt enable mask, choose from UART_XXXX_INT_ENA_M under UART_INT_ENA_REG(i), connect with bit-or operator - uint8_t rx_timeout_thresh; //UART timeout interrupt threshold(unit: time of sending one byte) - uint8_t txfifo_empty_intr_thresh; //UART TX empty interrupt threshold. - uint8_t rxfifo_full_thresh; //UART RX full interrupt threshold. + uint32_t intr_enable_mask; /*!< UART interrupt enable mask, choose from UART_XXXX_INT_ENA_M under UART_INT_ENA_REG(i), connect with bit-or operator*/ + uint8_t rx_timeout_thresh; /*!< UART timeout interrupt threshold(unit: time of sending one byte)*/ + uint8_t txfifo_empty_intr_thresh; /*!< UART TX empty interrupt threshold.*/ + uint8_t rxfifo_full_thresh; /*!< UART RX full interrupt threshold.*/ } uart_intr_config_t; - typedef enum { - UART_DATA, - UART_BREAK, - UART_BUFFER_FULL, - UART_FIFO_OVF, - UART_FRAME_ERR, - UART_PARITY_ERR, - UART_EVENT_MAX, + UART_DATA, /*!< UART data event*/ + UART_BREAK, /*!< UART break event*/ + UART_BUFFER_FULL, /*!< UART RX buffer full event*/ + UART_FIFO_OVF, /*!< UART FIFO overflow event*/ + UART_FRAME_ERR, /*!< UART RX frame error event*/ + UART_PARITY_ERR, /*!< UART RX parity event*/ + UART_DATA_BREAK, /*!< UART TX data and break event*/ + UART_EVENT_MAX, /*!< UART event max index*/ } uart_event_type_t; typedef struct { uart_event_type_t type; union { struct { + int brk_len; size_t size; + uint8_t data[]; } data; - }; } uart_event_t; - - /** * @brief Set UART data bits. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uart_word_length_t data_bit : UART data bits + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param data_bit UART data bits * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_set_word_length(uart_port_t uart_num, uart_word_length_t data_bit); /** * @brief Get UART data bits. * - * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_FAIL : Parameter error - * ESP_OK : Success, result will be put in (*data_bit) + * @return + * - ESP_FAIL Parameter error + * - ESP_OK Success, result will be put in (*data_bit) */ esp_err_t uart_get_word_length(uart_port_t uart_num, uart_word_length_t* data_bit); /** * @brief Set UART stop bits. * - * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uart_stop_bits_t bit_num : UART stop bits + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param bit_num UART stop bits * - * @return ESP_OK : Success - * ESP_FAIL: Fail + * @return + * - ESP_OK Success + * - ESP_FAIL Fail */ esp_err_t uart_set_stop_bits(uart_port_t uart_no, uart_stop_bits_t bit_num); /** * @brief Set UART stop bits. * - * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_FAIL : Parameter error - * ESP_OK : Success, result will be put in (*stop_bit) + * @return + * - ESP_FAIL Parameter error + * - ESP_OK Success, result will be put in (*stop_bit) */ esp_err_t uart_get_stop_bits(uart_port_t uart_num, uart_stop_bits_t* stop_bit); /** * @brief Set UART parity. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uart_parity_t parity_mode : the enum of uart parity configuration + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param parity_mode the enum of uart parity configuration * - * @return null + * @return + * - ESP_FAIL Parameter error + * - ESP_OK Success */ esp_err_t uart_set_parity(uart_port_t uart_no, uart_parity_t parity_mode); /** * @brief Get UART parity mode. * - * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_FAIL : Parameter error - * ESP_OK : Success, result will be put in (*parity_mode) + * @return + * - ESP_FAIL Parameter error + * - ESP_OK Success, result will be put in (*parity_mode) * */ esp_err_t uart_get_parity(uart_port_t uart_num, uart_parity_t* parity_mode); @@ -200,32 +193,37 @@ esp_err_t uart_get_parity(uart_port_t uart_num, uart_parity_t* parity_mode); /** * @brief Set UART baud rate. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uint32_t baud_rate : UART baud-rate, we can choose one from uart_baudrate_t, or set a value. + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param baud_rate UART baud-rate. * - * @return null + * @return + * - ESP_FAIL Parameter error + * - ESP_OK Success */ esp_err_t uart_set_baudrate(uart_port_t uart_no, uint32_t baud_rate); /** * @brief Get UART bit-rate. * - * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_FAIL : Parameter error - * ESP_OK : Success, result will be put in (*baudrate) + * @return + * - ESP_FAIL Parameter error + * - ESP_OK Success, result will be put in (*baudrate) * */ esp_err_t uart_get_baudrate(uart_port_t uart_num, uint32_t* baudrate); /** * @brief Set UART line inverse mode - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uint32_t inverse_mask : Choose the wires that need to be inversed - * (Should be chosen from uart_inverse_t, combine with OR-OPERATION) + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param inverse_mask Choose the wires that need to be inversed. + * + * (inverse_mask should be chosen from uart_inverse_t, combine with OR-OPERATION) * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_set_line_inverse(uart_port_t uart_no, uint32_t inverse_mask) ; @@ -233,57 +231,65 @@ esp_err_t uart_set_line_inverse(uart_port_t uart_no, uint32_t inverse_mask) ; /** * @brief Set hardware flow control. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uart_hw_flowcontrol_t flow_ctrl : Hardware flow control mode - * @param uint8_t rx_thresh : Threshold of Hardware RX flow control(0 ~ UART_FIFO_LEN) + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param flow_ctrl Hardware flow control mode + * @param rx_thresh Threshold of Hardware RX flow control(0 ~ UART_FIFO_LEN) * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_no, uart_hw_flowcontrol_t flow_ctrl, uint8_t rx_thresh); /** * @brief Get hardware flow control mode - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_FAIL : Parameter error - * ESP_OK : Success, result will be put in (*flow_ctrl) + * @return + * - ESP_FAIL Parameter error + * - ESP_OK Success, result will be put in (*flow_ctrl) */ esp_err_t uart_get_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t* flow_ctrl); /** * @brief Clear UART interrupt status * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uint32_t clr_mask : Bit mask of the status that to be cleared. - * enable_mask should be chosen from the fields of register UART_INT_CLR_REG + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param clr_mask Bit mask of the status that to be cleared. * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * (enable_mask should be chosen from the fields of register UART_INT_CLR_REG) + * + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_clear_intr_status(uart_port_t uart_num, uint32_t clr_mask); /** * @brief Set UART interrupt enable * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uint32_t enable_mask : Bit mask of the enable bits. - * enable_mask should be chosen from the fields of register UART_INT_ENA_REG + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param enable_mask Bit mask of the enable bits. + * + * (enable_mask should be chosen from the fields of register UART_INT_ENA_REG) * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_enable_intr_mask(uart_port_t uart_num, uint32_t enable_mask); /** * @brief Clear UART interrupt enable bits * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uint32_t disable_mask : Bit mask of the disable bits. - * Disable_mask should be chosen from the fields of register UART_INT_ENA_REG + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param disable_mask Bit mask of the disable bits. * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * (disable_mask should be chosen from the fields of register UART_INT_ENA_REG) + * + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_disable_intr_mask(uart_port_t uart_num, uint32_t disable_mask); @@ -291,42 +297,46 @@ esp_err_t uart_disable_intr_mask(uart_port_t uart_num, uint32_t disable_mask); /** * @brief Enable UART RX interrupt(RX_FULL & RX_TIMEOUT INTERRUPT) * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_enable_rx_intr(uart_port_t uart_num); /** * @brief Disable UART RX interrupt(RX_FULL & RX_TIMEOUT INTERRUPT) * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_disable_rx_intr(uart_port_t uart_num); /** * @brief Disable UART TX interrupt(RX_FULL & RX_TIMEOUT INTERRUPT) * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_disable_tx_intr(uart_port_t uart_num); /** * @brief Enable UART TX interrupt(RX_FULL & RX_TIMEOUT INTERRUPT) * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param int enable : 1: enable; 0: disable - * @param int thresh : Threshold of TX interrupt, 0 ~ UART_FIFO_LEN + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param enable 1: enable; 0: disable + * @param thresh Threshold of TX interrupt, 0 ~ UART_FIFO_LEN * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_enable_tx_intr(uart_port_t uart_num, int enable, int thresh); @@ -337,29 +347,31 @@ esp_err_t uart_enable_tx_intr(uart_port_t uart_num, int enable, int thresh); * We can find the information of INUM and interrupt level in soc.h. * * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uint8_t uart_intr_num : UART interrupt number,check the info in soc.h, and please refer to core-isa.h for more details - * @param void (* fn)(void* ) : Interrupt handler function. - * Note that the handler function MUST be defined with attribution of "IRAM_ATTR" for now. - * @param void * arg : parameter for handler function + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_intr_num UART interrupt number,check the info in soc.h, and please refer to core-isa.h for more details + * @param fn Interrupt handler function. + * @attention + * The ISR handler function MUST be defined with attribution of "IRAM_ATTR" for now. + * @param arg parameter for handler function * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_isr_register(uart_port_t uart_num, uint8_t uart_intr_num, void (*fn)(void*), void * arg); /** * @brief Set UART pin number * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param tx_io_num : UART TX pin GPIO number - * @param rx_io_num : UART RX pin GPIO number - * @param rts_io_num : UART RTS pin GPIO number - * @param cts_io_num : UART CTS pin GPIO number - * + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param tx_io_num UART TX pin GPIO number + * @param rx_io_num UART RX pin GPIO number + * @param rts_io_num UART RTS pin GPIO number + * @param cts_io_num UART CTS pin GPIO number * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int rts_io_num, int cts_io_num); @@ -367,97 +379,107 @@ esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int r * @brief UART set RTS level (before inverse) * UART rx hardware flow control should not be set. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param int level : 1: RTS output low(active) - * 0: RTS output high(block) + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param level 1: RTS output low(active); 0: RTS output high(block) * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_set_rts(uart_port_t uart_num, int level); /** * @brief UART set DTR level (before inverse) * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param int level : 1: DTR output low - * 0: DTR output high + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param level 1: DTR output low; 0: DTR output high * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_set_dtr(uart_port_t uart_num, int level); /** * @brief UART parameter configure * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uart_config_t *uart_config: UART parameter settings + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_config UART parameter settings * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_param_config(uart_port_t uart_num, uart_config_t *uart_config); /** * @brief UART interrupt configure * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uart_intr_config_t *p_intr_conf: UART interrupt settings + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param p_intr_conf UART interrupt settings * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_intr_config(uart_port_t uart_num, uart_intr_config_t *p_intr_conf); /** * @brief Install UART driver. + * * UART ISR handler will be attached to the same CPU core that this function is running on. * Users should know that which CPU is running and then pick a INUM that is not used by system. * We can find the information of INUM and interrupt level in soc.h. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param int buffer_size : UART ring buffer size - * @param int queue_size : UART event queue size/depth. - * @param int uart_intr_num : UART interrupt number,check the info in soc.h, and please refer to core-isa.h for more details + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param rx_buffer_size UART RX ring buffer size + * @param tx_buffer_size UART TX ring buffer size, if set to zero, driver will not use TX buffer and TX task. + * @param queue_size UART event queue size/depth. + * @param uart_intr_num UART interrupt number,check the info in soc.h, and please refer to core-isa.h for more details + * @param uart_queue UART event queue handle, if set NULL, driver will not use an event queue. + * @param buf_type UART RX ring_buffer type * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ -esp_err_t uart_driver_install(uart_port_t uart_num, int buffer_size, int queue_size, int uart_intr_num, void* uart_queue); +esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, int uart_intr_num, void* uart_queue, ringbuf_type_t rx_buf_type); /** * @brief Uninstall UART driver. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_driver_delete(uart_port_t uart_num); /** * @brief Wait UART TX FIFO empty * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param TickType_t ticks_to_wait: Timeout, count in RTOS ticks + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param ticks_to_wait Timeout, count in RTOS ticks * - * @return ESP_OK : Success - * ESP_FAIL : Parameter error - * ESP_ERR_TIMEOUT: Timeout + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error + * - ESP_ERR_TIMEOUT Timeout */ -esp_err_t uart_wait_tx_fifo_empty(uart_port_t uart_num, TickType_t ticks_to_wait); +esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait); /** * @brief Send data to the UART port from a given buffer and length, * This function will not wait for the space in TX FIFO, just fill the TX FIFO and return when the FIFO is full. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param char* buffer : data buffer address - * @param uint32_t len : data length to send + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param buffer data buffer address + * @param len data length to send * - * @return -1 : Parameter error - * OTHERS(>=0): The number of data that pushed to the TX FIFO + * @return + * - (-1) Parameter error + * - OTHERS(>=0) The number of data that pushed to the TX FIFO */ int uart_tx_chars(uart_port_t uart_no, char* buffer, uint32_t len); @@ -465,12 +487,13 @@ int uart_tx_chars(uart_port_t uart_no, char* buffer, uint32_t len); * @brief Send data to the UART port from a given buffer and length, * This function will not return until all the data have been sent out, or at least pushed into TX FIFO. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param char* src : data buffer address - * @param size_t size : data length to send + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param src data buffer address + * @param size data length to send * - * @return -1 : Parameter error - * OTHERS(>=0): The number of data that pushed to the TX FIFO + * @return + * - (-1) Parameter error + * - OTHERS(>=0) The number of data that pushed to the TX FIFO */ int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size); @@ -478,57 +501,62 @@ int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size); * @brief Send data to the UART port from a given buffer and length, * This function will not return until all the data and the break signal have been sent out. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param char* src : data buffer address - * @param size_t size : data length to send - * @param int brk_len : break signal length (unit: one bit's time@current_baudrate) + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param src data buffer address + * @param size data length to send + * @param brk_len break signal length (unit: one bit's time@current_baudrate) * - * @return -1 : Parameter error - * OTHERS(>=0): The number of data that pushed to the TX FIFO + * @return + * - (-1) Parameter error + * - OTHERS(>=0) The number of data that pushed to the TX FIFO */ int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len); /** * @brief UART read one char * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param TickType_t ticks_to_wait : Timeout, count in RTOS ticks + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param ticks_to_wait Timeout, count in RTOS ticks * - * @return -1 : Error - * Others : return a char data from UART. + * @return + * - (-1) Error + * - Others return a char data from UART. */ int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait); /** * @brief UART read bytes from UART buffer * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 - * @param uint8_t* buf : pointer to the buffer. - * @param uint32_t length : data length - * @param TickType_t ticks_to_wait: Timeout, count in RTOS ticks + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param buf pointer to the buffer. + * @param length data length + * @param ticks_to_wait: Timeout, count in RTOS ticks * - * @return -1 : Error - * Others : return a char data from uart fifo. + * @return + * - (-1) Error + * - Others return a char data from uart fifo. */ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait); /** * @brief UART ring buffer flush * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error */ esp_err_t uart_flush(uart_port_t uart_num); /** * @brief Set the serial output port for ets_printf function, not effective for ESP_LOGX macro. * - * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 + * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2 * - * @return ESP_OK : Success - * ESP_FAIL: Parameter error, or UART driver not installed. + * @return + * - ESP_OK Success + * - ESP_FAIL Parameter error, or UART driver not installed. */ esp_err_t uart_set_print_port(uart_port_t uart_no); @@ -536,141 +564,155 @@ esp_err_t uart_set_print_port(uart_port_t uart_no); * @brief Get the current serial port for ets_printf function * * - * @return current print port: 0: UART0; - * 1: UART1; - * 2: UART2; + * @return current print port(0: UART0; 1: UART1; 2: UART2) */ -int uart_get_print_port(); +int uart_get_print_port(void); /***************************EXAMPLE********************************** * * * ----------------EXAMPLE OF UART SETTING --------------------- - * //1. Setup UART - * #include "freertos/queue.h" - * #define UART_INTR_NUM 17 //choose one interrupt number from soc.h - * //a. Set UART parameter - * int uart_num = 0; //uart port number - * uart_config_t uart_config = { - * .baud_rate = UART_BITRATE_115200, //baudrate - * .data_bits = UART_DATA_8_BITS, //data bit mode - * .parity = UART_PARITY_DISABLE, //parity mode - * .stop_bits = UART_STOP_BITS_1, //stop bit mode - * .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, //hardware flow control(cts/rts) - * .rx_flow_ctrl_thresh = 120, //flow control threshold - * }; - * uart_param_config(uart_num, &uart_config); - * //b1. Setup UART driver(with UART queue) - * QueueHandle_t uart_queue; - * uart_driver_install(uart_num, 1024 * 2, 10, UART_INTR_NUM, &uart_queue);//parameters here are just an example - * //b2. Setup UART driver(without UART queue) - * uart_driver_install(uart_num, 1024 * 2, 10, UART_INTR_NUM, NULL); //parameters here are just an example - * + * @code{c} + * //1. Setup UART + * #include "freertos/queue.h" + * #define UART_INTR_NUM 17 //choose one interrupt number from soc.h + * //a. Set UART parameter + * int uart_num = 0; //uart port number + * uart_config_t uart_config = { + * .baud_rate = UART_BITRATE_115200, //baudrate + * .data_bits = UART_DATA_8_BITS, //data bit mode + * .parity = UART_PARITY_DISABLE, //parity mode + * .stop_bits = UART_STOP_BITS_1, //stop bit mode + * .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, //hardware flow control(cts/rts) + * .rx_flow_ctrl_thresh = 120, //flow control threshold + * }; + * uart_param_config(uart_num, &uart_config); + * //b1. Setup UART driver(with UART queue) + * QueueHandle_t uart_queue; + * uart_driver_install(uart_num, 1024 * 2, 10, UART_INTR_NUM, &uart_queue);//parameters here are just an example + * //b2. Setup UART driver(without UART queue) + * uart_driver_install(uart_num, 1024 * 2, 10, UART_INTR_NUM, NULL); //parameters here are just an example + *@endcode *-----------------------------------------------------------------------------* - * //2. Set UART pin - * uart_set_pin(uart_num, -1, -1, 15, 13); //set UART pin, not needed if use default pins. - * + * @code{c} + * //2. Set UART pin + * uart_set_pin(uart_num, -1, -1, 15, 13); //set UART pin, not needed if use default pins. + * @endcode *-----------------------------------------------------------------------------* - * //3. Read data from UART. - * uint8_t data[128]; - * int length = 0; - * length = uart_read_bytes(uart_num, data, sizeof(data), 100); - * + * @code{c} + * //3. Read data from UART. + * uint8_t data[128]; + * int length = 0; + * length = uart_read_bytes(uart_num, data, sizeof(data), 100); + * @endcode *-----------------------------------------------------------------------------* - * //4. Write data to UART. - * char* test_str = "This is a test string.\n" - * uart_tx_all_chars(uart_num, (const char*)test_str, strlen(test_str)); - * + * @code{c} + * //4. Write data to UART. + * char* test_str = "This is a test string.\n" + * uart_tx_all_chars(uart_num, (const char*)test_str, strlen(test_str)); + * @endcode *-----------------------------------------------------------------------------* - * //5. Write data to UART, end with a break signal. - * uart_tx_all_chars_with_break(0, "test break\n",strlen("test break\n"), 100); - * + * @code{c} + * //5. Write data to UART, end with a break signal. + * uart_tx_all_chars_with_break(0, "test break\n",strlen("test break\n"), 100); + * @endcode *-----------------------------------------------------------------------------* - * - * //6. an example of echo test with hardware flow control on UART1 - * void uart_loop_back_test() - * { - * int uart_num = 1; - * uart_config_t uart_config = { - * .baud_rate = 115200, - * .data_bits = UART_DATA_8_BITS, - * .parity = UART_PARITY_DISABLE, - * .stop_bits = UART_STOP_BITS_1, - * .flow_ctrl = UART_HW_FLOWCTRL_CTS_RTS, - * .rx_flow_ctrl_thresh = 122, - * }; - * uart_param_config(uart_num, &uart_config); //Config UART1 parameters - * uart_set_pin(uart_num, 16, 17, 18, 19); //Set UART1 pins(TX: IO16, RX: IO17, RTS: IO18, CTS: IO19) - * esp_log_level_set(UART_TAG, ESP_LOG_ERROR); //Set UART log level - * uart_driver_install(uart_num, 1024 * 2, 10, 17, NULL); //Install UART driver( We don't need an event queue here) - * uint8_t data[1000]; - * while(1) { - * int len = uart_read_bytes(uart_num, data, sizeof(data), 10); //Read data from UART - * uart_tx_all_chars(uart_num, (const char*)data, len); //Write data back to UART - * } + * @code{c} + * //6. an example of echo test with hardware flow control on UART1 + * void uart_loop_back_test() + * { + * int uart_num = 1; + * uart_config_t uart_config = { + * .baud_rate = 115200, + * .data_bits = UART_DATA_8_BITS, + * .parity = UART_PARITY_DISABLE, + * .stop_bits = UART_STOP_BITS_1, + * .flow_ctrl = UART_HW_FLOWCTRL_CTS_RTS, + * .rx_flow_ctrl_thresh = 122, + * }; + * uart_param_config(uart_num, &uart_config); //Config UART1 parameters + * uart_set_pin(uart_num, 16, 17, 18, 19); //Set UART1 pins(TX: IO16, RX: IO17, RTS: IO18, CTS: IO19) + * esp_log_level_set(UART_TAG, ESP_LOG_ERROR); //Set UART log level + * //Install UART driver( We don't need an event queue here) + * uart_driver_install(uart_num, 1024 * 2, 1024*4, 10, 17, NULL, RINGBUF_TYPE_BYTEBUF); + * uint8_t data[1000]; + * while(1) { + * int len = uart_read_bytes(uart_num, data, sizeof(data), 10); //Read data from UART + * uart_tx_all_chars(uart_num, (const char*)data, len); //Write data back to UART * } - * + * } + * @endcode *-----------------------------------------------------------------------------* - * //7. An example of using UART event queue on UART0. - * - * #include "freertos/queue.h" - * QueueHandle_t uart0_queue; //A queue to handle UART event. - * void uart_task(void *pvParameters) - * { - * int uart_num = (int)pvParameters; - * uart_event_t event; - * uint8_t dtmp[1000]; - * for(;;) { - * if(xQueueReceive(uart0_queue, (void * )&event, (portTickType)portMAX_DELAY)) { //Waiting for UART event. - * ESP_LOGI(UART_TAG, "uart[%d] event:", uart_num); - * switch(event.type) { - * case UART_DATA: //Event of UART receving data - * ESP_LOGI(UART_TAG,"data, len: %d\n", event.data.size); - * int len = uart_read_bytes(uart_num, dtmp, event.data.size, 10); - * ESP_LOGI(UART_TAG, "uart read: %d\n", len); - * break; - * case UART_FIFO_OVF: //Event of HW FIFO overflow detected - * ESP_LOGI(UART_TAG, "hw fifo overflow\n"); - * break; - * case UART_BUFFER_FULL: //Event of UART ring buffer full - * ESP_LOGI(UART_TAG, "ring buffer full\n"); - * break; - * case UART_BREAK: - * ESP_LOGI(UART_TAG, "uart rx break\n"); //Event of UART RX break detected - * break; - * case UART_PARITY_ERR: //Event of UART parity check error - * ESP_LOGI(UART_TAG, "uart parity error\n"); - * break; - * case UART_FRAME_ERR: //Event of UART frame error - * ESP_LOGI(UART_TAG, "uart frame error\n"); - * break; - * default: //Others - * ESP_LOGI(UART_TAG, "uart event type: %d\n", event.type); - * break; - * } - * } - * } - * vTaskDelete(NULL); - * } - * - * void uart_queue_test() - * { - * int uart_num = 0; - * uart_config_t uart_config = { - * .baud_rate = 115200, - * .data_bits = UART_DATA_8_BITS, - * .parity = UART_PARITY_DISABLE, - * .stop_bits = UART_STOP_BITS_1, - * .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, - * .rx_flow_ctrl_thresh = 122, - * }; - * uart_param_config(uart_num, &uart_config); //Set UART parameters - * uart_set_pin(uart_num, -1, -1, 15, 13); //Set UART pins,(-1: default pin, no change.) - * esp_log_level_set(UART_TAG, ESP_LOG_INFO); //Set UART log level - * uart_driver_install(uart_num, 1024 * 2, 10, 17, &uart0_queue); //Install UART driver, and get the queue. - * xTaskCreate(uart_task, "uTask", 2048*8, (void*)uart_num, 10, NULL); //Create a task to handler UART event from ISR + * @code{c} + * //7. An example of using UART event queue on UART0. + * #include "freertos/queue.h" + * //A queue to handle UART event. + * QueueHandle_t uart0_queue; + * void uart_task(void *pvParameters) + * { + * int uart_num = (int)pvParameters; + * uart_event_t event; + * uint8_t dtmp[1000]; + * for(;;) { + * //Waiting for UART event. + * if(xQueueReceive(uart0_queue, (void * )&event, (portTickType)portMAX_DELAY)) { + * ESP_LOGI(UART_TAG, "uart[%d] event:", uart_num); + * switch(event.type) { + * //Event of UART receving data + * case UART_DATA: + * ESP_LOGI(UART_TAG,"data, len: %d\n", event.data.size); + * int len = uart_read_bytes(uart_num, dtmp, event.data.size, 10); + * ESP_LOGI(UART_TAG, "uart read: %d\n", len); + * break; + * //Event of HW FIFO overflow detected + * case UART_FIFO_OVF: + * ESP_LOGI(UART_TAG, "hw fifo overflow\n"); + * break; + * //Event of UART ring buffer full + * case UART_BUFFER_FULL: + * ESP_LOGI(UART_TAG, "ring buffer full\n"); + * break; + * //Event of UART RX break detected + * case UART_BREAK: + * ESP_LOGI(UART_TAG, "uart rx break\n"); + * break; + * //Event of UART parity check error + * case UART_PARITY_ERR: + * ESP_LOGI(UART_TAG, "uart parity error\n"); + * break; + * //Event of UART frame error + * case UART_FRAME_ERR: + * ESP_LOGI(UART_TAG, "uart frame error\n"); + * break; + * //Others + * default: + * ESP_LOGI(UART_TAG, "uart event type: %d\n", event.type); + * break; + * } * } + * } + * vTaskDelete(NULL); + * } * + * void uart_queue_test() + * { + * int uart_num = 0; + * uart_config_t uart_config = { + * .baud_rate = 115200, + * .data_bits = UART_DATA_8_BITS, + * .parity = UART_PARITY_DISABLE, + * .stop_bits = UART_STOP_BITS_1, + * .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, + * .rx_flow_ctrl_thresh = 122, + * }; + * uart_param_config(uart_num, &uart_config); //Set UART parameters + * uart_set_pin(uart_num, -1, -1, 15, 13); //Set UART pins,(-1: default pin, no change.) + * esp_log_level_set(UART_TAG, ESP_LOG_INFO); //Set UART log level + * //Install UART driver, and get the queue. + * uart_driver_install(uart_num, 1024 * 2, 1024*4, 10, 17, &uart0_queue, RINGBUF_TYPE_BYTEBUF); + * xTaskCreate(uart_task, "uTask", 2048*8, (void*)uart_num, 10, NULL); //Create a task to handler UART event from ISR + * } + * @endcode * ***************************END OF EXAMPLE**********************************/ diff --git a/components/driver/uart.c b/components/driver/uart.c index 29e4522d6d..eeb2c64208 100644 --- a/components/driver/uart.c +++ b/components/driver/uart.c @@ -30,13 +30,15 @@ #include "soc/uart_struct.h" const char* UART_TAG = "UART"; -#define UART_CHECK(a, str) if (!(a)) { \ +#define UART_CHECK(a, str) if (!(a)) { \ ESP_LOGE(UART_TAG,"%s:%d (%s):%s\n", __FILE__, __LINE__, __FUNCTION__, str); \ return ESP_FAIL; \ } -#define DEFAULT_EMPTY_THRESH 10 -#define DEFAULT_FULL_THRESH 120 -#define DEFAULT_TOUT_THRESH 10 +#define UART_EMPTY_THRESH_DEFAULT (10) +#define UART_FULL_THRESH_DEFAULT (120) +#define UART_TOUT_THRESH_DEFAULT (10) +#define UART_TX_TASK_DEPTH_DEFAULT (256*2+64) +#define UART_TX_TASK_PRIO_DEFAULT (10) #define UART_ENTER_CRITICAL_ISR(mux) portENTER_CRITICAL_ISR(mux) #define UART_EXIT_CRITICAL_ISR(mux) portEXIT_CRITICAL_ISR(mux) #define UART_ENTER_CRITICAL(mux) portENTER_CRITICAL(mux) @@ -46,13 +48,19 @@ typedef struct { uart_port_t uart_num; SemaphoreHandle_t tx_fifo_sem; SemaphoreHandle_t tx_mutex; + SemaphoreHandle_t tx_buffer_mutex; SemaphoreHandle_t tx_done_sem; SemaphoreHandle_t tx_brk_sem; - SemaphoreHandle_t rx_sem; + SemaphoreHandle_t rx_mux; QueueHandle_t xQueueUart; int queue_size; int intr_num; - RingbufHandle_t ring_buffer; + int rx_buf_size; + ringbuf_type_t rx_buf_type; + RingbufHandle_t rx_ring_buf; + int tx_buf_size; + RingbufHandle_t tx_ring_buf; + TaskHandle_t tx_task_handle; bool buffer_full_flg; bool tx_waiting; int cur_remain; @@ -66,20 +74,6 @@ static uart_obj_t *p_uart_obj[UART_NUM_MAX] = {0}; static uart_dev_t* UART[UART_NUM_MAX] = {&UART0, &UART1, &UART2}; static portMUX_TYPE uart_spinlock[UART_NUM_MAX] = {portMUX_INITIALIZER_UNLOCKED, portMUX_INITIALIZER_UNLOCKED, portMUX_INITIALIZER_UNLOCKED}; -//Fill UART tx_fifo and return a number, -//This function by itself is not thread-safe, always call from within a muxed section. -static int uart_fill_fifo(uart_port_t uart_num, char* buffer, uint32_t len) -{ - uint8_t i = 0; - uint8_t tx_fifo_cnt = UART[uart_num]->status.txfifo_cnt; - uint8_t tx_remain_fifo_cnt = (UART_FIFO_LEN - tx_fifo_cnt); - uint8_t copy_cnt = (len >= tx_remain_fifo_cnt ? tx_remain_fifo_cnt : len); - for(i = 0; i < copy_cnt; i++) { - WRITE_PERI_REG(UART_FIFO_AHB_REG(uart_num), buffer[i]); - } - return copy_cnt; -} - esp_err_t uart_set_word_length(uart_port_t uart_num, uart_word_length_t data_bit) { UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); @@ -315,11 +309,11 @@ esp_err_t uart_isr_register(uart_port_t uart_num, uint8_t uart_intr_num, void (* //only one GPIO pad can connect with input signal esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int rts_io_num, int cts_io_num) { -// UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); -// UART_CHECK((tx_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(tx_io_num))), "tx_io_num error"); -// UART_CHECK((rx_io_num < 0 || (GPIO_IS_VALID_GPIO(rx_io_num))), "rx_io_num error"); -// UART_CHECK((rts_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(rts_io_num))), "rts_io_num error"); -// UART_CHECK((cts_io_num < 0 || (GPIO_IS_VALID_GPIO(cts_io_num))), "cts_io_num error"); + UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); + UART_CHECK((tx_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(tx_io_num))), "tx_io_num error"); + UART_CHECK((rx_io_num < 0 || (GPIO_IS_VALID_GPIO(rx_io_num))), "rx_io_num error"); + UART_CHECK((rts_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(rts_io_num))), "rts_io_num error"); + UART_CHECK((cts_io_num < 0 || (GPIO_IS_VALID_GPIO(cts_io_num))), "cts_io_num error"); int tx_sig, rx_sig, rts_sig, cts_sig; switch(uart_num) { @@ -443,7 +437,6 @@ static void IRAM_ATTR uart_rx_intr_handler_default(void *param) uart_obj_t *p_uart = (uart_obj_t*) param; uint8_t uart_num = p_uart->uart_num; uart_dev_t* uart_reg = UART[uart_num]; - uint8_t buf_idx = 0; uint32_t uart_intr_status = UART[uart_num]->int_st.val; static int rx_fifo_len = 0; @@ -478,7 +471,7 @@ static void IRAM_ATTR uart_rx_intr_handler_default(void *param) UART_EXIT_CRITICAL_ISR(&uart_spinlock[uart_num]); uart_event.type = UART_DATA; uart_event.data.size = rx_fifo_len; - if(pdFALSE == xRingbufferSendFromISR(p_uart->ring_buffer, p_uart->data_buf, p_uart->data_len, &HPTaskAwoken)) { + if(pdFALSE == xRingbufferSendFromISR(p_uart->rx_ring_buf, p_uart->data_buf, p_uart->data_len, &HPTaskAwoken)) { UART_ENTER_CRITICAL_ISR(&uart_spinlock[uart_num]); uart_reg->int_ena.rxfifo_full = 0; uart_reg->int_ena.rxfifo_tout = 0; @@ -544,108 +537,7 @@ static void IRAM_ATTR uart_rx_intr_handler_default(void *param) } /**************************************************************/ -esp_err_t uart_driver_install(uart_port_t uart_num, int buffer_size, int queue_size, int uart_intr_num, void* uart_queue) -{ - UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); - if(p_uart_obj[uart_num] == NULL) { - ESP_INTR_DISABLE(uart_intr_num); - p_uart_obj[uart_num] = (uart_obj_t*) malloc(sizeof(uart_obj_t)); - if(p_uart_obj[uart_num] == NULL) { - ESP_LOGE(UART_TAG, "UART driver malloc error\n"); - return ESP_FAIL; - } - p_uart_obj[uart_num]->uart_num = uart_num; - p_uart_obj[uart_num]->tx_fifo_sem = xSemaphoreCreateBinary(); - xSemaphoreGive(p_uart_obj[uart_num]->tx_fifo_sem); - p_uart_obj[uart_num]->tx_done_sem = xSemaphoreCreateBinary(); - xSemaphoreGive(p_uart_obj[uart_num]->tx_done_sem); - p_uart_obj[uart_num]->tx_brk_sem = xSemaphoreCreateBinary(); - - p_uart_obj[uart_num]->tx_mutex = xSemaphoreCreateMutex(); - p_uart_obj[uart_num]->rx_sem = xSemaphoreCreateMutex(); - p_uart_obj[uart_num]->intr_num = uart_intr_num; - p_uart_obj[uart_num]->queue_size = queue_size; - - if(uart_queue) { - p_uart_obj[uart_num]->xQueueUart = xQueueCreate(queue_size, sizeof(uart_event_t)); - *((QueueHandle_t*) uart_queue) = p_uart_obj[uart_num]->xQueueUart; - ESP_LOGI(UART_TAG, "queue free spaces: %d\n", uxQueueSpacesAvailable(p_uart_obj[uart_num]->xQueueUart)); - } else { - p_uart_obj[uart_num]->xQueueUart = NULL; - } - p_uart_obj[uart_num]->buffer_full_flg = false; - p_uart_obj[uart_num]->tx_waiting = false; - p_uart_obj[uart_num]->rd_ptr = NULL; - p_uart_obj[uart_num]->cur_remain = 0; - p_uart_obj[uart_num]->head_ptr = NULL; - p_uart_obj[uart_num]->ring_buffer = xRingbufferCreate(buffer_size, 0); - } else { - ESP_LOGE(UART_TAG, "UART driver already installed\n"); - return ESP_FAIL; - } - uart_isr_register(uart_num, uart_intr_num, uart_rx_intr_handler_default, p_uart_obj[uart_num]); - uart_intr_config_t uart_intr = { - .intr_enable_mask = UART_RXFIFO_FULL_INT_ENA_M - | UART_RXFIFO_TOUT_INT_ENA_M - | UART_FRM_ERR_INT_ENA_M - | UART_RXFIFO_OVF_INT_ENA_M - | UART_BRK_DET_INT_ENA_M, - .rxfifo_full_thresh = DEFAULT_FULL_THRESH, - .rx_timeout_thresh = DEFAULT_TOUT_THRESH, - .txfifo_empty_intr_thresh = DEFAULT_EMPTY_THRESH - }; - uart_intr_config(uart_num, &uart_intr); - ESP_INTR_ENABLE(uart_intr_num); - return ESP_OK; -} - -//Make sure no other tasks are still using UART before you call this function -esp_err_t uart_driver_delete(uart_port_t uart_num) -{ - UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); - if(p_uart_obj[uart_num] == NULL) { - ESP_LOGI(UART_TAG, "ALREADY NULL\n"); - return ESP_OK; - } - ESP_INTR_DISABLE(p_uart_obj[uart_num]->intr_num); - uart_disable_rx_intr(uart_num); - uart_disable_tx_intr(uart_num); - uart_isr_register(uart_num, p_uart_obj[uart_num]->intr_num, NULL, NULL); - - if(p_uart_obj[uart_num]->tx_fifo_sem) { - vSemaphoreDelete(p_uart_obj[uart_num]->tx_fifo_sem); - p_uart_obj[uart_num]->tx_fifo_sem = NULL; - } - if(p_uart_obj[uart_num]->tx_done_sem) { - vSemaphoreDelete(p_uart_obj[uart_num]->tx_done_sem); - p_uart_obj[uart_num]->tx_done_sem = NULL; - } - if(p_uart_obj[uart_num]->tx_brk_sem) { - vSemaphoreDelete(p_uart_obj[uart_num]->tx_brk_sem); - p_uart_obj[uart_num]->tx_brk_sem = NULL; - } - if(p_uart_obj[uart_num]->tx_mutex) { - vSemaphoreDelete(p_uart_obj[uart_num]->tx_mutex); - p_uart_obj[uart_num]->tx_mutex = NULL; - } - if(p_uart_obj[uart_num]->rx_sem) { - vSemaphoreDelete(p_uart_obj[uart_num]->rx_sem); - p_uart_obj[uart_num]->rx_sem = NULL; - } - if(p_uart_obj[uart_num]->xQueueUart) { - vQueueDelete(p_uart_obj[uart_num]->xQueueUart); - p_uart_obj[uart_num]->xQueueUart = NULL; - } - if(p_uart_obj[uart_num]->ring_buffer) { - vRingbufferDelete(p_uart_obj[uart_num]->ring_buffer); - p_uart_obj[uart_num]->ring_buffer = NULL; - } - free(p_uart_obj[uart_num]); - p_uart_obj[uart_num] = NULL; - return ESP_OK; -} - -esp_err_t uart_wait_tx_fifo_empty(uart_port_t uart_num, TickType_t ticks_to_wait) +esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait) { UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); UART_CHECK((p_uart_obj[uart_num]), "uart driver error"); @@ -657,17 +549,9 @@ esp_err_t uart_wait_tx_fifo_empty(uart_port_t uart_num, TickType_t ticks_to_wait return ESP_ERR_TIMEOUT; } ticks_to_wait = ticks_end - xTaskGetTickCount(); - //take 1st tx_done_sem - res = xSemaphoreTake(p_uart_obj[uart_num]->tx_done_sem, (portTickType)ticks_to_wait); - if(res == pdFALSE) { - ESP_LOGE(UART_TAG, "take uart done sem error, should not get here.\n"); - xSemaphoreGive(p_uart_obj[uart_num]->tx_done_sem); - xSemaphoreGive(p_uart_obj[uart_num]->tx_mutex); - return ESP_ERR_TIMEOUT; - } + xSemaphoreTake(p_uart_obj[uart_num]->tx_done_sem, 0); ticks_to_wait = ticks_end - xTaskGetTickCount(); if(UART[uart_num]->status.txfifo_cnt == 0) { - xSemaphoreGive(p_uart_obj[uart_num]->tx_done_sem); xSemaphoreGive(p_uart_obj[uart_num]->tx_mutex); return ESP_OK; } @@ -676,11 +560,9 @@ esp_err_t uart_wait_tx_fifo_empty(uart_port_t uart_num, TickType_t ticks_to_wait res = xSemaphoreTake(p_uart_obj[uart_num]->tx_done_sem, (portTickType)ticks_to_wait); if(res == pdFALSE) { uart_disable_intr_mask(uart_num, UART_TX_DONE_INT_ENA_M); - xSemaphoreGive(p_uart_obj[uart_num]->tx_done_sem); xSemaphoreGive(p_uart_obj[uart_num]->tx_mutex); return ESP_ERR_TIMEOUT; } - xSemaphoreGive(p_uart_obj[uart_num]->tx_done_sem); xSemaphoreGive(p_uart_obj[uart_num]->tx_mutex); return ESP_OK; } @@ -696,6 +578,20 @@ static esp_err_t uart_set_break(uart_port_t uart_num, int break_num) return ESP_OK; } +//Fill UART tx_fifo and return a number, +//This function by itself is not thread-safe, always call from within a muxed section. +static int uart_fill_fifo(uart_port_t uart_num, char* buffer, uint32_t len) +{ + uint8_t i = 0; + uint8_t tx_fifo_cnt = UART[uart_num]->status.txfifo_cnt; + uint8_t tx_remain_fifo_cnt = (UART_FIFO_LEN - tx_fifo_cnt); + uint8_t copy_cnt = (len >= tx_remain_fifo_cnt ? tx_remain_fifo_cnt : len); + for(i = 0; i < copy_cnt; i++) { + WRITE_PERI_REG(UART_FIFO_AHB_REG(uart_num), buffer[i]); + } + return copy_cnt; +} + int uart_tx_chars(uart_port_t uart_num, char* buffer, uint32_t len) { UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); @@ -727,7 +623,7 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool size_t sent = uart_fill_fifo(uart_num, (char*) src, size); if(sent < size) { p_uart_obj[uart_num]->tx_waiting = true; - uart_enable_tx_intr(uart_num, 1, DEFAULT_EMPTY_THRESH); + uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT); } size -= sent; src += sent; @@ -742,12 +638,55 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool return original_size; } +static void uart_tx_task(void* arg) +{ + uart_obj_t* p_uart = (uart_obj_t*) arg; + size_t size; + uart_event_t evt; + for(;;) { + char* data = (char*) xRingbufferReceive(p_uart->tx_ring_buf, &size, portMAX_DELAY); + if(data == NULL) { + continue; + } + memcpy(&evt, data, sizeof(evt)); + if(evt.type == UART_DATA) { + uart_tx_all(p_uart->uart_num, (const char*) data + sizeof(uart_event_t), evt.data.size, 0, 0); + } else if(evt.type == UART_DATA_BREAK) { + uart_tx_all(p_uart->uart_num, (const char*) data + sizeof(uart_event_t), evt.data.size, 1, evt.data.brk_len); + } + vRingbufferReturnItem(p_uart->tx_ring_buf, data); + } + vTaskDelete(NULL); +} + int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size) { UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); - UART_CHECK((p_uart_obj[uart_num]), "uart driver error"); + UART_CHECK((p_uart_obj[uart_num] != NULL), "uart driver error"); UART_CHECK(src, "buffer null"); - return uart_tx_all(uart_num, src, size, 0, 0); + if(p_uart_obj[uart_num]->tx_buf_size > 0) { + if(xRingbufferGetMaxItemSize(p_uart_obj[uart_num]->tx_ring_buf) > (size + sizeof(uart_event_t))) { + uart_event_t *evt = (uart_event_t*) malloc(sizeof(uart_event_t) + size); + if(evt == NULL) { + ESP_LOGE(UART_TAG, "UART EVT MALLOC ERROR\n"); + return -1; + } + xSemaphoreTake(p_uart_obj[uart_num]->tx_buffer_mutex, (portTickType)portMAX_DELAY); + evt->type = UART_DATA; + evt->data.size = size; + memcpy(evt->data.data, src, size); + xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) evt, sizeof(uart_event_t) + size, portMAX_DELAY); + free(evt); + evt = NULL; + xSemaphoreGive(p_uart_obj[uart_num]->tx_buffer_mutex); + return size; + } else { + ESP_LOGW(UART_TAG, "UART TX BUFFER TOO SMALL[0], SEND DIRECTLY\n"); + return uart_tx_all(uart_num, src, size, 0, 0); + } + } else { + return uart_tx_all(uart_num, src, size, 0, 0); + } } int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len) @@ -757,7 +696,29 @@ int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t s UART_CHECK((size > 0), "uart size error"); UART_CHECK((src), "uart data null"); UART_CHECK((brk_len > 0 && brk_len < 256), "break_num error"); - return uart_tx_all(uart_num, src, size, 1, brk_len); + if(p_uart_obj[uart_num]->tx_buf_size > 0) { + if(xRingbufferGetMaxItemSize(p_uart_obj[uart_num]->tx_ring_buf) > (size)) { + uart_event_t *evt = (uart_event_t*) malloc(sizeof(uart_event_t) + size); + if(evt == NULL) { + return -1; + } + xSemaphoreTake(p_uart_obj[uart_num]->tx_buffer_mutex, (portTickType)portMAX_DELAY); + evt->type = UART_DATA_BREAK; + evt->data.size = size; + evt->data.brk_len = brk_len; + memcpy(evt->data.data, src, size); + xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) evt, sizeof(uart_event_t) + size, portMAX_DELAY); + free(evt); + evt = NULL; + xSemaphoreGive(p_uart_obj[uart_num]->tx_buffer_mutex); + return size; + } else { + ESP_LOGW(UART_TAG, "UART TX BUFFER TOO SMALL[1], SEND DIRECTLY\n"); + return uart_tx_all(uart_num, src, size, 1, brk_len); + } + } else { + return uart_tx_all(uart_num, src, size, 1, brk_len); + } } int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait) @@ -768,18 +729,18 @@ int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait) size_t size; int val; portTickType ticks_end = xTaskGetTickCount() + ticks_to_wait; - if(xSemaphoreTake(p_uart_obj[uart_num]->rx_sem,(portTickType)ticks_to_wait) != pdTRUE) { + if(xSemaphoreTake(p_uart_obj[uart_num]->rx_mux,(portTickType)ticks_to_wait) != pdTRUE) { return -1; } if(p_uart_obj[uart_num]->cur_remain == 0) { ticks_to_wait = ticks_end - xTaskGetTickCount(); - data = (uint8_t*) xRingbufferReceive(p_uart_obj[uart_num]->ring_buffer, &size, (portTickType) ticks_to_wait); + data = (uint8_t*) xRingbufferReceive(p_uart_obj[uart_num]->rx_ring_buf, &size, (portTickType) ticks_to_wait); if(data) { p_uart_obj[uart_num]->head_ptr = data; p_uart_obj[uart_num]->rd_ptr = data; p_uart_obj[uart_num]->cur_remain = size; } else { - xSemaphoreGive(p_uart_obj[uart_num]->rx_sem); + xSemaphoreGive(p_uart_obj[uart_num]->rx_mux); return -1; } } @@ -787,18 +748,18 @@ int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait) p_uart_obj[uart_num]->rd_ptr++; p_uart_obj[uart_num]->cur_remain--; if(p_uart_obj[uart_num]->cur_remain == 0) { - vRingbufferReturnItem(p_uart_obj[uart_num]->ring_buffer, p_uart_obj[uart_num]->head_ptr); + vRingbufferReturnItem(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->head_ptr); p_uart_obj[uart_num]->head_ptr = NULL; p_uart_obj[uart_num]->rd_ptr = NULL; if(p_uart_obj[uart_num]->buffer_full_flg) { - BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->ring_buffer, p_uart_obj[uart_num]->data_buf, p_uart_obj[uart_num]->data_len, 1); + BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->data_buf, p_uart_obj[uart_num]->data_len, 1); if(res == pdTRUE) { p_uart_obj[uart_num]->buffer_full_flg = false; uart_enable_rx_intr(p_uart_obj[uart_num]->uart_num); } } } - xSemaphoreGive(p_uart_obj[uart_num]->rx_sem); + xSemaphoreGive(p_uart_obj[uart_num]->rx_mux); return val; } @@ -807,23 +768,22 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); UART_CHECK((buf), "uart_num error"); UART_CHECK((p_uart_obj[uart_num]), "uart driver error"); - uint8_t* data = NULL; size_t size; size_t copy_len = 0; int len_tmp; - if(xSemaphoreTake(p_uart_obj[uart_num]->rx_sem,(portTickType)ticks_to_wait) != pdTRUE) { + if(xSemaphoreTake(p_uart_obj[uart_num]->rx_mux,(portTickType)ticks_to_wait) != pdTRUE) { return -1; } while(length) { if(p_uart_obj[uart_num]->cur_remain == 0) { - data = (uint8_t*) xRingbufferReceive(p_uart_obj[uart_num]->ring_buffer, &size, (portTickType) ticks_to_wait); + data = (uint8_t*) xRingbufferReceive(p_uart_obj[uart_num]->rx_ring_buf, &size, (portTickType) ticks_to_wait); if(data) { p_uart_obj[uart_num]->head_ptr = data; p_uart_obj[uart_num]->rd_ptr = data; p_uart_obj[uart_num]->cur_remain = size; } else { - xSemaphoreGive(p_uart_obj[uart_num]->rx_sem); + xSemaphoreGive(p_uart_obj[uart_num]->rx_mux); return copy_len; } } @@ -838,11 +798,11 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp copy_len += len_tmp; length -= len_tmp; if(p_uart_obj[uart_num]->cur_remain == 0) { - vRingbufferReturnItem(p_uart_obj[uart_num]->ring_buffer, p_uart_obj[uart_num]->head_ptr); + vRingbufferReturnItem(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->head_ptr); p_uart_obj[uart_num]->head_ptr = NULL; p_uart_obj[uart_num]->rd_ptr = NULL; if(p_uart_obj[uart_num]->buffer_full_flg) { - BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->ring_buffer, p_uart_obj[uart_num]->data_buf, p_uart_obj[uart_num]->data_len, 1); + BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->data_buf, p_uart_obj[uart_num]->data_len, 1); if(res == pdTRUE) { p_uart_obj[uart_num]->buffer_full_flg = false; uart_enable_rx_intr(p_uart_obj[uart_num]->uart_num); @@ -850,7 +810,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp } } } - xSemaphoreGive(p_uart_obj[uart_num]->rx_sem); + xSemaphoreGive(p_uart_obj[uart_num]->rx_mux); return copy_len; } @@ -858,30 +818,38 @@ esp_err_t uart_flush(uart_port_t uart_num) { UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); UART_CHECK((p_uart_obj[uart_num]), "uart driver error"); - uart_obj_t* p_uart = p_uart_obj[uart_num]; uint8_t* data; size_t size; //rx sem protect the ring buffer read related functions - xSemaphoreTake(p_uart->rx_sem, (portTickType)portMAX_DELAY); + xSemaphoreTake(p_uart->rx_mux, (portTickType)portMAX_DELAY); while(true) { if(p_uart->head_ptr) { - vRingbufferReturnItem(p_uart->ring_buffer, p_uart->head_ptr); + vRingbufferReturnItem(p_uart->rx_ring_buf, p_uart->head_ptr); p_uart->rd_ptr = NULL; p_uart->cur_remain = 0; p_uart->head_ptr = NULL; } - data = (uint8_t*) xRingbufferReceive(p_uart->ring_buffer, &size, (portTickType) 0); + data = (uint8_t*) xRingbufferReceive(p_uart->rx_ring_buf, &size, (portTickType) 0); if(data == NULL) { break; } - vRingbufferReturnItem(p_uart->ring_buffer, data); + vRingbufferReturnItem(p_uart->rx_ring_buf, data); } p_uart->rd_ptr = NULL; p_uart->cur_remain = 0; p_uart->head_ptr = NULL; - xSemaphoreGive(p_uart->rx_sem); - uart_wait_tx_fifo_empty(uart_num, portMAX_DELAY); + xSemaphoreGive(p_uart->rx_mux); + xSemaphoreTake(p_uart->tx_mutex, (portTickType)portMAX_DELAY); + do { + data = (uint8_t*) xRingbufferReceive(p_uart->tx_ring_buf, &size, (portTickType) 0); + if(data == NULL) { + break; + } + vRingbufferReturnItem(p_uart->rx_ring_buf, data); + } while(1); + xSemaphoreGive(p_uart->tx_mutex); + uart_wait_tx_done(uart_num, portMAX_DELAY); uart_reset_fifo(uart_num); return ESP_OK; } @@ -915,7 +883,6 @@ esp_err_t uart_set_print_port(uart_port_t uart_num) { UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); UART_CHECK((p_uart_obj[uart_num]), "UART driver error"); - s_uart_print_nport = uart_num; switch(s_uart_print_nport) { case UART_NUM_0: @@ -940,3 +907,127 @@ int uart_get_print_port() return s_uart_print_nport; } +esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, int uart_intr_num, void* uart_queue, ringbuf_type_t rx_buf_type) +{ + UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); + UART_CHECK((rx_buffer_size > 0), "uart rx buffer length error\n"); + if(p_uart_obj[uart_num] == NULL) { + ESP_INTR_DISABLE(uart_intr_num); + p_uart_obj[uart_num] = (uart_obj_t*) malloc(sizeof(uart_obj_t)); + if(p_uart_obj[uart_num] == NULL) { + ESP_LOGE(UART_TAG, "UART driver malloc error\n"); + return ESP_FAIL; + } + p_uart_obj[uart_num]->uart_num = uart_num; + p_uart_obj[uart_num]->tx_fifo_sem = xSemaphoreCreateBinary(); + xSemaphoreGive(p_uart_obj[uart_num]->tx_fifo_sem); + p_uart_obj[uart_num]->tx_done_sem = xSemaphoreCreateBinary(); + p_uart_obj[uart_num]->tx_brk_sem = xSemaphoreCreateBinary(); + p_uart_obj[uart_num]->tx_mutex = xSemaphoreCreateMutex(); + p_uart_obj[uart_num]->tx_buffer_mutex = xSemaphoreCreateMutex(); + p_uart_obj[uart_num]->rx_mux = xSemaphoreCreateMutex(); + p_uart_obj[uart_num]->intr_num = uart_intr_num; + p_uart_obj[uart_num]->queue_size = queue_size; + + if(uart_queue) { + p_uart_obj[uart_num]->xQueueUart = xQueueCreate(queue_size, sizeof(uart_event_t)); + *((QueueHandle_t*) uart_queue) = p_uart_obj[uart_num]->xQueueUart; + ESP_LOGI(UART_TAG, "queue free spaces: %d\n", uxQueueSpacesAvailable(p_uart_obj[uart_num]->xQueueUart)); + } else { + p_uart_obj[uart_num]->xQueueUart = NULL; + } + p_uart_obj[uart_num]->buffer_full_flg = false; + p_uart_obj[uart_num]->tx_waiting = false; + p_uart_obj[uart_num]->rd_ptr = NULL; + p_uart_obj[uart_num]->cur_remain = 0; + p_uart_obj[uart_num]->head_ptr = NULL; + p_uart_obj[uart_num]->rx_buf_type = rx_buf_type; + p_uart_obj[uart_num]->rx_ring_buf = xRingbufferCreate(rx_buffer_size, rx_buf_type); + if(tx_buffer_size > 0) { + p_uart_obj[uart_num]->tx_ring_buf = xRingbufferCreate(tx_buffer_size, RINGBUF_TYPE_NOSPLIT); + p_uart_obj[uart_num]->tx_buf_size = tx_buffer_size; + xTaskCreate(uart_tx_task, "uart_tx_task", UART_TX_TASK_DEPTH_DEFAULT, (void*)p_uart_obj[uart_num], UART_TX_TASK_PRIO_DEFAULT, &p_uart_obj[uart_num]->tx_task_handle); + + } else { + p_uart_obj[uart_num]->tx_ring_buf = NULL; + p_uart_obj[uart_num]->tx_buf_size = 0; + p_uart_obj[uart_num]->tx_task_handle = NULL; + } + } else { + ESP_LOGE(UART_TAG, "UART driver already installed\n"); + return ESP_FAIL; + } + uart_isr_register(uart_num, uart_intr_num, uart_rx_intr_handler_default, p_uart_obj[uart_num]); + uart_intr_config_t uart_intr = { + .intr_enable_mask = UART_RXFIFO_FULL_INT_ENA_M + | UART_RXFIFO_TOUT_INT_ENA_M + | UART_FRM_ERR_INT_ENA_M + | UART_RXFIFO_OVF_INT_ENA_M + | UART_BRK_DET_INT_ENA_M, + .rxfifo_full_thresh = UART_FULL_THRESH_DEFAULT, + .rx_timeout_thresh = UART_TOUT_THRESH_DEFAULT, + .txfifo_empty_intr_thresh = UART_EMPTY_THRESH_DEFAULT + }; + uart_intr_config(uart_num, &uart_intr); + ESP_INTR_ENABLE(uart_intr_num); + return ESP_OK; +} + +//Make sure no other tasks are still using UART before you call this function +esp_err_t uart_driver_delete(uart_port_t uart_num) +{ + UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); + if(p_uart_obj[uart_num] == NULL) { + ESP_LOGI(UART_TAG, "ALREADY NULL\n"); + return ESP_OK; + } + ESP_INTR_DISABLE(p_uart_obj[uart_num]->intr_num); + uart_disable_rx_intr(uart_num); + uart_disable_tx_intr(uart_num); + uart_isr_register(uart_num, p_uart_obj[uart_num]->intr_num, NULL, NULL); + + if(p_uart_obj[uart_num]->tx_task_handle) { + vTaskDelete(p_uart_obj[uart_num]->tx_task_handle); + p_uart_obj[uart_num]->tx_task_handle = NULL; + } + if(p_uart_obj[uart_num]->tx_fifo_sem) { + vSemaphoreDelete(p_uart_obj[uart_num]->tx_fifo_sem); + p_uart_obj[uart_num]->tx_fifo_sem = NULL; + } + if(p_uart_obj[uart_num]->tx_done_sem) { + vSemaphoreDelete(p_uart_obj[uart_num]->tx_done_sem); + p_uart_obj[uart_num]->tx_done_sem = NULL; + } + if(p_uart_obj[uart_num]->tx_brk_sem) { + vSemaphoreDelete(p_uart_obj[uart_num]->tx_brk_sem); + p_uart_obj[uart_num]->tx_brk_sem = NULL; + } + if(p_uart_obj[uart_num]->tx_mutex) { + vSemaphoreDelete(p_uart_obj[uart_num]->tx_mutex); + p_uart_obj[uart_num]->tx_mutex = NULL; + } + if(p_uart_obj[uart_num]->tx_buffer_mutex) { + vSemaphoreDelete(p_uart_obj[uart_num]->tx_buffer_mutex); + p_uart_obj[uart_num]->tx_buffer_mutex = NULL; + } + if(p_uart_obj[uart_num]->rx_mux) { + vSemaphoreDelete(p_uart_obj[uart_num]->rx_mux); + p_uart_obj[uart_num]->rx_mux = NULL; + } + if(p_uart_obj[uart_num]->xQueueUart) { + vQueueDelete(p_uart_obj[uart_num]->xQueueUart); + p_uart_obj[uart_num]->xQueueUart = NULL; + } + if(p_uart_obj[uart_num]->rx_ring_buf) { + vRingbufferDelete(p_uart_obj[uart_num]->rx_ring_buf); + p_uart_obj[uart_num]->rx_ring_buf = NULL; + } + if(p_uart_obj[uart_num]->tx_ring_buf) { + vRingbufferDelete(p_uart_obj[uart_num]->tx_ring_buf); + p_uart_obj[uart_num]->tx_ring_buf = NULL; + } + + free(p_uart_obj[uart_num]); + p_uart_obj[uart_num] = NULL; + return ESP_OK; +} -- 2.40.0