For fuck's sake

esp32-thread/border-router/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+idf_component_register(SRCS "gps.c" "esp_ot_br.c"
+                       PRIV_REQUIRES esp_psram openthread esp_coex esp_wifi nvs_flash
+                       INCLUDE_DIRS "."
+                       REQUIRES esp_http_client)

esp32-thread/border-router/main/Kconfig.projbuild

@@ -0,0 +1,52 @@
+menu "OpenThread Border Router Example"
+
+    config OPENTHREAD_BR_AUTO_START
+        bool 'Enable the automatic start mode in Thread Border Router.'
+        default n
+        help
+            If enabled, The Thread Border Router will connect to Wi-Fi with pre-configured
+            SSID and PSK, and then form a Thread network automatically. Otherwise, user need
+            to configure Wi-Fi and Thread manually.
+
+    config OPENTHREAD_SUPPORT_HW_RESET_RCP
+        bool 'Enable hardware RCP resetting'
+        default n
+        help
+            If enabled, the Thread Border Router will support hardware resetting the RCP
+            when processing RCP failure.
+
+    config OPENTHREAD_HW_RESET_RCP_PIN
+        int 'Pin to RCP reset'
+        depends on OPENTHREAD_SUPPORT_HW_RESET_RCP
+        default 7
+
+    menu "External coexist wire type and pin config"
+        config EXTERNAL_COEX_WIRE_TYPE
+            int "The wire_type of external coexist"
+            depends on ESP_COEX_EXTERNAL_COEXIST_ENABLE
+            default 3
+            range 0 3
+            help
+                Select wire_type for external coexist, the wire_type define in external_coex_wire_t.
+
+        config EXTERNAL_COEX_REQUEST_PIN
+            int "The number of external coexist request pin"
+            depends on ESP_COEX_EXTERNAL_COEXIST_ENABLE && (EXTERNAL_COEX_WIRE_TYPE >= 0)
+            default 0
+
+        config EXTERNAL_COEX_GRANT_PIN
+            int "The number of external coexist grant pin"
+            depends on ESP_COEX_EXTERNAL_COEXIST_ENABLE && (EXTERNAL_COEX_WIRE_TYPE >= 1)
+            default 1
+
+        config EXTERNAL_COEX_PRIORITY_PIN
+            int "The number of external coexist priority pin"
+            depends on ESP_COEX_EXTERNAL_COEXIST_ENABLE && (EXTERNAL_COEX_WIRE_TYPE >= 2)
+            default 2
+
+        config EXTERNAL_COEX_TX_LINE_PIN
+            int "The number of external coexist tx_line pin"
+            depends on ESP_COEX_EXTERNAL_COEXIST_ENABLE && (EXTERNAL_COEX_WIRE_TYPE = 3)
+            default 3
+    endmenu # External coexist wire type and pin config
+endmenu

esp32-thread/border-router/main/esp_ot_br.c

@@ -0,0 +1,227 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: CC0-1.0
+ *
+ * OpenThread Border Router Example
+ *
+ * This example code is in the Public Domain (or CC0 licensed, at your option.)
+ *
+ * Unless required by applicable law or agreed to in writing, this
+ * software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "sdkconfig.h"
+#include "esp_check.h"
+#include "esp_err.h"
+#include "esp_event.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "esp_openthread.h"
+#include "esp_openthread_border_router.h"
+#include "esp_openthread_cli.h"
+#include "esp_openthread_lock.h"
+#include "esp_openthread_netif_glue.h"
+#include "esp_openthread_types.h"
+#if CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
+#include "esp_ot_cli_extension.h"
+#endif // CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
+#include "esp_ot_config.h"
+#include "esp_ot_wifi_cmd.h"
+#include "esp_vfs_dev.h"
+#include "esp_vfs_eventfd.h"
+#include "esp_wifi.h"
+#include "mdns.h"
+#include "nvs_flash.h"
+#include "protocol_examples_common.h"
+#include "driver/gpio.h"
+#include "driver/uart.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "hal/uart_types.h"
+#include "openthread/error.h"
+#include "openthread/logging.h"
+#include "openthread/tasklet.h"
+#include "gps.h"
+
+#if CONFIG_OPENTHREAD_STATE_INDICATOR_ENABLE
+#include "ot_led_strip.h"
+#endif
+
+#if CONFIG_OPENTHREAD_BR_AUTO_START
+#include "example_common_private.h"
+#include "protocol_examples_common.h"
+#endif
+
+#if !CONFIG_OPENTHREAD_BR_AUTO_START && CONFIG_EXAMPLE_CONNECT_ETHERNET
+// TZ-1109: Add a menchanism for connecting ETH manually.
+#error Currently we do not support a manual way to connect ETH, if you want to use ETH, please enable OPENTHREAD_BR_AUTO_START.
+#endif
+
+#define TAG "esp_ot_br"
+
+#if CONFIG_OPENTHREAD_SUPPORT_HW_RESET_RCP
+#define PIN_TO_RCP_RESET CONFIG_OPENTHREAD_HW_RESET_RCP_PIN
+static void rcp_failure_hardware_reset_handler(void)
+{
+    gpio_config_t reset_pin_config;
+    memset(&reset_pin_config, 0, sizeof(reset_pin_config));
+    reset_pin_config.intr_type = GPIO_INTR_DISABLE;
+    reset_pin_config.pin_bit_mask = BIT(PIN_TO_RCP_RESET);
+    reset_pin_config.mode = GPIO_MODE_OUTPUT;
+    reset_pin_config.pull_down_en = GPIO_PULLDOWN_DISABLE;
+    reset_pin_config.pull_up_en = GPIO_PULLUP_DISABLE;
+    gpio_config(&reset_pin_config);
+    gpio_set_level(PIN_TO_RCP_RESET, 0);
+    vTaskDelay(pdMS_TO_TICKS(10));
+    gpio_set_level(PIN_TO_RCP_RESET, 1);
+    vTaskDelay(pdMS_TO_TICKS(30));
+    gpio_reset_pin(PIN_TO_RCP_RESET);
+}
+#endif
+
+#if CONFIG_EXTERNAL_COEX_ENABLE
+static void ot_br_external_coexist_init(void)
+{
+    esp_external_coex_gpio_set_t gpio_pin = ESP_OPENTHREAD_DEFAULT_EXTERNAL_COEX_CONFIG();
+    esp_external_coex_set_work_mode(EXTERNAL_COEX_LEADER_ROLE);
+    ESP_ERROR_CHECK(esp_enable_extern_coex_gpio_pin(CONFIG_EXTERNAL_COEX_WIRE_TYPE, gpio_pin));
+}
+#endif /* CONFIG_EXTERNAL_COEX_ENABLE */
+
+static void ot_task_worker(void *aContext)
+{
+    esp_openthread_platform_config_t config = {
+        .radio_config = ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG(),
+        .host_config = ESP_OPENTHREAD_DEFAULT_HOST_CONFIG(),
+        .port_config = ESP_OPENTHREAD_DEFAULT_PORT_CONFIG(),
+    };
+
+    esp_netif_config_t cfg = ESP_NETIF_DEFAULT_OPENTHREAD();
+    esp_netif_t       *openthread_netif = esp_netif_new(&cfg);
+    assert(openthread_netif != NULL);
+
+    // Initialize the OpenThread stack
+    ESP_ERROR_CHECK(esp_openthread_init(&config));
+    ESP_ERROR_CHECK(esp_netif_attach(openthread_netif, esp_openthread_netif_glue_init(&config)));
+    esp_openthread_lock_acquire(portMAX_DELAY);
+#if CONFIG_OPENTHREAD_LOG_LEVEL_DYNAMIC
+    // The OpenThread log level directly matches ESP log level
+    (void)otLoggingSetLevel(CONFIG_LOG_DEFAULT_LEVEL);
+#endif // CONFIG_OPENTHREAD_LOG_LEVEL_DYNAMIC
+#if CONFIG_OPENTHREAD_CLI
+    esp_openthread_cli_init();
+#if CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
+    esp_cli_custom_command_init();
+#endif // CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
+    esp_openthread_cli_create_task();
+#endif // CONFIG_OPENTHREAD_CLI
+    esp_openthread_lock_release();
+
+    // Run the main loop
+    esp_openthread_launch_mainloop();
+
+    // Clean up
+    esp_openthread_netif_glue_deinit();
+    esp_netif_destroy(openthread_netif);
+    esp_vfs_eventfd_unregister();
+    vTaskDelete(NULL);
+}
+
+void ot_br_init(void *ctx)
+{
+#if CONFIG_OPENTHREAD_CLI_WIFI
+    ESP_ERROR_CHECK(esp_ot_wifi_config_init());
+#endif
+#if CONFIG_OPENTHREAD_BR_AUTO_START
+#if CONFIG_EXAMPLE_CONNECT_WIFI || CONFIG_EXAMPLE_CONNECT_ETHERNET
+    bool wifi_or_ethernet_connected = false;
+#else
+#error No backbone netif!
+#endif
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+    char wifi_ssid[32] = "";
+    char wifi_password[64] = "";
+    if (esp_ot_wifi_config_get_ssid(wifi_ssid) == ESP_OK) {
+        ESP_LOGI(TAG, "use the Wi-Fi config from NVS");
+        esp_ot_wifi_config_get_password(wifi_password);
+    } else {
+        ESP_LOGI(TAG, "use the Wi-Fi config from Kconfig");
+        strcpy(wifi_ssid, CONFIG_EXAMPLE_WIFI_SSID);
+        strcpy(wifi_password, CONFIG_EXAMPLE_WIFI_PASSWORD);
+    }
+    if (esp_ot_wifi_connect(wifi_ssid, wifi_password) == ESP_OK) {
+        wifi_or_ethernet_connected = true;
+    } else {
+        ESP_LOGE(TAG, "Fail to connect to Wi-Fi, please try again manually");
+    }
+#endif
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+    ESP_ERROR_CHECK(example_ethernet_connect());
+    wifi_or_ethernet_connected = true;
+#endif
+#endif // CONFIG_OPENTHREAD_BR_AUTO_START
+
+#if CONFIG_EXTERNAL_COEX_ENABLE
+    ot_br_external_coexist_init();
+#endif // CONFIG_EXTERNAL_COEX_ENABLE
+    ESP_ERROR_CHECK(mdns_init());
+    ESP_ERROR_CHECK(mdns_hostname_set("esp-ot-br"));
+
+    esp_openthread_lock_acquire(portMAX_DELAY);
+#if CONFIG_OPENTHREAD_STATE_INDICATOR_ENABLE
+    ESP_ERROR_CHECK(esp_openthread_state_indicator_init(esp_openthread_get_instance()));
+#endif
+#if CONFIG_OPENTHREAD_BR_AUTO_START
+    if (wifi_or_ethernet_connected) {
+        esp_openthread_set_backbone_netif(get_example_netif());
+        ESP_ERROR_CHECK(esp_openthread_border_router_init());
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+        esp_ot_wifi_border_router_init_flag_set(true);
+#endif
+        otOperationalDatasetTlvs dataset;
+        otError error = otDatasetGetActiveTlvs(esp_openthread_get_instance(), &dataset);
+        ESP_ERROR_CHECK(esp_openthread_auto_start((error == OT_ERROR_NONE) ? &dataset : NULL));
+    } else {
+        ESP_LOGE(TAG, "Auto-start mode failed, please try to start manually");
+    }
+#endif // CONFIG_OPENTHREAD_BR_AUTO_START
+    esp_openthread_lock_release();
+    vTaskDelete(NULL);
+}
+
+void app_main(void)
+{
+    // Used eventfds:
+    // * netif
+    // * task queue
+    // * border router
+    size_t max_eventfd = 3;
+
+#if CONFIG_OPENTHREAD_RADIO_NATIVE || CONFIG_OPENTHREAD_RADIO_SPINEL_SPI
+    // * radio driver (A native radio device needs a eventfd for radio driver.)
+    // * SpiSpinelInterface (The Spi Spinel Interface needs a eventfd.)
+    // The above will not exist at the same time.
+    max_eventfd++;
+#endif
+#if CONFIG_OPENTHREAD_RADIO_TREL
+    // * TREL reception (The Thread Radio Encapsulation Link needs a eventfd for reception.)
+    max_eventfd++;
+#endif
+    esp_vfs_eventfd_config_t eventfd_config = {
+        .max_fds = max_eventfd,
+    };
+    ESP_ERROR_CHECK(esp_vfs_eventfd_register(&eventfd_config));
+    ESP_ERROR_CHECK(nvs_flash_init());
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+#if CONFIG_OPENTHREAD_SUPPORT_HW_RESET_RCP
+    esp_openthread_register_rcp_failure_handler(rcp_failure_hardware_reset_handler);
+#endif
+    xTaskCreate(ot_task_worker, "ot_br_main", 8192, xTaskGetCurrentTaskHandle(), 5, NULL);
+    xTaskCreate(ot_br_init, "ot_br_init", 6144, NULL, 4, NULL);
+}

esp32-thread/border-router/main/esp_ot_config.h

@@ -0,0 +1,140 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: CC0-1.0
+ *
+ * OpenThread Border Router Example
+ *
+ * This example code is in the Public Domain (or CC0 licensed, at your option.)
+ *
+ * Unless required by applicable law or agreed to in writing, this
+ * software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#pragma once
+#include "esp_coexist.h"
+#include "esp_openthread_types.h"
+
+#if CONFIG_OPENTHREAD_RADIO_NATIVE
+#define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG()              \
+    {                                                      \
+        .radio_mode = RADIO_MODE_NATIVE,                   \
+    }
+#elif CONFIG_OPENTHREAD_RADIO_SPINEL_UART
+#define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG()              \
+    {                                                      \
+        .radio_mode = RADIO_MODE_UART_RCP,                 \
+        .radio_uart_config = {                             \
+            .port = 1,                                     \
+            .uart_config =                                 \
+                {                                          \
+                    .baud_rate = 460800,                   \
+                    .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 = 0,              \
+                    .source_clk = UART_SCLK_DEFAULT,       \
+                },                                         \
+            .rx_pin = 4,                                   \
+            .tx_pin = 5,                                   \
+        },                                                 \
+    }
+#else
+#define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG()      \
+    {                                              \
+        .radio_mode = RADIO_MODE_SPI_RCP,          \
+        .radio_spi_config = {                      \
+            .host_device = SPI2_HOST,              \
+            .dma_channel = 2,                      \
+            .spi_interface =                       \
+                {                                  \
+                    .mosi_io_num = 11,             \
+                    .sclk_io_num = 12,             \
+                    .miso_io_num = 13,             \
+                },                                 \
+            .spi_device =                          \
+                {                                  \
+                    .cs_ena_pretrans = 2,          \
+                    .input_delay_ns = 100,         \
+                    .mode = 0,                     \
+                    .clock_speed_hz = 2500 * 1000, \
+                    .spics_io_num = 10,            \
+                    .queue_size = 5,               \
+                },                                 \
+            .intr_pin = 8,                         \
+        },                                         \
+    }
+#endif // CONFIG_OPENTHREAD_RADIO_SPINEL_UART OR  CONFIG_OPENTHREAD_RADIO_SPINEL_SPI
+
+#if CONFIG_IDF_TARGET_ESP32C2 && CONFIG_XTAL_FREQ_26
+#define HOST_BAUD_RATE 74880
+#else
+#define HOST_BAUD_RATE 115200
+#endif
+
+#if CONFIG_OPENTHREAD_CONSOLE_TYPE_UART
+#define ESP_OPENTHREAD_DEFAULT_HOST_CONFIG()                    \
+    {                                                           \
+        .host_connection_mode = HOST_CONNECTION_MODE_CLI_UART,  \
+        .host_uart_config = {                                   \
+            .port = 0,                                          \
+            .uart_config =                                      \
+                {                                               \
+                    .baud_rate = HOST_BAUD_RATE,                \
+                    .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 = 0,                   \
+                    .source_clk = UART_SCLK_DEFAULT,            \
+                },                                              \
+            .rx_pin = UART_PIN_NO_CHANGE,                       \
+            .tx_pin = UART_PIN_NO_CHANGE,                       \
+        },                                                      \
+    }
+#elif CONFIG_OPENTHREAD_CONSOLE_TYPE_USB_SERIAL_JTAG
+#define ESP_OPENTHREAD_DEFAULT_HOST_CONFIG()                        \
+    {                                                               \
+        .host_connection_mode = HOST_CONNECTION_MODE_CLI_USB,       \
+        .host_usb_config = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT(), \
+    }
+#endif
+
+#define ESP_OPENTHREAD_DEFAULT_PORT_CONFIG()    \
+    {                                           \
+        .storage_partition_name = "nvs",        \
+        .netif_queue_size = 10,                 \
+        .task_queue_size = 10,                  \
+    }
+
+#if CONFIG_EXTERNAL_COEX_ENABLE
+#if CONFIG_EXTERNAL_COEX_WIRE_TYPE == EXTERNAL_COEXIST_WIRE_1
+#define ESP_OPENTHREAD_DEFAULT_EXTERNAL_COEX_CONFIG()   \
+    {                                                   \
+        .request = CONFIG_EXTERNAL_COEX_REQUEST_PIN,    \
+    }
+#elif CONFIG_EXTERNAL_COEX_WIRE_TYPE == EXTERNAL_COEXIST_WIRE_2
+#define ESP_OPENTHREAD_DEFAULT_EXTERNAL_COEX_CONFIG()   \
+    {                                                   \
+        .request = CONFIG_EXTERNAL_COEX_REQUEST_PIN,    \
+        .grant = CONFIG_EXTERNAL_COEX_GRANT_PIN,        \
+    }
+#elif CONFIG_EXTERNAL_COEX_WIRE_TYPE == EXTERNAL_COEXIST_WIRE_3
+#define ESP_OPENTHREAD_DEFAULT_EXTERNAL_COEX_CONFIG()   \
+    {                                                   \
+        .request = CONFIG_EXTERNAL_COEX_REQUEST_PIN,    \
+        .priority = CONFIG_EXTERNAL_COEX_PRIORITY_PIN,  \
+        .grant = CONFIG_EXTERNAL_COEX_GRANT_PIN,        \
+    }
+#elif CONFIG_EXTERNAL_COEX_WIRE_TYPE == EXTERNAL_COEXIST_WIRE_4
+#define ESP_OPENTHREAD_DEFAULT_EXTERNAL_COEX_CONFIG()   \
+    {                                                   \
+        .request = CONFIG_EXTERNAL_COEX_REQUEST_PIN,    \
+        .priority = CONFIG_EXTERNAL_COEX_PRIORITY_PIN,  \
+        .grant = CONFIG_EXTERNAL_COEX_GRANT_PIN,        \
+        .tx_line = CONFIG_EXTERNAL_COEX_TX_LINE_PIN,    \
+    }
+#endif
+#endif // CONFIG_EXTERNAL_COEX_ENABLE

esp32-thread/border-router/main/gps.c

@@ -0,0 +1,111 @@
+#include "gps.h"
+#include "driver/uart.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include <string.h>
+#include <stdlib.h>
+
+#define GPS_UART_NUM UART_NUM_1
+#define GPS_TX_PIN 4
+#define GPS_RX_PIN 5
+#define BUF_SIZE 1024
+
+static uint8_t gps_buffer[BUF_SIZE];
+void init_gps() {
+    const uart_config_t uart_config = {
+        .baud_rate = 9600,
+        .data_bits = UART_DATA_8_BITS,
+        .parity    = UART_PARITY_DISABLE,
+        .stop_bits = UART_STOP_BITS_1,
+        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE
+    };
+
+    uart_param_config(GPS_UART_NUM, &uart_config);
+    uart_set_pin(GPS_UART_NUM, GPS_TX_PIN, GPS_RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+    uart_driver_install(GPS_UART_NUM, BUF_SIZE, 0, 0, NULL, 0);
+}
+
+// Convertit NMEA "ddmm.mmmm" + N/S/E/W en degrés décimaux
+double nmea_to_decimal(const char* nmea_coord, const char direction) {
+    double raw = atof(nmea_coord);
+    int degrees = (int)(raw / 100);
+    double minutes = raw - (degrees * 100);
+    double decimal = degrees + minutes / 60.0;
+    if (direction == 'S' || direction == 'W') decimal = -decimal;
+    return decimal;
+}
+
+char* gps_to_json(char* gps_data) {
+    static char json[128];
+
+    double latitude = 0.0;
+    double longitude = 0.0;
+
+    if (gps_data && strncmp(gps_data, "$GPGGA,", 7) == 0) {
+        char* fields[15];
+        int i = 0;
+        char gps_copy[BUF_SIZE];
+        strncpy(gps_copy, gps_data, BUF_SIZE - 1);
+        gps_copy[BUF_SIZE - 1] = '\0';
+
+        char* token = strtok(gps_copy, ",");
+        while (token && i < 15) {
+            fields[i++] = token;
+            token = strtok(NULL, ",");
+        }
+
+        if (i >= 6 && fields[2][0] != '\0' && fields[4][0] != '\0') {
+            latitude = nmea_to_decimal(fields[2], fields[3][0]);
+            longitude = nmea_to_decimal(fields[4], fields[5][0]);
+        }
+    }
+
+    // Créer le JSON avec des valeurs valides même si GPS pas fixé
+    snprintf(json, sizeof(json), "{\"data\":{\"latitude\":%.6f,\"longitude\":%.6f}}",
+             latitude, longitude);
+
+    return json;
+}
+
+
+char* read_gps() { 
+    int len = uart_read_bytes(GPS_UART_NUM, gps_buffer, BUF_SIZE - 1, 100 / portTICK_PERIOD_MS); 
+    if (len > 0) { 
+        gps_buffer[len] = '\0'; 
+        return (char*)gps_buffer; 
+    } 
+    return NULL; 
+}
+
+void send_gps_data(const char* server_url, const char* json)
+{
+    if (!json) return;
+
+    ESP_LOGI(TAG, "Sending JSON: %s", json);
+
+    esp_http_client_config_t config = { .url = server_url };
+    esp_http_client_handle_t client = esp_http_client_init(&config);
+    esp_http_client_set_method(client, HTTP_METHOD_POST);
+    esp_http_client_set_post_field(client, json, strlen(json));
+    esp_http_client_set_header(client, "Content-Type", "application/json");
+
+    esp_http_client_perform(client);
+    esp_http_client_cleanup(client);
+}
+
+void send_position_task(void *pvParameters)
+{
+    const char* position_endpoint = "http://192.168.15.117:5000/devices/notify-position";
+
+    while (1) {
+        char* json;
+        char* raw_data = read_gps();
+        if (raw_data) {
+            char* json = gps_to_json(raw_data);
+            send_gps_data(position_endpoint, json);
+        } else {
+            ESP_LOGI(TAG, "NO GPS DATA");
+        }
+        vTaskDelay(25000 / portTICK_PERIOD_MS);
+    }
+}

esp32-thread/border-router/main/gps.h

@@ -0,0 +1,11 @@
+#include "driver/uart.h"
+
+#define GPS_UART_NUM UART_NUM_1
+#define GPS_TX_PIN 4
+#define GPS_RX_PIN 5
+
+void init_gps(void);
+char* read_gps(void);
+char* gps_to_json(char* gps_data);
+void send_gps_data(const char* server_url, const char* json);
+void send_position_task(void *pvParameters);

esp32-thread/border-router/main/idf_component.yml

@@ -0,0 +1,12 @@
+## IDF Component Manager Manifest File
+dependencies:
+  espressif/esp_ot_cli_extension:
+    version: "~1.3.0"
+  espressif/mdns: "^1.0.3"
+  ## Required IDF version
+  idf:
+    version: ">=5.0"
+  protocol_examples_common:
+    path: ${IDF_PATH}/examples/common_components/protocol_examples_common
+  ot_led:
+    path: ${IDF_PATH}/examples/openthread/ot_common_components/ot_led