#include "freertos/ringbuf.h"\r
#include <esp_types.h>\r
\r
-extern const char* UART_TAG;\r
-#define UART_FIFO_LEN (128) //Do not change this, this value describes the length of the gardware FIFO in the ESP32\r
+#define UART_FIFO_LEN (128) /*< Length of the hardware FIFO buffers */\r
#define UART_INTR_MASK 0x1ff\r
#define UART_LINE_INV_MASK (0x3f << 19)\r
#define UART_BITRATE_MAX 5000000\r
+#define UART_PIN_NO_CHANGE (-1)\r
\r
typedef enum {\r
UART_DATA_5_BITS = 0x0, /*!< word length: 5bits*/\r
*\r
* @param rx_thresh Threshold of Hardware RX flow control(0 ~ UART_FIFO_LEN)\r
*\r
+ * Only when UART_HW_FLOWCTRL_RTS is set , will the rx_thresh value be set.\r
+ *\r
* @return\r
* - ESP_OK Success\r
* - ESP_FAIL Parameter error\r
/**\r
* @brief Set UART pin number\r
*\r
+ * @note\r
+ * Internal signal can be output to multiple GPIO pads\r
+ * Only one GPIO pad can connect with input signal\r
+ *\r
* @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2\r
*\r
- * @param tx_io_num UART TX pin GPIO number\r
+ * @param tx_io_num UART TX pin GPIO number, if set to UART_PIN_NO_CHANGE, use the current pin.\r
*\r
- * @param rx_io_num UART RX pin GPIO number\r
+ * @param rx_io_num UART RX pin GPIO number, if set to UART_PIN_NO_CHANGE, use the current pin.\r
*\r
- * @param rts_io_num UART RTS pin GPIO number\r
+ * @param rts_io_num UART RTS pin GPIO number, if set to UART_PIN_NO_CHANGE, use the current pin.\r
*\r
- * @param cts_io_num UART CTS pin GPIO number\r
+ * @param cts_io_num UART CTS pin GPIO number, if set to UART_PIN_NO_CHANGE, use the current pin.\r
*\r
* @return\r
* - ESP_OK Success\r
* - ESP_OK Success\r
* - ESP_FAIL Parameter error\r
*/\r
-esp_err_t uart_param_config(uart_port_t uart_num, uart_config_t *uart_config);\r
+esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_config);\r
\r
/**\r
* @brief UART interrupt configure\r
*\r
* @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2\r
*\r
- * @param p_intr_conf UART interrupt settings\r
+ * @param intr_conf UART interrupt settings\r
*\r
* @return\r
* - ESP_OK Success\r
* - ESP_FAIL Parameter error\r
*/\r
-esp_err_t uart_intr_config(uart_port_t uart_num, uart_intr_config_t *p_intr_conf);\r
+esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_conf);\r
\r
/**\r
* @brief Install UART driver.\r
/**\r
* @brief Send data to the UART port from a given buffer and length,\r
* This function will not wait for the space in TX FIFO, just fill the TX FIFO and return when the FIFO is full.\r
+ * @note\r
+ * This function should only be used when UART TX buffer is not enabled.\r
+ *\r
*\r
* @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2\r
*\r
* - (-1) Parameter error\r
* - OTHERS(>=0) The number of data that pushed to the TX FIFO\r
*/\r
-int uart_tx_chars(uart_port_t uart_no, char* buffer, uint32_t len);\r
+int uart_tx_chars(uart_port_t uart_no, const char* buffer, uint32_t len);\r
\r
/**\r
* @brief Send data to the UART port from a given buffer and length,\r
* - (-1) Parameter error\r
* - OTHERS(>=0) The number of data that pushed to the TX FIFO\r
*/\r
-int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size);\r
+int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size);\r
\r
/**\r
* @brief Send data to the UART port from a given buffer and length,\r
* - OTHERS(>=0) The number of data that pushed to the TX FIFO\r
*/\r
\r
-int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len);\r
-\r
-/**\r
-* @brief UART read one char\r
- *\r
- * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2\r
- *\r
- * @param ticks_to_wait Timeout, count in RTOS ticks\r
- *\r
- * @return\r
- * - (-1) Error\r
- * - Others return a char data from UART.\r
- */\r
-int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait);\r
+int uart_write_bytes_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len);\r
\r
/**\r
* @brief UART read bytes from UART buffer\r
*/\r
esp_err_t uart_flush(uart_port_t uart_num);\r
\r
-/**\r
- * @brief Set the serial output port for ets_printf function, not effective for ESP_LOGX macro.\r
- *\r
- * @param uart_no UART_NUM_0, UART_NUM_1 or UART_NUM_2\r
- *\r
- * @return\r
- * - ESP_OK Success\r
- * - ESP_FAIL Parameter error, or UART driver not installed.\r
- */\r
-esp_err_t uart_set_print_port(uart_port_t uart_no);\r
-\r
-/**\r
- * @brief Get the current serial port for ets_printf function\r
- *\r
- *\r
- * @return current print port(0: UART0; 1: UART1; 2: UART2)\r
- */\r
-int uart_get_print_port(void);\r
-\r
/***************************EXAMPLE**********************************\r
*\r
*\r
* @code{c}\r
* //2. Set UART pin\r
* //set UART pin, not needed if use default pins.\r
- * uart_set_pin(uart_num, -1, -1, 15, 13);\r
+ * uart_set_pin(uart_num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, 15, 13);\r
* @endcode\r
*-----------------------------------------------------------------------------*\r
* @code{c}\r
* @code{c}\r
* //4. Write data to UART.\r
* char* test_str = "This is a test string.\n"\r
- * uart_tx_all_chars(uart_num, (const char*)test_str, strlen(test_str));\r
+ * uart_write_bytes(uart_num, (const char*)test_str, strlen(test_str));\r
* @endcode\r
*-----------------------------------------------------------------------------*\r
* @code{c}\r
* //5. Write data to UART, end with a break signal.\r
- * uart_tx_all_chars_with_break(0, "test break\n",strlen("test break\n"), 100);\r
+ * uart_write_bytes_with_break(0, "test break\n",strlen("test break\n"), 100);\r
* @endcode\r
*-----------------------------------------------------------------------------*\r
* @code{c}\r
* uart_param_config(uart_num, &uart_config);\r
* //Set UART1 pins(TX: IO16, RX: IO17, RTS: IO18, CTS: IO19)\r
* uart_set_pin(uart_num, 16, 17, 18, 19);\r
- * //Set UART log level\r
- * esp_log_level_set(UART_TAG, ESP_LOG_ERROR);\r
* //Install UART driver( We don't need an event queue here)\r
* uart_driver_install(uart_num, 1024 * 2, 1024*4, 10, 17, NULL, RINGBUF_TYPE_BYTEBUF);\r
* uint8_t data[1000];\r
* //Read data from UART\r
* int len = uart_read_bytes(uart_num, data, sizeof(data), 10);\r
* //Write data back to UART\r
- * uart_tx_all_chars(uart_num, (const char*)data, len);\r
+ * uart_write_bytes(uart_num, (const char*)data, len);\r
* }\r
* }\r
* @endcode\r
* #include "freertos/queue.h"\r
* //A queue to handle UART event.\r
* QueueHandle_t uart0_queue;\r
+ * static const char *TAG = "uart_example";\r
* void uart_task(void *pvParameters)\r
* {\r
* int uart_num = (int)pvParameters;\r
* for(;;) {\r
* //Waiting for UART event.\r
* if(xQueueReceive(uart0_queue, (void * )&event, (portTickType)portMAX_DELAY)) {\r
- * ESP_LOGI(UART_TAG, "uart[%d] event:", uart_num);\r
+ * ESP_LOGI(TAG, "uart[%d] event:", uart_num);\r
* switch(event.type) {\r
* //Event of UART receving data\r
* case UART_DATA:\r
- * ESP_LOGI(UART_TAG,"data, len: %d\n", event.data.size);\r
+ * ESP_LOGI(TAG,"data, len: %d\n", event.data.size);\r
* int len = uart_read_bytes(uart_num, dtmp, event.data.size, 10);\r
- * ESP_LOGI(UART_TAG, "uart read: %d\n", len);\r
+ * ESP_LOGI(TAG, "uart read: %d\n", len);\r
* break;\r
* //Event of HW FIFO overflow detected\r
* case UART_FIFO_OVF:\r
- * ESP_LOGI(UART_TAG, "hw fifo overflow\n");\r
+ * ESP_LOGI(TAG, "hw fifo overflow\n");\r
* break;\r
* //Event of UART ring buffer full\r
* case UART_BUFFER_FULL:\r
- * ESP_LOGI(UART_TAG, "ring buffer full\n");\r
+ * ESP_LOGI(TAG, "ring buffer full\n");\r
* break;\r
* //Event of UART RX break detected\r
* case UART_BREAK:\r
- * ESP_LOGI(UART_TAG, "uart rx break\n");\r
+ * ESP_LOGI(TAG, "uart rx break\n");\r
* break;\r
* //Event of UART parity check error\r
* case UART_PARITY_ERR:\r
- * ESP_LOGI(UART_TAG, "uart parity error\n");\r
+ * ESP_LOGI(TAG, "uart parity error\n");\r
* break;\r
* //Event of UART frame error\r
* case UART_FRAME_ERR:\r
- * ESP_LOGI(UART_TAG, "uart frame error\n");\r
+ * ESP_LOGI(TAG, "uart frame error\n");\r
* break;\r
* //Others\r
* default:\r
- * ESP_LOGI(UART_TAG, "uart event type: %d\n", event.type);\r
+ * ESP_LOGI(TAG, "uart event type: %d\n", event.type);\r
* break;\r
* }\r
* }\r
* //Set UART parameters\r
* uart_param_config(uart_num, &uart_config);\r
* //Set UART pins,(-1: default pin, no change.)\r
- * uart_set_pin(uart_num, -1, -1, 15, 13);\r
+ * uart_set_pin(uart_num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, 15, 13);\r
* //Set UART log level\r
- * esp_log_level_set(UART_TAG, ESP_LOG_INFO);\r
+ * esp_log_level_set(TAG, ESP_LOG_INFO);\r
* //Install UART driver, and get the queue.\r
* uart_driver_install(uart_num, 1024 * 2, 1024*4, 10, 17, &uart0_queue, RINGBUF_TYPE_BYTEBUF);\r
* //Create a task to handler UART event from ISR\r
#include "driver/gpio.h"\r
#include "soc/uart_struct.h"\r
\r
-const char* UART_TAG = "UART";\r
+static const char* UART_TAG = "UART";\r
#define UART_CHECK(a, str, ret) if (!(a)) { \\r
ESP_LOGE(UART_TAG,"%s:%d (%s):%s\n", __FILE__, __LINE__, __FUNCTION__, str); \\r
return (ret); \\r
\r
esp_err_t uart_enable_rx_intr(uart_port_t uart_num)\r
{\r
- UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
- SET_PERI_REG_MASK(UART_INT_ENA_REG(uart_num), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);\r
- UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);\r
+ uart_enable_intr_mask(uart_num, UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);\r
return ESP_OK;\r
}\r
\r
esp_err_t uart_disable_rx_intr(uart_port_t uart_num)\r
{\r
- UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
- CLEAR_PERI_REG_MASK(UART_INT_ENA_REG(uart_num), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);\r
- UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);\r
+ uart_disable_intr_mask(uart_num, UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);\r
return ESP_OK;\r
}\r
\r
esp_err_t uart_disable_tx_intr(uart_port_t uart_num)\r
{\r
- UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
- UART[uart_num]->int_ena.txfifo_empty = 0;\r
- UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);\r
+ uart_disable_intr_mask(uart_num, UART_TXFIFO_EMPTY_INT_ENA);\r
return ESP_OK;\r
}\r
\r
return ESP_OK;\r
}\r
\r
-esp_err_t uart_param_config(uart_port_t uart_num, uart_config_t *uart_config)\r
+esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_config)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
UART_CHECK((uart_config), "param null\n", ESP_FAIL);\r
return ESP_OK;\r
}\r
\r
-esp_err_t uart_intr_config(uart_port_t uart_num, uart_intr_config_t *p_intr_conf)\r
+esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_conf)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_CHECK((p_intr_conf), "param null\n", ESP_FAIL);\r
+ UART_CHECK((intr_conf), "param null\n", ESP_FAIL);\r
UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
UART[uart_num]->int_clr.val = UART_INTR_MASK;\r
- if(p_intr_conf->intr_enable_mask & UART_RXFIFO_TOUT_INT_ENA_M) {\r
- UART[uart_num]->conf1.rx_tout_thrhd = ((p_intr_conf->rx_timeout_thresh) & UART_RX_TOUT_THRHD_V);\r
+ if(intr_conf->intr_enable_mask & UART_RXFIFO_TOUT_INT_ENA_M) {\r
+ UART[uart_num]->conf1.rx_tout_thrhd = ((intr_conf->rx_timeout_thresh) & UART_RX_TOUT_THRHD_V);\r
UART[uart_num]->conf1.rx_tout_en = 1;\r
} else {\r
UART[uart_num]->conf1.rx_tout_en = 0;\r
}\r
- if(p_intr_conf->intr_enable_mask & UART_RXFIFO_FULL_INT_ENA_M) {\r
- UART[uart_num]->conf1.rxfifo_full_thrhd = p_intr_conf->rxfifo_full_thresh;\r
+ if(intr_conf->intr_enable_mask & UART_RXFIFO_FULL_INT_ENA_M) {\r
+ UART[uart_num]->conf1.rxfifo_full_thrhd = intr_conf->rxfifo_full_thresh;\r
}\r
- if(p_intr_conf->intr_enable_mask & UART_TXFIFO_EMPTY_INT_ENA_M) {\r
- UART[uart_num]->conf1.txfifo_empty_thrhd = p_intr_conf->txfifo_empty_intr_thresh;\r
+ if(intr_conf->intr_enable_mask & UART_TXFIFO_EMPTY_INT_ENA_M) {\r
+ UART[uart_num]->conf1.txfifo_empty_thrhd = intr_conf->txfifo_empty_intr_thresh;\r
}\r
- UART[uart_num]->int_ena.val = p_intr_conf->intr_enable_mask;\r
+ UART[uart_num]->int_ena.val = intr_conf->intr_enable_mask;\r
UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);\r
return ESP_FAIL;\r
}\r
if(p_uart->tx_waiting_brk) {\r
return;\r
}\r
- //TX semaphore used in none tx ringbuffer mode.\r
- if(p_uart->tx_waiting_fifo == true && p_uart->tx_buf_size > 0) {\r
+ //TX semaphore will only be used when tx_buf_size is zero.\r
+ if(p_uart->tx_waiting_fifo == true && p_uart->tx_buf_size == 0) {\r
p_uart->tx_waiting_fifo = false;\r
xSemaphoreGiveFromISR(p_uart->tx_fifo_sem, NULL);\r
}\r
\r
//Fill UART tx_fifo and return a number,\r
//This function by itself is not thread-safe, always call from within a muxed section.\r
-static int uart_fill_fifo(uart_port_t uart_num, char* buffer, uint32_t len)\r
+static int uart_fill_fifo(uart_port_t uart_num, const char* buffer, uint32_t len)\r
{\r
uint8_t i = 0;\r
uint8_t tx_fifo_cnt = UART[uart_num]->status.txfifo_cnt;\r
return copy_cnt;\r
}\r
\r
-int uart_tx_chars(uart_port_t uart_num, char* buffer, uint32_t len)\r
+int uart_tx_chars(uart_port_t uart_num, const char* buffer, uint32_t len)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));\r
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));\r
return 0;\r
}\r
xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);\r
- int tx_len = uart_fill_fifo(uart_num, buffer, len);\r
+ int tx_len = uart_fill_fifo(uart_num, (const char*) buffer, len);\r
xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);\r
return tx_len;\r
}\r
if(size == 0) {\r
return 0;\r
}\r
- //lock for uart_tx\r
- xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);\r
size_t original_size = size;\r
- while(size) {\r
- //semaphore for tx_fifo available\r
- if(pdTRUE == xSemaphoreTake(p_uart_obj[uart_num]->tx_fifo_sem, (portTickType)portMAX_DELAY)) {\r
- size_t sent = uart_fill_fifo(uart_num, (char*) src, size);\r
- if(sent < size) {\r
- p_uart_obj[uart_num]->tx_waiting_fifo = true;\r
- uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);\r
- }\r
- size -= sent;\r
- src += sent;\r
- }\r
- }\r
- if(brk_en) {\r
- uart_set_break(uart_num, brk_len);\r
- xSemaphoreTake(p_uart_obj[uart_num]->tx_brk_sem, (portTickType)portMAX_DELAY);\r
- }\r
- xSemaphoreGive(p_uart_obj[uart_num]->tx_fifo_sem);\r
- xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);\r
- return original_size;\r
-}\r
\r
-int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size)\r
-{\r
- UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));\r
- UART_CHECK((p_uart_obj[uart_num] != NULL), "uart driver error", (-1));\r
- UART_CHECK(src, "buffer null", (-1));\r
- //Push data to TX ring buffer and return, ISR will send the data.\r
+ //lock for uart_tx\r
+ xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);\r
if(p_uart_obj[uart_num]->tx_buf_size > 0) {\r
- xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);\r
int max_size = xRingbufferGetMaxItemSize(p_uart_obj[uart_num]->tx_ring_buf);\r
- int ori_size = size;\r
int offset = 0;\r
uart_event_t evt;\r
- evt.type = UART_DATA;\r
evt.data.size = size;\r
+ evt.data.brk_len = brk_len;\r
+ if(brk_en) {\r
+ evt.type = UART_DATA_BREAK;\r
+ } else {\r
+ evt.type = UART_DATA;\r
+ }\r
xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) &evt, sizeof(uart_event_t), portMAX_DELAY);\r
while(size > 0) {\r
int send_size = size > max_size / 2 ? max_size / 2 : size;\r
}\r
xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);\r
uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);\r
- return ori_size;\r
} else {\r
- //Send data without TX ring buffer, the task will block until all data have been sent out\r
- return uart_tx_all(uart_num, src, size, 0, 0);\r
+ while(size) {\r
+ //semaphore for tx_fifo available\r
+ if(pdTRUE == xSemaphoreTake(p_uart_obj[uart_num]->tx_fifo_sem, (portTickType)portMAX_DELAY)) {\r
+ size_t sent = uart_fill_fifo(uart_num, (char*) src, size);\r
+ if(sent < size) {\r
+ p_uart_obj[uart_num]->tx_waiting_fifo = true;\r
+ uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);\r
+ }\r
+ size -= sent;\r
+ src += sent;\r
+ }\r
+ }\r
+ if(brk_en) {\r
+ uart_set_break(uart_num, brk_len);\r
+ xSemaphoreTake(p_uart_obj[uart_num]->tx_brk_sem, (portTickType)portMAX_DELAY);\r
+ }\r
+ xSemaphoreGive(p_uart_obj[uart_num]->tx_fifo_sem);\r
}\r
+ xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);\r
+ return original_size;\r
}\r
\r
-int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len)\r
+int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));\r
- UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));\r
- UART_CHECK((size > 0), "uart size error", (-1));\r
- UART_CHECK((src), "uart data null", (-1));\r
- UART_CHECK((brk_len > 0 && brk_len < 256), "break_num error", (-1));\r
- //Push data to TX ring buffer and return, ISR will send the data.\r
- if(p_uart_obj[uart_num]->tx_buf_size > 0) {\r
- xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);\r
- int max_size = xRingbufferGetMaxItemSize(p_uart_obj[uart_num]->tx_ring_buf);\r
- int ori_size = size;\r
- int offset = 0;\r
- uart_event_t evt;\r
- evt.type = UART_DATA_BREAK;\r
- evt.data.size = size;\r
- evt.data.brk_len = brk_len;\r
- xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) &evt, sizeof(uart_event_t), portMAX_DELAY);\r
- while(size > 0) {\r
- int send_size = size > max_size / 2 ? max_size / 2 : size;\r
- xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) (src + offset), send_size, portMAX_DELAY);\r
- size -= send_size;\r
- offset += send_size;\r
- }\r
- xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);\r
- uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);\r
- return ori_size;\r
- } else {\r
- //Send data without TX ring buffer, the task will block until all data have been sent out\r
- return uart_tx_all(uart_num, src, size, 1, brk_len);\r
- }\r
+ UART_CHECK((p_uart_obj[uart_num] != NULL), "uart driver error", (-1));\r
+ UART_CHECK(src, "buffer null", (-1));\r
+ return uart_tx_all(uart_num, src, size, 0, 0);\r
}\r
\r
-int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait)\r
+int uart_write_bytes_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));\r
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));\r
- uint8_t* data;\r
- size_t size;\r
- int val;\r
- portTickType ticks_end = xTaskGetTickCount() + ticks_to_wait;\r
- if(xSemaphoreTake(p_uart_obj[uart_num]->rx_mux,(portTickType)ticks_to_wait) != pdTRUE) {\r
- return -1;\r
- }\r
- if(p_uart_obj[uart_num]->rx_cur_remain == 0) {\r
- ticks_to_wait = ticks_end - xTaskGetTickCount();\r
- data = (uint8_t*) xRingbufferReceive(p_uart_obj[uart_num]->rx_ring_buf, &size, (portTickType) ticks_to_wait);\r
- if(data) {\r
- p_uart_obj[uart_num]->rx_head_ptr = data;\r
- p_uart_obj[uart_num]->rx_ptr = data;\r
- p_uart_obj[uart_num]->rx_cur_remain = size;\r
- } else {\r
- xSemaphoreGive(p_uart_obj[uart_num]->rx_mux);\r
- return -1;\r
- }\r
- }\r
- val = *(p_uart_obj[uart_num]->rx_ptr);\r
- p_uart_obj[uart_num]->rx_ptr++;\r
- p_uart_obj[uart_num]->rx_cur_remain--;\r
- if(p_uart_obj[uart_num]->rx_cur_remain == 0) {\r
- vRingbufferReturnItem(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_head_ptr);\r
- p_uart_obj[uart_num]->rx_head_ptr = NULL;\r
- p_uart_obj[uart_num]->rx_ptr = NULL;\r
- if(p_uart_obj[uart_num]->rx_buffer_full_flg) {\r
- BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_data_buf, p_uart_obj[uart_num]->rx_stash_len, 1);\r
- if(res == pdTRUE) {\r
- p_uart_obj[uart_num]->rx_buffer_full_flg = false;\r
- uart_enable_rx_intr(p_uart_obj[uart_num]->uart_num);\r
- }\r
- }\r
- }\r
- xSemaphoreGive(p_uart_obj[uart_num]->rx_mux);\r
- return val;\r
+ UART_CHECK((size > 0), "uart size error", (-1));\r
+ UART_CHECK((src), "uart data null", (-1));\r
+ UART_CHECK((brk_len > 0 && brk_len < 256), "break_num error", (-1));\r
+ return uart_tx_all(uart_num, src, size, 1, brk_len);\r
}\r
\r
int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait)\r
return ESP_OK;\r
}\r
\r
-//-----------------------------------\r
-//Should not enable hw flow control the debug print port.\r
-//Use uart_tx_all_chars() as a thread-safe function to send data.\r
-static int s_uart_print_nport = UART_NUM_0;\r
-static void uart2_write_char(char chr)\r
-{\r
- uart_tx_all_chars(UART_NUM_2, (const char*)&chr, 1);\r
-}\r
-\r
-static void uart1_write_char(char chr)\r
-{\r
- uart_tx_all_chars(UART_NUM_1, (const char*)&chr, 1);\r
-}\r
-\r
-static void uart0_write_char(char chr)\r
-{\r
- uart_tx_all_chars(UART_NUM_0, (const char*)&chr, 1);\r
-}\r
-\r
-static void uart_ignore_char(char chr)\r
-{\r
-\r
-}\r
-\r
-//Only effective to ets_printf function, not ESP_LOGX macro.\r
-esp_err_t uart_set_print_port(uart_port_t uart_num)\r
-{\r
- UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_CHECK((p_uart_obj[uart_num]), "UART driver error", ESP_FAIL);\r
- s_uart_print_nport = uart_num;\r
- switch(s_uart_print_nport) {\r
- case UART_NUM_0:\r
- ets_install_putc1(uart0_write_char);\r
- break;\r
- case UART_NUM_1:\r
- ets_install_putc1(uart1_write_char);\r
- break;\r
- case UART_NUM_2:\r
- ets_install_putc1(uart2_write_char);\r
- break;\r
- case UART_NUM_MAX:\r
- default:\r
- ets_install_putc1(uart_ignore_char);\r
- break;\r
- }\r
- return ESP_OK;\r
-}\r
-\r
-int uart_get_print_port()\r
-{\r
- return s_uart_print_nport;\r
-}\r
-\r
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)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
projects / esp-idf / commitdiff