UART Introduction<\/h2>\n\n\n\n
UART communication also known as Universal Asynchronous Receive Transmit or Serial communication is one of the simplest and commonly used communication protocols used between two devices. Data transfer between the two devices is via transmission and receiving lines which are connected with the two devices. Data is transferred in the form of bits from one device to another, bit by bit. One of the key advantages of using this communication protocol is that the two devices which are communicating need not be at the same operating frequency. However, it is necessary to se the same baud rate for both the devices in order for the instructions to be understood by them.<\/p>\n\n\n\n
The ESP32 development consists of three UART ports commonly referred as UART0, UART1, and UART2. These three serial interfaces are hardware supported and work at 3.3V TTL level. Each of them exposes 4 pins: RX, TX, RTS and CTS. <\/p>\n\n\n\n
ESP32 UART ESP-IDF APIs<\/h2>\n\n\n\n
Now let us discuss the UART driver library and its functions provided by ESP-IDF to establish communication between UART devices such as ESP32 and USB-TTL converter. <\/p>\n\n\n\n
ESP-IDF provides driver\/uart.h library that is required for UART communication. Let\u2019s show you the steps using the API provided by this library to successfully setup UART communication.<\/p>\n\n\n\n
This is the header file that is required to include the UART driver:<\/p>\n\n\n\n
#include \"driver\/uart.h\"<\/code><\/pre>\n\n\n\nSet Communication Parameters<\/h3>\n\n\n\n
The first step is to setup the UART communication parameters. These include the following:<\/p>\n\n\n\n
- Baud Rate<\/li>
- Data Bits<\/li>
- Parity Control<\/li>
- Number of stop Bits<\/li>
- Hardware Flow Control Mode<\/li>
- Communication Mode<\/li><\/ul>\n\n\n\n
There are generally two methods to set these communication methods.<\/p>\n\n\n\n
In the first method which is more commonly used, we configure all the parameters in a single step. This is done by first creating a structure uart_config_t<\/strong> that contains all the definitions of the required parameters. And then calling the function uart_param_config()<\/strong> which takes in the UART port and the above structure as parameters inside it. This will configure the UART parameters.<\/p>\n\n\n\nconst uart_port_t uart_num = UART_NUM_2;\nuart_config_t uart_config = {\n .baud_rate = 115200,\n .data_bits = UART_DATA_8_BITS,\n .parity = UART_PARITY_DISABLE,\n .stop_bits = UART_STOP_BITS_1,\n .flow_ctrl = UART_HW_FLOWCTRL_CTS_RTS,\n .rx_flow_ctrl_thresh = 122,\n};\n\/\/ Configure UART parameters\nESP_ERROR_CHECK(uart_param_config(uart_num, &uart_config));<\/code><\/pre>\n\n\n\nThe second method involves calling separate functions to configure each of the parameters. The table below shows the parameters and their corresponding configuration functions.<\/p>\n\n\n\nBaud Rate<\/td> uart_set_baudrate()<\/td><\/tr> Number of Transmitted Bits<\/td> uart_set_word_length() selected out of uart_word_length_t<\/td><\/tr> Parity Control<\/td> uart_set_parity() selected out of uart_parity_t<\/td><\/tr> Number of Stop Bits<\/td> uart_set_stop_bits() selected out of uart_stop_bits_t<\/td><\/tr> Hardware Flow Control Mode<\/td> uart_set_hw_flow_ctrl() selected out of uart_hw_flowcontrol_t<\/td><\/tr> Communication Mode<\/td> uart_set_mode() selected out of uart_mode_t<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nSet Communication Pins<\/h3>\n\n\n\n
In this step, we assign the physical pins that will allow UART communication to establish between two devices by connecting them. <\/p>\n\n\n\n
The uart_set_pin()<\/strong> function is called to set the TX, RX, RTS and CTS pins which we pass as parameters inside it. This function takes in five parameters. The first parameter is the UART port number. The second parameter is the GPIO pin that we want to set up as the TX pin. The third parameter is the GPIO pin that we want to set up as the RX pin. Likewise, the fourth parameter is the GPIO pin that we want to set up as the RTS pin. Finally, the last parameter is the GPIO pin that we want to set up as the CTS pin. The driver will route the GPIO pins that we specify to the respective TX, RX, RTS and CTS signals.<\/p>\n\n\n\nesp_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)<\/code><\/pre>\n\n\n\nIn the following function, we are setting GPIO4 as TX, GPIO5 as RX, GPIO18 as RTS and GPIO19 as CTS, for UART2.<\/p>\n\n\n\n
ESP_ERROR_CHECK(uart_set_pin(UART_NUM_2, 4, 5, 18, 19));<\/code><\/pre>\n\n\n\nInstall Driver<\/h3>\n\n\n\n
Next, we assign the resources of ESP32 for the UART driver. This stage marks the completion of the UART configuration. We use the function, uart_driver_install()<\/strong> to assign the necessary internal resources for the UART driver. It takes in five parameters. The first parameter is the UART port number. The rest of the parameters are listed below in order:<\/p>\n\n\n\n- rx_buffer_size (Size of RX ring buffer)<\/li>
- tx_buffer_size (Size of TX ring buffer)<\/li>
- queue_size (UART event queue size)<\/li>
- uart_queue (UART event queue handle)<\/li>
- intr_alloc_flags (Flags to allocate an interrupt)<\/li><\/ol>\n\n\n\n
esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, QueueHandle_t *uart_queue, int intr_alloc_flags)<\/code><\/pre>\n\n\n\nFirst we setup UART buffered IO with event queue as follows:<\/p>\n\n\n\n
const int uart_buffer_size = (1024 * 2);\nQueueHandle_t uart_queue;<\/code><\/pre>\n\n\n\nNext, we install the driver by using the event queue:<\/p>\n\n\n\n
ESP_ERROR_CHECK(uart_driver_install(UART_NUM_2, uart_buffer_size, \\\n uart_buffer_size, 10, &uart_queue, 0));<\/code><\/pre>\n\n\n\nSend and Receive Data<\/h3>\n\n\n\n
This stage denotes the start of the UART operation. The UART controller has a finite state machine commonly known as FSM that controls the UART communication. The FSM takes care of all the process whereby the application just reads and writes data to a specific buffer. Lets look at each of these steps. <\/p>\n\n\n\n
Transmission<\/h4>\n\n\n\n
To send data serially, we first write the data to the TX FIFO buffer. The FSM then serializes this data and sends it out. We use the function, uart_write_bytes()<\/strong> to write the data to the TX ring buffer first. When there is available space in the TX FIFO buffer, this data is shifted from the ring buffer to the FIFO buffer. This process occurs behind the scene through an interrupt service routine.<\/p>\n\n\n\nThe uart_write_bytes() takes in three parameters. the first parameter is the UART port number. The second parameter is the address of the data buffer and the third parameter is the length of the data to be sent. <\/p>\n\n\n\n
int uart_write_bytes(uart_port_t uart_num, const void *src, size_t size)<\/code><\/pre>\n\n\n\nBelow you can view the code which shows how to use of this function to transmit the message ‘Welcome to esp32tutorials.’<\/p>\n\n\n\n
char* message = \"Welcome to esp32tutorials\\n\";\nuart_write_bytes(uart_num, (const char*)message, strlen(message));<\/code><\/pre>\n\n\n\nReception<\/h4>\n\n\n\n
Likewise, to receive the data serially, the FSM first processes this incoming data and parallelizes it. It then writes the data to the RX FIFO buffer. Finally, this data is read from the RX FIFO buffer. To red the data already present in the RX FIFO buffer, we use the function uart_read_bytes()<\/strong>. This function takes in four parameters. The first parameter is the UART port number. The second parameter is the pointer to the buffer. The third parameter is the length of the data and the last parameter is the count in RTOS ticks.<\/p>\n\n\n\nint uart_read_bytes(uart_port_t uart_num, void *buf, uint32_t length, TickType_t ticks_to_wait)<\/code><\/pre>\n\n\n\nESP-IDF UART Echo Example<\/strong> ESP-IDF<\/h2>\n\n\n\nIn this section, we will build and test a project using the UART driver described in the previously. We will use the UART Echo example provided by ESP-IDF. Through this example we will show you how to use UART interfaces. For demonstration, the data received on the configured UART will be echoed back to the sender.<\/p>\n\n\n\n
Create Example Project<\/h3>\n\n\n\n
Open your VS Code and head over to View > Command Palette<\/strong>. Type ESP-IDF: New Project<\/strong> in the search bar and press enter.<\/p>\n\n\n\nSpecify the project name and directory. We have named our project ‘ESP_IDF_UART_ECHO.\u2019 For the ESP-IDF board, we have chosen the custom board option. For ESP-IDF target, we have chosen ESP32 module. Click \u2018Choose Template\u2019 button to proceed forward.<\/p>\n\n\n
\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-1.jpg?resize=1024%2C636&ssl=1\")
<\/figure>\n<\/div>\n\n\nIn the Extension, select ESP-IDF option:<\/p>\n\n\n
\n![\"ESP-IDF](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/06\/ESP-IDF-in-VS-Code-New-Project-2.jpg?resize=1024%2C417&ssl=1\")
<\/figure>\n<\/div>\n\n\nWe will click the \u2018softAP<\/strong>\u2019 under the uart tab. Now click \u2018Create project using template uart_echo<\/strong>.’<\/p>\n\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-2.jpg?resize=1024%2C383&ssl=1\")
<\/figure>\n<\/div>\n\n\nYou will get a notification that the project has been created. To open the project in a new window, click \u2018Yes.\u2019<\/p>\n\n\n\n
This opens our ESP_IDF_UART_ECHO project that we created, inside the EXPLORER tab. There are several folders inside our project folder. This is the same for every project which you will create through ESP-IDF Explorer.<\/p>\n\n\n\n
ESP-IDF SDK Configuration Editor<\/h3>\n\n\n\n
Lets first head over to the menuconfig<\/strong>. Click the icon shown below. It opens the ESP-IDF SDK Configuration Editor. <\/p>\n\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-Menuconfig-1.jpg?resize=1024%2C640&ssl=1\")
<\/figure>\n<\/div>\n\n\nScroll down and open the Echo Example Configuration<\/strong> for our project. Here we can set the UART configuration parameter according to our needs. This includes the UART port number, UART communication speed (baud rate), UART RX pin, UART TX pin and the stack size for the task. Here you can view that by default, ESP-IDF is using UART port number 2 (UART2), baud rate of 115200, RX pin as GPIO5, TX pin as GPIO4 and task stack size as 2048. You can alter these parameters and then click the Save button found at the top. We will leave the configuration settings as default.<\/p>\n\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-Menuconfig-2.jpg?resize=1024%2C585&ssl=1\")
<\/figure>\n<\/div>\n\n\nLets head over to the main.c file. The main folder contains the source code meaning the main.c file will be found here.<\/p>\n\n\n\n
Now go to main > uart_echo_example_main.c <\/strong>and open it. <\/p>\n\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-main.c-file.jpg?resize=1024%2C567&ssl=1\")
<\/figure>\n<\/div>\n\n\nThe following code opens up which is shown below. This example code will demonstrate UART Echo. It will echo the received message on UART2 back to the sender.<\/p>\n\n\n\n
ESP-IDF Code: ESP32 UART Echo<\/h3>\n\n\n\n\/* UART Echo Example\n\n This example code is in the Public Domain (or CC0 licensed, at your option.)\n\n Unless required by applicable law or agreed to in writing, this\n software is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n CONDITIONS OF ANY KIND, either express or implied.\n*\/\n#include <stdio.h>\n#include \"freertos\/FreeRTOS.h\"\n#include \"freertos\/task.h\"\n#include \"driver\/uart.h\"\n#include \"driver\/gpio.h\"\n#include \"sdkconfig.h\"\n\n\/**\n * This is an example which echos any data it receives on configured UART back to the sender,\n * with hardware flow control turned off. It does not use UART driver event queue.\n *\n * - Port: configured UART\n * - Receive (Rx) buffer: on\n * - Transmit (Tx) buffer: off\n * - Flow control: off\n * - Event queue: off\n * - Pin assignment: see defines below (See Kconfig)\n *\/\n\n#define ECHO_TEST_TXD (CONFIG_EXAMPLE_UART_TXD)\n#define ECHO_TEST_RXD (CONFIG_EXAMPLE_UART_RXD)\n#define ECHO_TEST_RTS (UART_PIN_NO_CHANGE)\n#define ECHO_TEST_CTS (UART_PIN_NO_CHANGE)\n\n#define ECHO_UART_PORT_NUM (CONFIG_EXAMPLE_UART_PORT_NUM)\n#define ECHO_UART_BAUD_RATE (CONFIG_EXAMPLE_UART_BAUD_RATE)\n#define ECHO_TASK_STACK_SIZE (CONFIG_EXAMPLE_TASK_STACK_SIZE)\n\n#define BUF_SIZE (1024)\n\nstatic void echo_task(void *arg)\n{\n \/* Configure parameters of an UART driver,\n * communication pins and install the driver *\/\n uart_config_t uart_config = {\n .baud_rate = ECHO_UART_BAUD_RATE,\n .data_bits = UART_DATA_8_BITS,\n .parity = UART_PARITY_DISABLE,\n .stop_bits = UART_STOP_BITS_1,\n .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,\n .source_clk = UART_SCLK_APB,\n };\n int intr_alloc_flags = 0;\n\n#if CONFIG_UART_ISR_IN_IRAM\n intr_alloc_flags = ESP_INTR_FLAG_IRAM;\n#endif\n\n ESP_ERROR_CHECK(uart_driver_install(ECHO_UART_PORT_NUM, BUF_SIZE * 2, 0, 0, NULL, intr_alloc_flags));\n ESP_ERROR_CHECK(uart_param_config(ECHO_UART_PORT_NUM, &uart_config));\n ESP_ERROR_CHECK(uart_set_pin(ECHO_UART_PORT_NUM, ECHO_TEST_TXD, ECHO_TEST_RXD, ECHO_TEST_RTS, ECHO_TEST_CTS));\n\n \/\/ Configure a temporary buffer for the incoming data\n uint8_t *data = (uint8_t *) malloc(BUF_SIZE);\n\n while (1) {\n \/\/ Read data from the UART\n int len = uart_read_bytes(ECHO_UART_PORT_NUM, data, BUF_SIZE, 20 \/ portTICK_RATE_MS);\n \/\/ Write data back to the UART\n uart_write_bytes(ECHO_UART_PORT_NUM, (const char *) data, len);\n }\n}\n\nvoid app_main(void)\n{\n xTaskCreate(echo_task, \"uart_echo_task\", ECHO_TASK_STACK_SIZE, NULL, 10, NULL);\n}\n<\/code><\/pre>\n\n\n\nHow the Code Works?<\/h3>\n\n\n\n
Firstly, we will start by including the necessary libraries that includes the FreeRTOS libraries to generate delays and create tasks, driver\/gpio.h as we have to assign signals of a UART peripheral to ESP32 GPIO pins and driver\/uart.h for the UART communication.<\/p>\n\n\n\n
#include <stdio.h>\n#include \"freertos\/FreeRTOS.h\"\n#include \"freertos\/task.h\"\n#include \"driver\/uart.h\"\n#include \"driver\/gpio.h\"\n#include \"sdkconfig.h\"<\/code><\/pre>\n\n\n\nThen we have defined several variables including the RX, TX, RTS and CTS pins, baud rate, UAT port number and task stack size. These variables will access the values that we set in the menuconfig previously so the values are already defined.<\/p>\n\n\n\n
#define ECHO_TEST_TXD (CONFIG_EXAMPLE_UART_TXD)\n#define ECHO_TEST_RXD (CONFIG_EXAMPLE_UART_RXD)\n#define ECHO_TEST_RTS (UART_PIN_NO_CHANGE)\n#define ECHO_TEST_CTS (UART_PIN_NO_CHANGE)\n\n#define ECHO_UART_PORT_NUM (CONFIG_EXAMPLE_UART_PORT_NUM)\n#define ECHO_UART_BAUD_RATE (CONFIG_EXAMPLE_UART_BAUD_RATE)\n#define ECHO_TASK_STACK_SIZE (CONFIG_EXAMPLE_TASK_STACK_SIZE)<\/code><\/pre>\n\n\n\nMoreover, we will define the Buffer size in this code. It is 1024 bytes or approximately 1 Kilobyte.<\/p>\n\n\n\n
#define BUF_SIZE (1024)<\/code><\/pre>\n\n\n\necho_task()<\/h4>\n\n\n\n
Next we have the function echo_task(). It consists of a uart_config_t <\/strong>structure that contains all the necessary parameters for UART communication. It will be later on passed as a parameter inside the uart_param_confg()<\/strong> function, when we configure the UART communication parameters. The configuration used is 8 data bits, no parity bit and 1 stop bit (8-N-1) with the baud rate of 115200. Moreover, the UART source clock is set to APB.<\/p>\n\n\n\nstatic void echo_task(void *arg)\n{\n uart_config_t uart_config = {\n .baud_rate = ECHO_UART_BAUD_RATE,\n .data_bits = UART_DATA_8_BITS,\n .parity = UART_PARITY_DISABLE,\n .stop_bits = UART_STOP_BITS_1,\n .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,\n .source_clk = UART_SCLK_APB,\n };<\/code><\/pre>\n\n\n\nInstall Driver<\/h4>\n\n\n\n
Next, we call the uart_driver_install() function to install the UART driver. It takes in six parameters as described below:<\/p>\n\n\n\n
- uart_port_t<\/strong>: This is the UART port number that we set up in menuconfig. We are using the default settings hence it is UART2 in our case.<\/li>
- int rx_buffer_size<\/strong>: This is the size of the buffer which we defined as 1024 bytes multiplied by 2. <\/li>
- int tx_buffer_size<\/strong>: This is the size of the TX buffer which is set to 0 in our case. This means that until all of the data is sent out, the driver will not use this buffer.<\/li>
- int queue_size<\/strong>: This is the UART event queue size which is set to 0 as no queues are being used.<\/li>
- QueueHandle_t *uart_queue<\/strong>: This is the UART event queue handle which is NULL in our case due to presence of no queues in this example.<\/li>
- int intr_alloc_flags<\/strong>: This is the flag that is assigned to an interrupt. As we are not using interrupt in this example, hence it is set as NULL.<\/li><\/ul>\n\n\n\n
ESP_ERROR_CHECK(uart_driver_install(ECHO_UART_PORT_NUM, BUF_SIZE * 2, 0, 0, NULL, intr_alloc_flags));<\/code><\/pre>\n\n\n\nConfigure UART Parameters<\/h4>\n\n\n\n
Next, we call the uart_param_config() function, to set the UART configuration parameters. It takes in two parameters. The first parameter is the UART port number and the second parameter is the UART parameter settings that we setup in the echo_task() function.<\/p>\n\n\n\n
ESP_ERROR_CHECK(uart_param_config(ECHO_UART_PORT_NUM, &uart_config));<\/code><\/pre>\n\n\n\nSet Communication Pins<\/h4>\n\n\n\n
To set the UART communication (TX, RX, RTS and CTS) pins, we will use the uart_set_pin() function and specify the GPIOs as parameters inside it. In our case, the driver will allocate signals of TX, RX, RTS and CTS to the corresponding GPIO pins that we set respectively. <\/p>\n\n\n\n
ESP_ERROR_CHECK(uart_set_pin(ECHO_UART_PORT_NUM, ECHO_TEST_TXD, ECHO_TEST_RXD, ECHO_TEST_RTS, ECHO_TEST_CTS));<\/code><\/pre>\n\n\n\nWe will create a temporary buffer for the arriving data by allocating dynamic memory.<\/p>\n\n\n\n
uint8_t *data = (uint8_t *) malloc(BUF_SIZE);<\/code><\/pre>\n\n\n\nRunning UART Communication<\/h4>\n\n\n\n
Inside the while loop we will read data from UART2 by calling the uart_read_bytes() function and save it in the int variable ‘len.’ Then we will write this data (len) back to the UART using uart_write_bytes().<\/p>\n\n\n\n
while (1) {\n int len = uart_read_bytes(ECHO_UART_PORT_NUM, data, BUF_SIZE, 20 \/ portTICK_RATE_MS);\n uart_write_bytes(ECHO_UART_PORT_NUM, (const char *) data, len);\n }<\/code><\/pre>\n\n\n\napp_main()<\/h4>\n\n\n\n
Inside the main() function, we will create the task. To create a task, use the function xTaskCreate()<\/strong>. This function takes in several arguments.<\/p>\n\n\n\n- The first argument is the name of the function. In our case, we have set it to echo_task.<\/li>
- The second argument is the name of the task for descriptive purposes. In our case we set the second argument as \u201cuart_echo_task.\u201d<\/li>
- The third argument specifies the stack size of the task. This indicates the amount of memory we want to reserve for the particular task. We have set it to \u20182048\u2019 which was the default value.<\/li>
- The fourth argument is the parameter. It is a value that is passed as the parameter to the created task. This can be used to specify a variable that is being used in the main function and whose value needs to be added to the task. In our case, we will set this argument as NULL which indicates that we are not using this property.<\/li>
- The fifth argument is the priority of the task. We have set it to \u201910.\u2019<\/li>
- The last argument is the handle which is used to change the function of the task eg. suspend, delete, resume, get or set a config of task. This works as a pointer therefore the ampersand symbol is used with it. It is optional so we can also set it to NULL. In our case we have set it to NULL.<\/li><\/ul>\n\n\n\n
void app_main(void)\n{\n xTaskCreate(echo_task, \"uart_echo_task\", ECHO_TASK_STACK_SIZE, NULL, 10, NULL);\n}<\/code><\/pre>\n\n\n\nCompiling the Sketch<\/h3>\n\n\n\n
To flash your chip, type the following command in the serial terminal. Remember to replace the COM port with the one through which your board is connected.<\/p>\n\n\n\n
idf.py -p COMX flash monitor<\/code><\/pre>\n\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-flash-chip.jpg?resize=1024%2C644&ssl=1\")
<\/figure>\n<\/div>\n\n\nAfter the code flashes successfully, connect your ESP32 with a USB to TTL converter. Use the following connections to connect both the devices together.<\/p>\n\n\n\n
![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-Serial-Terminal-1.jpg?resize=640%2C583&ssl=1\")
<\/figure>\n<\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Echo-ESP-IDF-Project-Serial-Terminal-2.jpg?resize=653%2C291&ssl=1\")
<\/figure>\n<\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Async-RX-TX-Tasks-ESP-IDF-Project-1.jpg?resize=1024%2C636&ssl=1\")
<\/figure>\n<\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Async-RX-TX-Tasks-ESP-IDF-Project-2.jpg?resize=1024%2C372&ssl=1\")
<\/figure>\n<\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Async-RX-TX-Tasks-ESP-IDF-Project-3.jpg?resize=1024%2C684&ssl=1\")
<\/figure>\n<\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Async-RX-TX-Tasks-ESP-IDF-Project-Serial-Terminal.jpg?resize=918%2C560&ssl=1\")
<\/figure>\n\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Async-RX-TX-Tasks-ESP-IDF-Project-Serial-Terminal-1.jpg?resize=1024%2C485&ssl=1\")
<\/figure>\n<\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Async-RX-TX-Tasks-ESP-IDF-Project-Serial-Terminal-2.jpg?resize=962%2C658&ssl=1\")
<\/figure>\n<\/div>\n\n\n![\"ESP32](\"https:\/\/i0.wp.com\/esp32tutorials.com\/wp-content\/uploads\/2022\/08\/ESP32-UART-Async-RX-TX-Tasks-ESP-IDF-Project-Serial-Terminal-3-1.jpg?resize=1024%2C377&ssl=1\")
<\/figure>\n<\/div>\n\n\n