feat(eppp): Use wifi-netif over PPP channels

Author: david-cermak

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

@@ -97,22 +97,48 @@ static void mqtt_app_start(void)
 #endif // MQTT
 
 #ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+#define HELLO_DONE BIT0
+#define WIFI_MAC BIT1
+#define CONNECT BIT2
+
 typedef enum {
     UNKNOWN,
-    INIT,
-    CONNECTED,
-    DISCONNECTED,
+    HELLO,
+    START,
     ERROR,
 } state_t;
 static state_t s_state = UNKNOWN;
-static eppp_channel_fn_t s_transmit[CHANNEL_ID_MAX] = {NULL};
+static esp_netif_t *s_wifi_netif = NULL;
+static EventGroupHandle_t s_events;
+static eppp_channel_fn_t s_transmit = {NULL};
 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", (int)len, (int)len, data);
-        return ESP_OK;
+    if (nr == 1) {
+        printf("Received channel=%d len=%d %.*s\n", nr, (int)len, (int)len, (char *)buffer);
+        if (s_state == HELLO) {
+            const char hello[] = "Hello client";
+            const char mac[] = "MAC: ";
+            size_t mac_len = 5 /* MAC: */ + 6 * 2 /* 6 bytes per char */ + 5 /* : */ + 1 /* \0 */;
+            if (len == sizeof(hello) && memcmp(buffer, hello, len) == 0) {
+                xEventGroupSetBits(s_events, HELLO_DONE);
+            } else if (len == mac_len && memcmp(buffer, mac, 5) == 0) {
+                uint8_t mac_addr[6];
+                sscanf((char *)buffer + 5, "%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8,
+                       &mac_addr[0], &mac_addr[1], &mac_addr[2], &mac_addr[3], &mac_addr[4], &mac_addr[5]);
+                printf("Parsed MAC: %02x:%02x:%02x:%02x:%02x:%02x\n", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
+                esp_netif_set_mac(s_wifi_netif, mac_addr);
+                xEventGroupSetBits(s_events, WIFI_MAC);
+            }
+        } else if (s_state == START) {
+            const char connected[] = "Connected";
+            if (len == sizeof(connected) && memcmp(buffer, connected, len) == 0) {
+                xEventGroupSetBits(s_events, CONNECT);
+            }
+        }
+    } else if (nr == 2) {
+        printf("Received WIFI channel=%d len=%d\n", nr, (int)len);
+        // ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_INFO);
+        return esp_wifi_remote_channel_rx(NULL, buffer, NULL, len);
     }
     return ESP_OK;
 }
@@ -121,14 +147,67 @@ static void task_transmit(void *arg)
 {
     int counter = 0;
     esp_netif_t *eppp_netif = (esp_netif_t *)arg;
+    while (1) {
+        EventBits_t bits = xEventGroupWaitBits(s_events,
+                                               HELLO_DONE | WIFI_MAC | CONNECT,
+                                               pdTRUE,
+                                               pdFALSE,
+                                               pdMS_TO_TICKS(1000));
+        // if (bits & HELLO_SERVER) {
+        //     const char hello[] = "Hello server";
+        //     s_transmit(eppp_netif, 1, hello, sizeof(hello));
+        // } else
+        if (bits & HELLO_DONE) {
+            ESP_LOGI(TAG, "Hello done");
+            const char command[] = "Get MAC";
+            s_transmit(eppp_netif, 1, (void*)command, sizeof(command));
+            // s_state = CONNECTED;
+        } else if (bits & WIFI_MAC) {
+            s_state = START;
+            ESP_LOGI(TAG, "Starting WIFI");
+            esp_netif_action_start(s_wifi_netif, 0, 0, 0);
+        } else if (bits & CONNECT) {
+            ESP_LOGI(TAG, "WIFI connected");
+            esp_netif_action_connected(s_wifi_netif, 0, 0, 0);
+        } else if (s_state != START) {
+            const char hello[] = "Hello server";
+            s_transmit(eppp_netif, 1, (void*)hello, sizeof(hello));
+            s_state = HELLO;
+        }
+    }
+
     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
+
+esp_netif_t* esp_wifi_remote_create_default_sta(void);
+
+// move to netif2
+ESP_EVENT_DEFINE_BASE(WIFI_REMOTE_EVENT);
+
+static esp_err_t wifi_remote_tx(void *h, void *buffer, size_t len)
+{
+    esp_netif_t *eppp_netif = (esp_netif_t *)h;
+    // ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_INFO);
+    return s_transmit(eppp_netif, 2, buffer, len);
+}
+
+static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
+{
+    ESP_LOGI(TAG, "IP event_handler: event_base=%s event_id=%d", event_base, event_id);
+    if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
+        ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
+        ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
+        xEventGroupSetBits(s_events, CONNECT);
+    }
+}
+
+#endif // CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 
 void app_main(void)
 {
@@ -198,11 +277,15 @@ void app_main(void)
     ESP_ERROR_CHECK(console_cmd_start());
 
 #ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+    ESP_RETURN_ON_FALSE(s_events = xEventGroupCreate(),, TAG, "Failed to create event group");
     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);
+    s_wifi_netif = esp_wifi_remote_create_default_sta();
+    esp_wifi_remote_channel_set(WIFI_IF_STA, eppp_netif, wifi_remote_tx);
+    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, event_handler, NULL);
 #endif
 #if CONFIG_EXAMPLE_MQTT
-    mqtt_app_start();
+    // mqtt_app_start();
 #endif
 }

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

@@ -14,6 +14,7 @@
 #include "esp_check.h"
 #include "nvs_flash.h"
 #include "eppp_link.h"
+#include "esp_private/wifi.h"
 
 static const char *TAG = "eppp_slave";
 
@@ -27,14 +28,20 @@ static EventGroupHandle_t s_wifi_event_group;
  * - we failed to connect after the maximum amount of retries */
 #define WIFI_CONNECTED_BIT BIT0
 #define WIFI_FAIL_BIT      BIT1
+//---------------------------------------
+#define WIFI_CONNECTED BIT2
 
 
 static int s_retry_num = 0;
+static EventGroupHandle_t s_events;
 
 static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
 {
+    ESP_LOGI(TAG, "event_handler: event_base=%s event_id=%d", event_base, event_id);
     if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
+        ESP_LOGI(TAG, "WIFI start event");
         esp_wifi_connect();
+        xEventGroupSetBits(s_events, WIFI_CONNECTED);
     } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
         if (s_retry_num < CONFIG_ESP_MAXIMUM_RETRY) {
             esp_wifi_connect();
@@ -56,7 +63,7 @@ void init_network_interface(void)
 {
     s_wifi_event_group = xEventGroupCreate();
 
-    esp_netif_create_default_wifi_sta();
+    // esp_netif_create_default_wifi_sta();
 
     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
@@ -82,9 +89,10 @@ void init_network_interface(void)
     };
     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
     ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
-    ESP_ERROR_CHECK(esp_wifi_start());
+    // ESP_ERROR_CHECK(esp_wifi_start());
 
     ESP_LOGI(TAG, "wifi_init_sta finished.");
+    return;
 
     /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum
      * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */
@@ -116,23 +124,111 @@ void init_network_interface(void)
 #endif // SoC WiFi capable chip
 
 #ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+#define HELLO_RECEIVED BIT0
+#define MAC_REQUEST BIT1
+
+typedef enum {
+    UNKNOWN,
+    HELLO,
+    START,
+    CONNECTED,
+    DISCONNECTED,
+    ERROR,
+} state_t;
+static state_t s_state = UNKNOWN;
+static eppp_channel_fn_t s_transmit = {NULL};
+static esp_netif_t *s_eppp_netif = NULL;
+
 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", (int)len, (int)len, data);
-        return ESP_OK;
+    if (nr == 1) {
+        printf("Received channel=%d len=%d %.*s\n", nr, (int)len, (int)len, (char *)buffer);
+        if (s_state == HELLO) {
+            const char hello[] = "Hello server";
+            const char mac[] = "Get MAC";
+            if (len == sizeof(hello) && memcmp(buffer, hello, len) == 0) {
+                xEventGroupSetBits(s_events, HELLO_RECEIVED);
+            } else if (len == sizeof(mac) && memcmp(buffer, mac, sizeof(mac)) == 0) {
+                xEventGroupSetBits(s_events, MAC_REQUEST);
+            }
+        }
+    } else if (nr == 2) {
+        printf("Received WIFI channel=%d len=%d\n", nr, (int)len);
+        return esp_wifi_internal_tx(WIFI_IF_STA, buffer, len);
+    }
+    return ESP_OK;
+}
+
+
+static esp_err_t wifi_receive(void *buffer, uint16_t len, void *eb)
+{
+    s_transmit(s_eppp_netif, 2, buffer, len);
+    esp_wifi_internal_free_rx_buffer(eb);
+    return ESP_OK;
+}
+
+
+static void task_transmit(void *arg)
+{
+    int counter = 0;
+    esp_netif_t *eppp_netif = (esp_netif_t *)arg;
+    while (1) {
+        EventBits_t bits = xEventGroupWaitBits(s_events,
+                                               HELLO_RECEIVED | MAC_REQUEST | WIFI_CONNECTED,
+                                               pdTRUE,
+                                               pdFALSE,
+                                               pdMS_TO_TICKS(1000));
+        // if (bits & HELLO_SERVER) {
+        //     const char hello[] = "Hello server";
+        //     s_transmit(eppp_netif, 1, hello, sizeof(hello));
+        // } else
+        if (bits & HELLO_RECEIVED) {
+            const char hello[] = "Hello client";
+            s_transmit(eppp_netif, 1, (void*)hello, sizeof(hello));
+            // s_state = CONNECTED;
+        } else if (bits & MAC_REQUEST) {
+            uint8_t mac[6];
+            esp_err_t ret;
+
+            if ((ret = esp_wifi_get_mac(WIFI_IF_STA, mac)) != ESP_OK) {
+                ESP_LOGE(TAG, "esp_wifi_get_mac failed with %d", ret);
+                s_state = ERROR;
+                continue;
+            }
+            char mac_data[5 /* MAC: */ + 6 * 2 /* 6 bytes per char */ + 5 /* : */ + 1 /* \0 */];
+            sprintf(mac_data, "MAC: %02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+            ESP_LOGI(TAG, "Sending MAC: %.*s", (int)sizeof(mac_data), mac_data);
+            s_transmit(eppp_netif, 1, (void*)mac_data, sizeof(mac_data));
+            s_state = START;
+            ret = esp_wifi_start();
+            ESP_LOGI(TAG, "WIFI start result: %d", ret);
+            esp_wifi_internal_reg_rxcb(WIFI_IF_STA, wifi_receive);
+        } else if (bits & WIFI_CONNECTED) {
+            ESP_LOGI(TAG, "WIFI connected");
+            const char connected[] = "Connected";
+            s_transmit(eppp_netif, 1, (void*)connected, sizeof(connected));
+        } else {
+            s_state = HELLO;
+            printf("Do nothing\n");
+            //         const char hello[] = "Hello server";
+            // s_transmit(eppp_netif, 1, (void*)hello, sizeof(hello));
+            // s_state = HELLO;
+        }
+    }
+
+    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);
     }
-    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) {
@@ -165,21 +261,16 @@ void app_main(void)
     config.transport = EPPP_TRANSPORT_SDIO;
 #endif // transport device
 
-    esp_netif_t *eppp_netif = eppp_listen(&config);
-    if (eppp_netif == NULL) {
+    s_eppp_netif = eppp_listen(&config);
+    if (s_eppp_netif == NULL) {
         ESP_LOGE(TAG, "Failed to setup connection");
         return ;
     }
-    ESP_ERROR_CHECK(esp_netif_napt_enable(eppp_netif));
+    // ESP_ERROR_CHECK(esp_netif_napt_enable(eppp_netif));
 #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)  {
-        char data[32];
-        sprintf(data, "Message from slave #%d", counter++);
-        transmit(eppp_netif, 1, data, strlen(data));
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
-    }
+    ESP_RETURN_ON_FALSE(s_events = xEventGroupCreate(),, TAG, "Failed to create event group");
+    ESP_RETURN_ON_FALSE(eppp_add_channels(s_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, s_eppp_netif, 5, NULL);
 #endif // CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 }