feat(rmt_uart): update, need squash

Kainarx · Kainarx · commit 8bc6033cd696 · 2025-05-15T18:14:27.000+08:00
diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -52,6 +52,7 @@ body:
         - quirc
         - sh2lib
         - spi_nand_flash
+        - soft_uart
         - supertinycron
         - thorvg
         - zlib
diff --git a/.github/workflows/upload_component.yml b/.github/workflows/upload_component.yml
@@ -63,6 +63,7 @@ jobs:
             quirc;
             sh2lib;
             spi_nand_flash;
+            soft_uart;
             supertinycron;
             thorvg;
             zlib;
diff --git a/.idf_build_apps.toml b/.idf_build_apps.toml
@@ -20,6 +20,7 @@ manifest_file = [
     "pid_ctrl/.build-test-rules.yml",
     "qrcode/.build-test-rules.yml",
     "quirc/.build-test-rules.yml",
+    "soft_uart/.build-test-rules.yml",
     "zlib/.build-test-rules.yml",
     ".build-test-rules.yml",
 ]
diff --git a/rmt_soft_uart/README.md b/rmt_soft_uart/README.md
diff --git a/soft_uart/.build-test-rules.yml b/soft_uart/.build-test-rules.yml
@@ -0,0 +1,4 @@
+soft_uart/example:
+  disable:
+    - if: CONFIG_SOC_RMT_SUPPORTED != 1
+      reason: Relevant only for RMT enabled targets
diff --git a/soft_uart/CHANGELOG.md b/soft_uart/CHANGELOG.md
@@ -0,0 +1,3 @@
+## 1.0.0
+
+- Initial driver version
diff --git a/soft_uart/CMakeLists.txt b/soft_uart/CMakeLists.txt
diff --git a/soft_uart/README.md b/soft_uart/README.md
@@ -0,0 +1,7 @@
+# Software UART
+
+[![Component Registry](https://components.espressif.com/components/espressif/rmt_soft_uart/badge.svg)](https://components.espressif.com/components/espressif/rmt_soft_uart)
+
+This directory contains an implementation for software UART. Currently only RMT is supported as the software UART backend.
+
+To learn more about how to use this component, please check API Documentation from header file [rmt_uart.h](./include/rmt_uart.h).
diff --git a/soft_uart/example/CMakeLists.txt b/soft_uart/example/CMakeLists.txt
@@ -3,4 +3,4 @@ cmake_minimum_required(VERSION 3.16)
 set(COMPONENTS main)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(rmt_soft_uart)
+project(soft_uart)
diff --git a/soft_uart/example/README.md b/soft_uart/example/README.md
@@ -0,0 +1,50 @@
+# Software UART Example (RMT backend)
+
+This example demonstrates how to simulate UART using the [soft_uart](https://components.espressif.com/component/espressif/soft_uart) component.
+
+## How to Use Example
+
+### Hardware Required
+
+* A development board with Espressif SoC
+* A USB cable for Power supply and programming
+* A UART bridge (optional, set the TX and RX pins to be the same as the loopback test if don't have)
+
+### Configure the Example
+
+Before project configuration and build, be sure to set the correct chip target using `idf.py set-target <chip_name>`. Then assign the proper GPIO in the [source file](main/soft_uart_main.c).
+
+### Build and Flash
+
+Run `idf.py -p PORT build flash monitor` to build, flash and monitor the project.
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
+
+## Example Output (loopback test)
+
+```text
+I (248) main_task: Started on CPU0
+I (248) main_task: Calling app_main()
+I (258) rmt-uart: new rmt uart at 0x4087cd38, baud=115200  rmt_resolution=921600
+I (268) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (278) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (288) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (298) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (308) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (318) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (328) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (338) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (348) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (358) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (368) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (378) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (388) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (398) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (408) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (418) rmt_uart_example: Read len: 23, data: RMT UART, transmission
+I (478) rmt_uart_example: UART transmit 16 times!
+I (478) main_task: Returned from app_main()
+
+```
diff --git a/soft_uart/example/main/CMakeLists.txt b/soft_uart/example/main/CMakeLists.txt
diff --git a/soft_uart/example/main/idf_component.yml b/soft_uart/example/main/idf_component.yml
@@ -1,4 +1,4 @@
 dependencies:
-  espressif/rmt_soft_uart:
+  espressif/soft_uart:
     version: "*"
     override_path: "../../"
diff --git a/soft_uart/example/main/soft_uart_main.c b/soft_uart/example/main/soft_uart_main.c
@@ -20,7 +20,6 @@
 
 const char *TAG = "rmt_uart_example";
 
-char sendbuf[100] = {0};
 
 IRAM_ATTR static bool rmt_uart_tx_event_cbs(rmt_uart_device_handle_t tx_unit, const rmt_uart_tx_done_event_data_t *edata, void *user_ctx)
 {
@@ -52,7 +51,7 @@ void uart_read_task(void *pvParameters)
         /* Read from the UART */
         ESP_ERROR_CHECK(rmt_uart_receive(uart_device, (uint8_t *)read_buffer, sizeof(read_buffer)));
         if (xQueueReceive(receive_queue, &rmt_rx_evt_data, portMAX_DELAY)) {
-            int read_len = rmt_uart_decode_data(uart_device, &rmt_rx_evt_data, (uint8_t *)read_buffer, sizeof(read_buffer), false);
+            int read_len = rmt_uart_decode_data(uart_device, &rmt_rx_evt_data, (uint8_t *)read_buffer, sizeof(read_buffer), true);
             if (read_len > 0) {
                 ESP_LOGI(TAG, "Read len: %d, data: %s", read_len, read_buffer);
                 memset(read_buffer, 0, sizeof(read_buffer));
@@ -84,10 +83,11 @@ void app_main(void)
     // create a task to read data from the UART
     xTaskCreate(uart_read_task, "uTask", 4096, uart_device, 4, NULL);
 
-    snprintf(sendbuf, sizeof(sendbuf), "RMT UART, transmission");
+    char sendbuf[100] = "RMT UART, transmission";
     for (int i = 0; i < 16; i++) {
         /* Write few bytes to the UART */
         ESP_ERROR_CHECK(rmt_uart_transmit(uart_device, (uint8_t *)sendbuf, strlen(sendbuf) + 1));
+        vTaskDelay(pdMS_TO_TICKS(10));
     }
 
     int count = 0;
diff --git a/soft_uart/idf_component.yml b/soft_uart/idf_component.yml
@@ -0,0 +1,6 @@
+version: "1.0.0"
+description: Driver for software UART
+url: https://github.com/espressif/idf-extra-components/tree/master/soft_uart
+issues: "https://github.com/espressif/idf-extra-components/issues"
+dependencies:
+  idf: ">=5.0"
diff --git a/soft_uart/include/rmt_uart.h b/soft_uart/include/rmt_uart.h
@@ -20,7 +20,7 @@ extern "C" {
 typedef struct {
     uint32_t baud_rate;                   /*!< UART baud rate*/
     size_t tx_trans_queue_depth;          /*!< UART tx internal transfer queue depth, increase this value can support more transfers pending in the background */
-    size_t rx_buffer_size;                  /*!< UART rx fifo size*/
+    size_t rx_buffer_size;                /*!< UART rx fifo size*/
     rmt_uart_word_length_t data_bits;     /*!< UART byte size*/
     rmt_uart_parity_t parity;             /*!< UART parity mode*/
     rmt_uart_stop_bits_t stop_bits;       /*!< UART stop bits*/
@@ -45,62 +45,51 @@ typedef struct {
 /**
  * @brief Create a new RMT UART controller.
  *
- * This function creates a new RMT UART controller. The controller is used to transmit and receive data
- * over a RMT UART controller.
- *
  * @param[in] uart_config Configuration for the RMT UART controller.
  * @param[out] ret_device Handle to the RMT UART controller.
  *
  * @return
  * - `ESP_OK`: RMT UART controller was successfully created.
  * - `ESP_ERR_INVALID_ARG`: Invalid arguments (e.g., null `uart_config` pointer or `ret_device` pointer).
- * - `ESP_ERR_NO_MEM`: Not enough memory to create the RMT UART controller.
+ * - `ESP_ERR_NO_MEM`: No enough memory to create the RMT UART controller.
  */
 esp_err_t rmt_new_uart_device(const rmt_uart_config_t *uart_config, rmt_uart_device_handle_t *ret_device);
 
 /**
- * @brief Transmit data over a RMT UART controller.
- *
- * This function allows the user to transmit data over a RMT UART controller. The data is encoded and
- * transmitted using the RMT UART controller.
+ * @brief Transmit data over a RMT UART controller. This is a non-blocking function.
  *
+ * @note You can use the `rmt_uart_register_tx_event_callbacks()` function to register a callback function to handle the transmission done event.
  * @param[in] uart_device Handle to the RMT UART controller, which was previously created using
  *                        `rmt_new_uart_device()`.
  * @param[in] data        Pointer to the data to be transmitted.
  * @param[in] size        Size of the data to be transmitted.
  *
  * @return
- * - `ESP_OK`: Data was successfully transmitted.
+ * - `ESP_OK`: Start transmitting successfully.
  * - `ESP_ERR_INVALID_ARG`: Invalid arguments (e.g., null `uart_device` handle or `data` pointer).
  */
 esp_err_t rmt_uart_transmit(rmt_uart_device_handle_t uart_device, const uint8_t *data, size_t size);
 
 /**
- * @brief Receive data over a RMT UART controller.
+ * @brief Receive data over a RMT UART controller. This is a non-blocking function.
  *
- * This function allows the user to receive data over a RMT UART controller. The data is received and
- * decoded using the RMT UART controller.
+ * @note You can use the `rmt_uart_register_rx_event_callbacks()` function to register a callback function to handle the received data.
  *
  * @param[in] uart_device Handle to the RMT UART controller, which was previously created using
  *                        `rmt_new_uart_device()`.
  * @param[in] buf         Pointer to the buffer to store the received data.
  * @param[in] size        Size of the buffer to store the received data.
- * @param[in] ticks_to_wait Timeout value in ticks.
  *
  * @return
- * - `ESP_OK`: Data was successfully received.
+ * - `ESP_OK`: Start receiving successfully.
  * - `ESP_ERR_INVALID_ARG`: Invalid arguments (e.g., null `uart_device` handle or `buf` pointer).
  */
 esp_err_t rmt_uart_receive(rmt_uart_device_handle_t uart_device, uint8_t *buf, size_t size);
 
 /**
  * @brief Delete a RMT UART controller.
  *
- * This function deletes a RMT UART controller. The controller is used to transmit and receive data
- * over a RMT UART controller.
- *
- * @param[in] uart_device Handle to the RMT UART controller, which was previously created using
- *                        `rmt_new_uart_device()`.
+ * @param[in] uart_device Handle to the RMT UART controller, which was previously created by `rmt_new_uart_device()`.
  *
  * @return
  * - `ESP_OK`: RMT UART controller was successfully deleted.
@@ -111,12 +100,10 @@ esp_err_t rmt_delete_uart_device(rmt_uart_device_handle_t uart_device);
 /**
  * @brief Decode RMT UART data.
  *
- * This function decodes RMT UART data. The data is decoded using the RMT UART controller.
+ * @note After receiving the RMT UART symbols, you can use this function to decode the data.
  *
- * @param[in] uart_device Handle to the RMT UART controller, which was previously created using
- *                        `rmt_new_uart_device()`.
- * @param[in] rmt_symbols Pointer to the RMT symbols to be decoded.
- * @param[in] symbol_num  Number of RMT symbols to be decoded.
+ * @param[in] uart_device Handle to the RMT UART controller, which was previously created by `rmt_new_uart_device()`.
+ * @param[in] rmt_rx_evt_data Pointer to the RMT UART receive event data.
  * @param[in] rx_buf      Pointer to the buffer to store the decoded data.
  * @param[in] rx_buf_size Size of the buffer to store the decoded data.
  * @param[in] continue_on_error Whether to continue decoding on error.
@@ -127,14 +114,12 @@ esp_err_t rmt_delete_uart_device(rmt_uart_device_handle_t uart_device);
 int rmt_uart_decode_data(rmt_uart_device_handle_t uart_device, rmt_uart_rx_done_event_data_t *rmt_rx_evt_data, uint8_t *rx_buf, size_t rx_buf_size, bool continue_on_error);
 
 /**
- * @brief Register tx event callback functions for a RMT UART controller.
+ * @brief Register rx event callback functions for a RMT UART controller.
  *
- * This function allows the user to register callback functions to handle specific RMT UART events, such as
- * transmission or reception completion. The callbacks provide a mechanism to handle asynchronous events
- * generated by the RMT UART controller.
+ * @note This function allows the user to register callback functions to handle specific RMT UART reception completion event.
+ *       The callbacks provide a mechanism to handle asynchronous events generated by the RMT UART controller.
  *
- * @param[in] uart_device Handle to the RMT UART controller, which was previously created using
- *                        `rmt_new_uart_device()`.
+ * @param[in] uart_device Handle to the RMT UART controller, which was previously created by `rmt_new_uart_device()`.
  * @param[in] cbs         Pointer to a `rmt_uart_event_rx_callbacks_t` structure that defines the callback
  *                        functions to be registered. This structure includes pointers to the callback
  *                        functions for handling RMT UART events.
@@ -143,20 +128,18 @@ int rmt_uart_decode_data(rmt_uart_device_handle_t uart_device, rmt_uart_rx_done_
  *                        specific to the application.
  *
  * @return
- * - `ESP_OK`: Event callbacks were successfully registered.
+ * - `ESP_OK`: Register event callbacks successfully.
  * - `ESP_ERR_INVALID_ARG`: Invalid arguments (e.g., null `uart_device` handle or `cbs` pointer).
  */
 esp_err_t rmt_uart_register_rx_event_callbacks(rmt_uart_device_handle_t uart_device, const rmt_uart_event_rx_callbacks_t *cbs, void *user_data);
 
 /**
- * @brief Register rx event callback functions for a RMT UART controller.
+ * @brief Register tx event callback functions for a RMT UART controller.
  *
- * This function allows the user to register callback functions to handle specific RMT UART events, such as
- * transmission or reception completion. The callbacks provide a mechanism to handle asynchronous events
- * generated by the RMT UART controller.
+ * @note This function allows the user to register callback functions to handle specific RMT UART transmission completion event.
+ *       The callbacks provide a mechanism to handle asynchronous events generated by the RMT UART controller.
  *
- * @param[in] uart_device Handle to the RMT UART controller, which was previously created using
- *                        `rmt_new_uart_device()`.
+ * @param[in] uart_device Handle to the RMT UART controller, which was previously created by `rmt_new_uart_device()`.
  * @param[in] cbs         Pointer to a `rmt_uart_event_tx_callbacks_t` structure that defines the callback
  *                        functions to be registered. This structure includes pointers to the callback
  *                        functions for handling RMT UART events.
@@ -165,7 +148,7 @@ esp_err_t rmt_uart_register_rx_event_callbacks(rmt_uart_device_handle_t uart_dev
  *                        specific to the application.
  *
  * @return
- * - `ESP_OK`: Event callbacks were successfully registered.
+ * - `ESP_OK`: Register event callbacks successfully.
  * - `ESP_ERR_INVALID_ARG`: Invalid arguments (e.g., null `uart_device` handle or `cbs` pointer).
  */
 esp_err_t rmt_uart_register_tx_event_callbacks(rmt_uart_device_handle_t uart_device, const rmt_uart_event_tx_callbacks_t *cbs, void *user_data);
diff --git a/soft_uart/include/rmt_uart_type.h b/soft_uart/include/rmt_uart_type.h
@@ -28,14 +28,12 @@ typedef enum {
 } rmt_uart_word_length_t;
 
 typedef enum {
-    RMT_UART_STOP_BITS_1   = 0x1,  /*!< stop bit: 1bit*/
-    RMT_UART_STOP_BITS_2   = 0x2,  /*!< stop bit: 2bits*/
+    RMT_UART_STOP_BITS_1   = 0x0,  /*!< stop bit: 1bit*/
+    RMT_UART_STOP_BITS_2   = 0x1,  /*!< stop bit: 2bits*/
 } rmt_uart_stop_bits_t;
 
 typedef enum {
     RMT_UART_PARITY_DISABLE = 0x0,  /*!< Disable UART parity*/
-    RMT_UART_PARITY_EVEN    = 0x1,  /*!< Enable UART even parity*/
-    RMT_UART_PARITY_ODD     = 0x2,  /*!< Enable UART odd parity*/
 } rmt_uart_parity_t;
 
 /**
diff --git a/soft_uart/src/rmt_uart.c b/soft_uart/src/rmt_uart.c
diff --git a/soft_uart/src/rmt_uart_encoder.c b/soft_uart/src/rmt_uart_encoder.c
diff --git a/soft_uart/src/rmt_uart_encoder.h b/soft_uart/src/rmt_uart_encoder.h

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ manifest_file = [`
`20`	`20`	`"pid_ctrl/.build-test-rules.yml",`
`21`	`21`	`"qrcode/.build-test-rules.yml",`
`22`	`22`	`"quirc/.build-test-rules.yml",`
	`23`	`+ "soft_uart/.build-test-rules.yml",`
`23`	`24`	`"zlib/.build-test-rules.yml",`
`24`	`25`	`".build-test-rules.yml",`
`25`	`26`	`]`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+## 1.0.0`
	`2`	`+`
	`3`	`+- Initial driver version`