fix(eppp): uart changes + simple channel operations

Author: david-cermak

components/eppp_link/eppp_spi.c

@@ -115,7 +115,6 @@ static esp_err_t transmit(void *h, void *buffer, size_t len)
 #ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 static esp_err_t transmit_channel(esp_netif_t *netif, int channel, void *buffer, size_t len)
 {
-//    printf("transmit_channel %d %p %zu\n", channel, buffer, len);
     struct eppp_handle *handle = esp_netif_get_io_driver(netif);
     struct eppp_spi *spi_handle = __containerof(handle, struct eppp_spi, parent);;
     return transmit_generic(spi_handle, channel, buffer, len);

components/eppp_link/eppp_uart.c

@@ -29,21 +29,21 @@ struct eppp_uart {
 
 struct header {
     uint8_t magic;
+    uint8_t channel;
     uint8_t check;
     uint16_t size;
 } __attribute__((packed));
 
-static esp_err_t transmit(void *h, void *buffer, size_t len)
+static esp_err_t transmit_generic(struct eppp_uart *handle, int channel, void *buffer, size_t len)
 {
-    struct eppp_handle *common = h;
-    struct eppp_uart *handle = __containerof(common, struct eppp_uart, parent);
 #ifndef CONFIG_EPPP_LINK_USES_PPP
     static uint8_t out_buf[PACKET_SIZE] = {};
     struct header *head = (void *)out_buf;
     head->magic = HEADER_MAGIC;
     head->check = 0;
+    head->channel = channel;
     head->size = len;
-    head->check = HEADER_MAGIC + len + (len >> 8);
+    head->check = HEADER_MAGIC + len + (len >> 8) + channel;
     memcpy(out_buf + sizeof(struct header), buffer, len);
     ESP_LOG_BUFFER_HEXDUMP("ppp_uart_send", out_buf, len + sizeof(struct header), ESP_LOG_DEBUG);
     uart_write_bytes(handle->uart_port, out_buf, len + sizeof(struct header));
@@ -54,6 +54,22 @@ static esp_err_t transmit(void *h, void *buffer, size_t len)
     return ESP_OK;
 }
 
+static esp_err_t transmit(void *h, void *buffer, size_t len)
+{
+    struct eppp_handle *handle = h;
+    struct eppp_uart *uart_handle = __containerof(handle, struct eppp_uart, parent);
+    return transmit_generic(uart_handle, 0, buffer, len);
+}
+
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+static esp_err_t transmit_channel(esp_netif_t *netif, int channel, void *buffer, size_t len)
+{
+    struct eppp_handle *handle = esp_netif_get_io_driver(netif);
+    struct eppp_uart *uart_handle = __containerof(handle, struct eppp_uart, parent);
+    return transmit_generic(uart_handle, channel, buffer, len);
+}
+#endif
+
 static esp_err_t init_uart(struct eppp_uart *h, struct eppp_config_uart_s *config)
 {
     h->uart_port = config->port;
@@ -78,7 +94,7 @@ static void deinit_uart(struct eppp_uart *h)
 }
 
 #ifndef CONFIG_EPPP_LINK_USES_PPP
-static void process_packet(esp_netif_t *netif, uint8_t *buffer, size_t len)
+static void process_packet(esp_netif_t *netif, struct eppp_uart *h, uint8_t *buffer, size_t len)
 {
     static uint8_t in_buf[PACKET_SIZE + UART_BUF_SIZE] = {};
     static size_t current_offset = 0;
@@ -104,7 +120,7 @@ static void process_packet(esp_netif_t *netif, uint8_t *buffer, size_t len)
             continue;
         }
 
-        uint8_t calculated_check = HEADER_MAGIC + head->size + (head->size >> 8);
+        uint8_t calculated_check = HEADER_MAGIC + head->size + (head->size >> 8) + head->channel;
         if (head->check != calculated_check) {
             ESP_LOGW(TAG, "Checksum mismatch: expected 0x%04x, got 0x%04x", calculated_check, head->check);
             // Discard this header
@@ -115,6 +131,7 @@ static void process_packet(esp_netif_t *netif, uint8_t *buffer, size_t len)
 
         // Check if we have the complete packet
         uint16_t payload_size = head->size;
+        int channel = head->channel;
         size_t total_packet_size = sizeof(struct header) + payload_size;
 
         if (payload_size > MAX_PAYLOAD) {
@@ -131,8 +148,16 @@ static void process_packet(esp_netif_t *netif, uint8_t *buffer, size_t len)
             break;
         }
 
-        // Got a complete packet, pass it to network
-        esp_netif_receive(netif, in_buf + sizeof(struct header), payload_size, NULL);
+        // Got a complete packet, pass it to the network (or to a custom channel handler)
+        if (channel == 0) {
+            esp_netif_receive(netif, in_buf + sizeof(struct header), payload_size, NULL);
+        } else {
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+            if (h->parent.channel_rx) {
+                h->parent.channel_rx(netif, channel, in_buf + sizeof(struct header), payload_size);
+            }
+#endif
+        }
 
         // Move any remaining data to the beginning of the buffer
         if (current_offset > total_packet_size) {
@@ -166,9 +191,10 @@ esp_err_t eppp_perform(esp_netif_t *netif)
             len = uart_read_bytes(h->uart_port, buffer, UART_BUF_SIZE, 0);
             ESP_LOG_BUFFER_HEXDUMP("ppp_uart_recv", buffer, len, ESP_LOG_DEBUG);
 #ifdef CONFIG_EPPP_LINK_USES_PPP
+// TODO: cannot use PPP and channels at the same time
             esp_netif_receive(netif, buffer, len, NULL);
 #else
-            process_packet(netif, buffer, len);
+            process_packet(netif, h, buffer, len);
 #endif
         }
     } else {
@@ -198,6 +224,9 @@ eppp_transport_handle_t eppp_uart_init(struct eppp_config_uart_s *config)
     __attribute__((unused)) esp_err_t ret = ESP_OK;
     struct eppp_uart *h = calloc(1, sizeof(struct eppp_uart));
     ESP_RETURN_ON_FALSE(h, NULL, TAG, "Failed to allocate eppp_handle");
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+    h->parent.channel_tx = transmit_channel;
+#endif
     h->parent.base.post_attach = post_attach;
     ESP_GOTO_ON_ERROR(init_uart(h, config), err, TAG, "Failed to init UART");
     return &h->parent;

components/eppp_link/examples/host/main/app_main.c

@@ -14,8 +14,16 @@
 #include "esp_netif.h"
 #include "eppp_link.h"
 #include "esp_log.h"
+#include "esp_check.h"
 #include "mqtt_client.h"
 #include "console_ping.h"
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+#if __has_include("esp_wifi_remote.h")
+#include "esp_wifi_remote.h"
+#define HAVE_WIFI_REMOTE
+#endif
+#endif
+
 
 void register_iperf(void);
 
@@ -87,19 +95,43 @@ static void mqtt_app_start(void)
     esp_mqtt_client_start(client);
 }
 #endif // MQTT
+
 #ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+typedef enum {
+    UNKNOWN,
+    INIT,
+    CONNECTED,
+    DISCONNECTED,
+    ERROR,
+} state_t;
+static state_t s_state = UNKNOWN;
+static eppp_channel_fn_t s_transmit[CHANNEL_ID_MAX] = {NULL};
 static esp_err_t recv(esp_netif_t *netif, int nr, void *buffer, size_t len)
 {
-    printf("recv %d %p %zu\n", nr, buffer, len);
+    char data[32];
+    if (len < sizeof(data)) {
+        memcpy(data, buffer, len);
+        printf("Received [%d] %*s\n", (int)len, (int)len, data);
+        return ESP_OK;
+    }
     return ESP_OK;
 }
+
+static void task_transmit(void *arg)
+{
+    int counter = 0;
+    esp_netif_t *eppp_netif = (esp_netif_t *)arg;
+    while (1)  {
+        char data[32];
+        sprintf(data, "Message from host #%d", counter++);
+        s_transmit(eppp_netif, 1, data, strlen(data));
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
+}
 #endif
 
 void app_main(void)
 {
-#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-    static eppp_channel_fn_t transmit = NULL;
-#endif
     ESP_LOGI(TAG, "[APP] Startup..");
     ESP_LOGI(TAG, "[APP] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size());
     ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
@@ -123,8 +155,8 @@ void app_main(void)
     config.spi.freq = 4000000;
 #elif CONFIG_EPPP_LINK_DEVICE_UART
     config.transport = EPPP_TRANSPORT_UART;
-    config.uart.tx_io = 17;
-    config.uart.rx_io = 18;
+    config.uart.tx_io = 4;
+    config.uart.rx_io = 5;
 //    config.uart.baud = CONFIG_EXAMPLE_UART_BAUDRATE;
 #elif CONFIG_EPPP_LINK_DEVICE_ETH
     config.transport = EPPP_TRANSPORT_ETHERNET;
@@ -166,11 +198,9 @@ void app_main(void)
     ESP_ERROR_CHECK(console_cmd_start());
 
 #ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-    eppp_add_channels(eppp_netif, 1, &transmit, recv);
-    while (1)  {
-        transmit(eppp_netif, 1, "Hi three", 3);
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
-    }
+    ESP_RETURN_ON_FALSE(eppp_add_channels(eppp_netif, 1, &s_transmit, recv) == ESP_OK,, TAG, "Failed to add channels");
+    ESP_RETURN_ON_FALSE(s_transmit,, TAG, "Channel tx function is not set");
+    xTaskCreate(task_transmit, "task_transmit", 2048, eppp_netif, 5, NULL);
 #endif
 #if CONFIG_EXAMPLE_MQTT
     mqtt_app_start();

components/eppp_link/examples/host/main/idf_component.yml

@@ -1,7 +1,10 @@
 dependencies:
-  espressif/iperf-cmd: "^0.1.1"
+  espressif/iperf-cmd: ^0.1.1
   espressif/eppp_link:
-    version: "*"
-    override_path: "../../.."
+    version: '*'
+    override_path: ../../..
   console_cmd_ping:
-    version: "*"
+    version: '*'
+  espressif/esp_wifi_remote:
+    version: '*'
+    override_path: /home/david/repos/esp-wifi-remote/components/esp_wifi_remote

components/eppp_link/examples/slave/main/eppp_slave.c

@@ -11,6 +11,7 @@
 #include "esp_wifi.h"
 #include "esp_event.h"
 #include "esp_log.h"
+#include "esp_check.h"
 #include "nvs_flash.h"
 #include "eppp_link.h"
 
@@ -114,18 +115,24 @@ void init_network_interface(void)
 
 #endif // SoC WiFi capable chip
 
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 static esp_err_t recv(esp_netif_t *netif, int nr, void *buffer, size_t len)
 {
     char data[32];
     if (len < sizeof(data)) {
         memcpy(data, buffer, len);
-        printf("Received #[%d] %s\n", nr, data);
+        printf("Received [%d] %*s\n", (int)len, (int)len, data);
+        return ESP_OK;
     }
-    return ESP_OK;
+    return ESP_ERR_INVALID_SIZE;
 }
+#endif // CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+
 void app_main(void)
 {
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
     static eppp_channel_fn_t transmit = NULL;
+#endif // CONFIG_EPPP_LINK_CHANNELS_SUPPORT
     //Initialize NVS
     esp_err_t ret = nvs_flash_init();
     if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
@@ -151,8 +158,8 @@ void app_main(void)
     config.spi.freq = 1000000;
 #elif CONFIG_EPPP_LINK_DEVICE_UART
     config.transport = EPPP_TRANSPORT_UART;
-    config.uart.tx_io = 18;
-    config.uart.rx_io = 17;
+    config.uart.tx_io = 4;
+    config.uart.rx_io = 5;
 //    config.uart.baud = CONFIG_EXAMPLE_UART_BAUDRATE;
 #elif CONFIG_EPPP_LINK_DEVICE_SDIO
     config.transport = EPPP_TRANSPORT_SDIO;
@@ -164,13 +171,15 @@ void app_main(void)
         return ;
     }
     ESP_ERROR_CHECK(esp_netif_napt_enable(eppp_netif));
-    ret = eppp_add_channels(eppp_netif, 1, &transmit, recv);
-    if (ret != ESP_OK) {
-        ESP_LOGE(TAG, "Failed to add channels");
-        return ;
-    }
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+    ESP_RETURN_ON_FALSE(eppp_add_channels(eppp_netif, 1, &transmit, recv) == ESP_OK,, TAG, "Failed to add channels");
+    ESP_RETURN_ON_FALSE(transmit,, TAG, "Channel tx function is not set");
+    int counter = 0;
     while (1)  {
-        transmit(eppp_netif, 1, "SLAve three", 3);
+        char data[32];
+        sprintf(data, "Message from slave #%d", counter++);
+        transmit(eppp_netif, 1, data, strlen(data));
         vTaskDelay(1000 / portTICK_PERIOD_MS);
     }
+#endif // CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 }