Merge branch 'serial_config' into 'master'

Serial config

Serial interface can be now configured by passing config structure upon initialization.
loader_port_change_baudrate() function has been moved to serial_io.h for convenience.

See merge request espressif/esp-serial-flasher!5

README.md

@@ -20,6 +20,7 @@ Following functions are part of serial_io.h header for convenience, however, use
 
 * loader_port_serial_init()
 * loader_port_serial_deinit()
+* loader_port_change_baudrate()
 * loader_port_reset_target()
 * loader_port_debug_print()
 

example/main/serial_flash_example_main.c

@@ -13,6 +13,8 @@
 #include "esp_spiffs.h"
 #include "esp_loader.h"
 #include "serial_io.h"
+#include "driver/gpio.h"
+#include "driver/uart.h"
 #include <sys/param.h>
 
 
@@ -22,8 +24,6 @@ const uint32_t HIGHER_BAUD_RATE = 921600;
 const uint32_t APP_START_ADDRESS = 0x10000;
 static uint8_t payload[1024];
 
-esp_loader_error_t loader_port_change_baudrate(uint32_t baudrate);
-
 
 static void flash_binary(FILE *image, size_t image_size)
 {
@@ -132,8 +132,18 @@ static FILE *get_image_and_its_size(size_t *image_size)
 
 void app_main(void)
 {
+
+    const loader_serial_config_t config = {
+        .baud_rate = 115200,
+        .uart_port = UART_NUM_1,
+        .uart_rx_pin = GPIO_NUM_5,
+        .uart_tx_pin = GPIO_NUM_4,
+        .reset_trigger_pin = GPIO_NUM_25,
+        .gpio0_trigger_pin = GPIO_NUM_26,
+    };
+
     // Initialize UART
-    esp_loader_error_t err = loader_port_serial_init(115200);
+    esp_loader_error_t err = loader_port_serial_init(&config);
     if (err != ESP_LOADER_SUCCESS) {
         ESP_LOGE(TAG, "serial initialization failed.");
         return;

include/serial_io.h

@@ -22,6 +22,16 @@
 extern "C" {
 #endif
 
+typedef struct
+{
+  uint32_t baud_rate;
+  uint32_t uart_port;
+  uint32_t uart_rx_pin;
+  uint32_t uart_tx_pin;
+  uint32_t reset_trigger_pin;
+  uint32_t gpio0_trigger_pin;
+} loader_serial_config_t;
+
 /**
   * @brief Initializes serial interface.
   *
@@ -31,14 +41,18 @@ extern "C" {
   *     - ESP_LOADER_SUCCESS Success
   *     - ESP_LOADER_ERROR_FAIL Initialization failure
   */
-esp_loader_error_t loader_port_serial_init(uint32_t baud_rate);
-
+esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config);
 
 /**
   * @brief Deinitialize serial interface.
   */
 void loader_port_serial_deinit(void);
 
+/**
+  * @brief Changes baud rate of serial peripheral.
+  */
+esp_loader_error_t loader_port_change_baudrate(uint32_t baudrate);
+
 /**
   * @brief Writes data to serial interface.
   *

port/esp32_uart.c

@@ -24,13 +24,6 @@
 
 // #define SERIAL_DEBUG_ENABLE
 
-#define UART_TXD_PIN        GPIO_NUM_4
-#define UART_RXD_PIN        GPIO_NUM_5
-#define UART_PORT           UART_NUM_1
-
-#define RESET_TRIGER_PIN    GPIO_NUM_25
-#define GPIO0_TRIGER_PIN    GPIO_NUM_26
-
 #ifdef SERIAL_DEBUG_ENABLE
 void serial_debug_print(const uint8_t *data, uint16_t size)
 {
@@ -41,13 +34,19 @@ void serial_debug_print(const uint8_t *data, uint16_t size) { }
 #endif
 
 static int64_t s_time_end;
+static int32_t s_uart_port;
+static int32_t s_reset_trigger_pin;
+static int32_t s_gpio0_trigger_pin;
 
-
-esp_loader_error_t loader_port_serial_init(uint32_t baud_rate)
+esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config)
 {
+    s_uart_port = config->uart_port;
+    s_reset_trigger_pin = config->reset_trigger_pin;
+    s_gpio0_trigger_pin = config->gpio0_trigger_pin;
+
     // Initialize UART
     uart_config_t uart_config = {
-        .baud_rate = baud_rate,
+        .baud_rate = config->baud_rate,
         .data_bits = UART_DATA_8_BITS,
         .parity    = UART_PARITY_DISABLE,
         .stop_bits = UART_STOP_BITS_1,
@@ -57,24 +56,24 @@ esp_loader_error_t loader_port_serial_init(uint32_t baud_rate)
     const int rx_buffer_size = 2 * 200;
     const int tx_buffer_size = 2 * 200;
 
-    if ( uart_param_config(UART_PORT, &uart_config) != ESP_OK ) {
+    if ( uart_param_config(s_uart_port, &uart_config) != ESP_OK ) {
         return ESP_LOADER_ERROR_FAIL;
     }
-    if ( uart_set_pin(UART_PORT, UART_TXD_PIN, UART_RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE) != ESP_OK ) {
+    if ( uart_set_pin(s_uart_port, config->uart_tx_pin, config->uart_rx_pin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE) != ESP_OK ) {
         return ESP_LOADER_ERROR_FAIL;
     }
-    if ( uart_driver_install(UART_PORT, rx_buffer_size, tx_buffer_size, 0, NULL, 0) != ESP_OK ) {
+    if ( uart_driver_install(s_uart_port, rx_buffer_size, tx_buffer_size, 0, NULL, 0) != ESP_OK ) {
         return ESP_LOADER_ERROR_FAIL;
     }
 
     // Initialize boot pin selection pins
-    gpio_pad_select_gpio(RESET_TRIGER_PIN);
-    gpio_set_pull_mode(RESET_TRIGER_PIN, GPIO_PULLUP_ONLY);
-    gpio_set_direction(RESET_TRIGER_PIN, GPIO_MODE_OUTPUT);
+    gpio_pad_select_gpio(s_reset_trigger_pin);
+    gpio_set_pull_mode(s_reset_trigger_pin, GPIO_PULLUP_ONLY);
+    gpio_set_direction(s_reset_trigger_pin, GPIO_MODE_OUTPUT);
 
-    gpio_pad_select_gpio(GPIO0_TRIGER_PIN);
-    gpio_set_pull_mode(GPIO0_TRIGER_PIN, GPIO_PULLUP_ONLY);
-    gpio_set_direction(GPIO0_TRIGER_PIN, GPIO_MODE_OUTPUT);
+    gpio_pad_select_gpio(s_gpio0_trigger_pin);
+    gpio_set_pull_mode(s_gpio0_trigger_pin, GPIO_PULLUP_ONLY);
+    gpio_set_direction(s_gpio0_trigger_pin, GPIO_MODE_OUTPUT);
 
     return ESP_LOADER_SUCCESS;
 }
@@ -84,8 +83,8 @@ esp_loader_error_t loader_port_serial_write(const uint8_t *data, uint16_t size,
 {
     serial_debug_print(data, size);
 
-    uart_write_bytes(UART_PORT, (const char *)data, size);
-    esp_err_t err = uart_wait_tx_done(UART_PORT, pdMS_TO_TICKS(timeout));
+    uart_write_bytes(s_uart_port, (const char *)data, size);
+    esp_err_t err = uart_wait_tx_done(s_uart_port, pdMS_TO_TICKS(timeout));
     
     if (err == ESP_OK) {
         return ESP_LOADER_SUCCESS;
@@ -99,7 +98,7 @@ esp_loader_error_t loader_port_serial_write(const uint8_t *data, uint16_t size,
 
 esp_loader_error_t loader_port_serial_read(uint8_t *data, uint16_t size, uint32_t timeout)
 {
-    int read = uart_read_bytes(UART_PORT, data, size, pdMS_TO_TICKS(timeout));
+    int read = uart_read_bytes(s_uart_port, data, size, pdMS_TO_TICKS(timeout));
     
     if (read < 0) {
         return ESP_LOADER_ERROR_FAIL;
@@ -115,19 +114,19 @@ esp_loader_error_t loader_port_serial_read(uint8_t *data, uint16_t size, uint32_
 // assert reset pin for 50 milliseconds.
 void loader_port_enter_bootloader(void)
 {
-    gpio_set_level(GPIO0_TRIGER_PIN, 0);
-    gpio_set_level(RESET_TRIGER_PIN, 0);
-    gpio_set_level(RESET_TRIGER_PIN, 1);
+    gpio_set_level(s_gpio0_trigger_pin, 0);
+    gpio_set_level(s_reset_trigger_pin, 0);
+    gpio_set_level(s_reset_trigger_pin, 1);
     loader_port_delay_ms(50);
-    gpio_set_level(GPIO0_TRIGER_PIN, 1);
+    gpio_set_level(s_gpio0_trigger_pin, 1);
 }
 
 
 void loader_port_reset_target(void)
 {
-    gpio_set_level(RESET_TRIGER_PIN, 0);
+    gpio_set_level(s_reset_trigger_pin, 0);
     loader_port_delay_ms(50);
-    gpio_set_level(RESET_TRIGER_PIN, 1);
+    gpio_set_level(s_reset_trigger_pin, 1);
 }
 
 
@@ -157,6 +156,6 @@ void loader_port_debug_print(const char *str)
 
 esp_loader_error_t loader_port_change_baudrate(uint32_t baudrate)
 {
-    esp_err_t err = uart_set_baudrate(UART_PORT, baudrate);
+    esp_err_t err = uart_set_baudrate(s_uart_port, baudrate);
     return (err == ESP_OK) ? ESP_LOADER_SUCCESS : ESP_LOADER_ERROR_FAIL;
 }

test/serial_io_mock.cpp

@@ -30,7 +30,7 @@ static uint32_t receive_delay = 0;
 static int32_t timer = 0;
 
 
-esp_loader_error_t loader_port_serial_init(uint32_t baud_rate)
+esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config)
 {
     return ESP_LOADER_SUCCESS;
 }

test/serial_io_tcp.cpp

@@ -33,7 +33,7 @@ const uint32_t PORT = 5555;
 static int sock = 0;
 ofstream file;
 
-esp_loader_error_t loader_port_serial_init(uint32_t baud_rate)
+esp_loader_error_t loader_port_serial_init(const loader_serial_config_t *config)
 {
     struct sockaddr_in serv_addr;
 

test/test_main.cpp

@@ -22,8 +22,10 @@
 
 int main( int argc, char* argv[] ) {
     
+    const loader_serial_config_t dummy_config = { 0 };
+
     // global setup...
-    if( loader_port_serial_init(0) != ESP_LOADER_SUCCESS ) {
+    if( loader_port_serial_init(&dummy_config) != ESP_LOADER_SUCCESS ) {
         std::cout << "Serial initialization failed";
         return 0;
     }