mesh: use new event library

components/esp_event/event_send.c

@@ -20,7 +20,6 @@ esp_err_t esp_event_send_noop(system_event_t *event);
 
 extern esp_err_t esp_event_send_legacy(system_event_t *event) __attribute__((weak, alias("esp_event_send_noop")));
 extern esp_err_t esp_event_send_to_default_loop(system_event_t *event) __attribute((weak, alias("esp_event_send_noop")));
-extern esp_err_t esp_event_mesh_hook(system_event_t* event) __attribute__((weak, alias("esp_event_send_noop")));
 
 
 esp_err_t esp_event_send_noop(system_event_t *event)
@@ -42,11 +41,5 @@ esp_err_t esp_event_send(system_event_t *event)
         return err;
     }
 
-    // send the event to mesh hook
-    err = esp_event_mesh_hook(event);
-    if (err != ESP_OK) {
-        return err;
-    }
-
     return ESP_OK;
 }

components/esp_wifi/include/esp_mesh.h

@@ -174,8 +174,6 @@ typedef enum {
     MESH_EVENT_ROOT_ADDRESS,            /**< the root address is obtained. It is posted by mesh stack automatically. */
     MESH_EVENT_ROOT_SWITCH_REQ,         /**< root switch request sent from a new voted root candidate */
     MESH_EVENT_ROOT_SWITCH_ACK,         /**< root switch acknowledgment responds the above request sent from current root */
-    MESH_EVENT_ROOT_GOT_IP,             /**< the root obtains the IP address. It is posted by LwIP stack automatically */
-    MESH_EVENT_ROOT_LOST_IP,            /**< the root loses the IP address. It is posted by LwIP stack automatically */
     MESH_EVENT_ROOT_ASKED_YIELD,        /**< the root is asked yield by a more powerful existing root. If self organized is disabled
                                              and this device is specified to be a root by users, users should set a new parent
                                              for this device. if self organized is enabled, this device will find a new parent
@@ -195,6 +193,9 @@ typedef enum {
     MESH_EVENT_MAX,
 } mesh_event_id_t;
 
+/** @brief ESP-MESH event base declaration */
+ESP_EVENT_DECLARE_BASE(MESH_EVENT);
+
 /**
  * @brief Device type
  */
@@ -427,21 +428,6 @@ typedef union {
     mesh_event_router_switch_t router_switch;              /**< new router information */
 } mesh_event_info_t;
 
-/**
- * @brief Mesh event
- */
-typedef struct {
-    mesh_event_id_t id;        /**< mesh event id */
-    mesh_event_info_t info;    /**< mesh event info */
-} mesh_event_t;
-
-/**
- * @brief  Mesh event callback handler prototype definition
- *
- * @param  event  mesh_event_t
- */
-typedef void (*mesh_event_cb_t)(mesh_event_t event);
-
 /**
  * @brief Mesh option
  */
@@ -492,7 +478,6 @@ typedef struct {
     uint8_t channel;                            /**< channel, the mesh network on */
     bool allow_channel_switch;                  /**< if this value is set, when "fail" (mesh_attempts_t) times is reached, device will change to
                                                      a full channel scan for a network that could join. The default value is false. */
-    mesh_event_cb_t event_cb;                   /**< mesh event callback */
     mesh_addr_t mesh_id;                        /**< mesh network identification */
     mesh_router_t router;                       /**< router configuration */
     mesh_ap_cfg_t mesh_ap;                      /**< mesh softAP configuration */
@@ -543,9 +528,6 @@ typedef struct {
 /* mesh IE crypto callback function */
 extern const mesh_crypto_funcs_t g_wifi_default_mesh_crypto_funcs;
 
-/* mesh event callback handler */
-extern mesh_event_cb_t g_mesh_event_cb;
-
 #define MESH_INIT_CONFIG_DEFAULT() { \
     .crypto_funcs = &g_wifi_default_mesh_crypto_funcs, \
 }
@@ -1303,16 +1285,6 @@ esp_err_t esp_mesh_set_root_healing_delay(int delay_ms);
  */
 int esp_mesh_get_root_healing_delay(void);
 
-/**
- * @brief      Set mesh event callback
- *
- * @param[in]  event_cb  mesh event call back
- *
- * @return
- *    - ESP_OK
- */
-esp_err_t esp_mesh_set_event_cb(const mesh_event_cb_t event_cb);
-
 /**
  * @brief      Enable network Fixed Root Setting
  *             - Enabling fixed root disables automatic election of the root node via voting.

components/esp_wifi/lib_esp32

@@ -1 +1 @@
-Subproject commit b7bfeeccdb63fd20cf6b4abc52d9185934af4cb8
+Subproject commit 414f9b279e772196e8f6cf343d19f2882a2e8741

components/esp_wifi/src/mesh_event.c

@@ -14,24 +14,10 @@
 
 #include <string.h>
 #include "esp_event.h"
-#include "esp_mesh.h"
 
-/* mesh event callback handler */
-mesh_event_cb_t g_mesh_event_cb = NULL;
+ESP_EVENT_DEFINE_BASE(MESH_EVENT);
 
-esp_err_t esp_event_mesh_hook(system_event_t *event)
+esp_err_t esp_mesh_send_event_internal(int32_t event_id, void* event_data, size_t event_data_size)
 {
-    if (event->event_id == SYSTEM_EVENT_STA_GOT_IP || event->event_id == SYSTEM_EVENT_STA_LOST_IP) {
-        if (g_mesh_event_cb) {
-            mesh_event_t mevent;
-            if (event->event_id == SYSTEM_EVENT_STA_GOT_IP) {
-                mevent.id = MESH_EVENT_ROOT_GOT_IP;
-                memcpy(&mevent.info.got_ip, &event->event_info.got_ip, sizeof(system_event_sta_got_ip_t));
-            } else {
-                mevent.id = MESH_EVENT_ROOT_LOST_IP;
-            }
-            g_mesh_event_cb(mevent);
-        }
-    }
-    return ESP_OK;
+    return esp_event_post(MESH_EVENT, event_id, event_data, event_data_size, 0);
 }

examples/mesh/internal_communication/main/mesh_main.c

@@ -9,7 +9,7 @@
 #include <string.h>
 #include "esp_wifi.h"
 #include "esp_system.h"
-#include "esp_event_loop.h"
+#include "esp_event.h"
 #include "esp_log.h"
 #include "esp_mesh.h"
 #include "esp_mesh_internal.h"
@@ -19,7 +19,6 @@
 /*******************************************************
  *                Macros
  *******************************************************/
-//#define MESH_P2P_TOS_OFF
 
 /*******************************************************
  *                Constants
@@ -71,11 +70,9 @@ void esp_mesh_p2p_tx_main(void *arg)
     data.data = tx_buf;
     data.size = sizeof(tx_buf);
     data.proto = MESH_PROTO_BIN;
-#ifdef MESH_P2P_TOS_OFF
-    data.tos = MESH_TOS_DEF;
-#endif /* MESH_P2P_TOS_OFF */
-
+    data.tos = MESH_TOS_P2P;
     is_running = true;
+
     while (is_running) {
         /* non-root do nothing but print */
         if (!esp_mesh_is_root()) {
@@ -138,8 +135,8 @@ void esp_mesh_p2p_rx_main(void *arg)
     int flag = 0;
     data.data = rx_buf;
     data.size = RX_SIZE;
-
     is_running = true;
+
     while (is_running) {
         data.size = RX_SIZE;
         err = esp_mesh_recv(&from, &data, portMAX_DELAY, &flag, NULL, 0);
@@ -178,53 +175,66 @@ esp_err_t esp_mesh_comm_p2p_start(void)
     return ESP_OK;
 }
 
-void mesh_event_handler(mesh_event_t event)
+void mesh_event_handler(void *arg, esp_event_base_t event_base,
+                        int32_t event_id, void *event_data)
 {
     mesh_addr_t id = {0,};
     static uint8_t last_layer = 0;
-    ESP_LOGD(MESH_TAG, "esp_event_handler:%d", event.id);
 
-    switch (event.id) {
-    case MESH_EVENT_STARTED:
+    switch (event_id) {
+    case MESH_EVENT_STARTED: {
         esp_mesh_get_id(&id);
-        ESP_LOGI(MESH_TAG, "<MESH_EVENT_STARTED>ID:"MACSTR"", MAC2STR(id.addr));
+        ESP_LOGI(MESH_TAG, "<MESH_EVENT_MESH_STARTED>ID:"MACSTR"", MAC2STR(id.addr));
         is_mesh_connected = false;
         mesh_layer = esp_mesh_get_layer();
-        break;
-    case MESH_EVENT_STOPPED:
+    }
+    break;
+    case MESH_EVENT_STOPPED: {
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOPPED>");
         is_mesh_connected = false;
         mesh_layer = esp_mesh_get_layer();
-        break;
-    case MESH_EVENT_CHILD_CONNECTED:
+    }
+    break;
+    case MESH_EVENT_CHILD_CONNECTED: {
+        mesh_event_child_connected_t *child_connected = (mesh_event_child_connected_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"",
-                 event.info.child_connected.aid,
-                 MAC2STR(event.info.child_connected.mac));
-        break;
-    case MESH_EVENT_CHILD_DISCONNECTED:
+                 child_connected->aid,
+                 MAC2STR(child_connected->mac));
+    }
+    break;
+    case MESH_EVENT_CHILD_DISCONNECTED: {
+        mesh_event_child_disconnected_t *child_disconnected = (mesh_event_child_disconnected_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"",
-                 event.info.child_disconnected.aid,
-                 MAC2STR(event.info.child_disconnected.mac));
-        break;
-    case MESH_EVENT_ROUTING_TABLE_ADD:
+                 child_disconnected->aid,
+                 MAC2STR(child_disconnected->mac));
+    }
+    break;
+    case MESH_EVENT_ROUTING_TABLE_ADD: {
+        mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
         ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d",
-                 event.info.routing_table.rt_size_change,
-                 event.info.routing_table.rt_size_new);
-        break;
-    case MESH_EVENT_ROUTING_TABLE_REMOVE:
+                 routing_table->rt_size_change,
+                 routing_table->rt_size_new);
+    }
+    break;
+    case MESH_EVENT_ROUTING_TABLE_REMOVE: {
+        mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
         ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d",
-                 event.info.routing_table.rt_size_change,
-                 event.info.routing_table.rt_size_new);
-        break;
-    case MESH_EVENT_NO_PARENT_FOUND:
+                 routing_table->rt_size_change,
+                 routing_table->rt_size_new);
+    }
+    break;
+    case MESH_EVENT_NO_PARENT_FOUND: {
+        mesh_event_no_parent_found_t *no_parent = (mesh_event_no_parent_found_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d",
-                 event.info.no_parent.scan_times);
-        /* TODO handler for the failure */
-        break;
-    case MESH_EVENT_PARENT_CONNECTED:
+                 no_parent->scan_times);
+    }
+    /* TODO handler for the failure */
+    break;
+    case MESH_EVENT_PARENT_CONNECTED: {
+        mesh_event_connected_t *connected = (mesh_event_connected_t *)event_data;
         esp_mesh_get_id(&id);
-        mesh_layer = event.info.connected.self_layer;
-        memcpy(&mesh_parent_addr.addr, event.info.connected.connected.bssid, 6);
+        mesh_layer = connected->self_layer;
+        memcpy(&mesh_parent_addr.addr, connected->connected.bssid, 6);
         ESP_LOGI(MESH_TAG,
                  "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR"",
                  last_layer, mesh_layer, MAC2STR(mesh_parent_addr.addr),
@@ -237,104 +247,129 @@ void mesh_event_handler(mesh_event_t event)
             tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
         }
         esp_mesh_comm_p2p_start();
-        break;
-    case MESH_EVENT_PARENT_DISCONNECTED:
+    }
+    break;
+    case MESH_EVENT_PARENT_DISCONNECTED: {
+        mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)event_data;
         ESP_LOGI(MESH_TAG,
                  "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d",
-                 event.info.disconnected.reason);
+                 disconnected->reason);
         is_mesh_connected = false;
         mesh_disconnected_indicator();
         mesh_layer = esp_mesh_get_layer();
-        break;
-    case MESH_EVENT_LAYER_CHANGE:
-        mesh_layer = event.info.layer_change.new_layer;
+    }
+    break;
+    case MESH_EVENT_LAYER_CHANGE: {
+        mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)event_data;
+        mesh_layer = layer_change->new_layer;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s",
                  last_layer, mesh_layer,
                  esp_mesh_is_root() ? "<ROOT>" :
                  (mesh_layer == 2) ? "<layer2>" : "");
         last_layer = mesh_layer;
         mesh_connected_indicator(mesh_layer);
-        break;
-    case MESH_EVENT_ROOT_ADDRESS:
+    }
+    break;
+    case MESH_EVENT_ROOT_ADDRESS: {
+        mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"",
-                 MAC2STR(event.info.root_addr.addr));
-        break;
-    case MESH_EVENT_ROOT_GOT_IP:
-        /* root starts to connect to server */
-        ESP_LOGI(MESH_TAG,
-                 "<MESH_EVENT_ROOT_GOT_IP>sta ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR,
-                 IP2STR(&event.info.got_ip.ip_info.ip),
-                 IP2STR(&event.info.got_ip.ip_info.netmask),
-                 IP2STR(&event.info.got_ip.ip_info.gw));
-        break;
-    case MESH_EVENT_ROOT_LOST_IP:
-        ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_LOST_IP>");
-        break;
-    case MESH_EVENT_VOTE_STARTED:
+                 MAC2STR(root_addr->addr));
+    }
+    break;
+    case MESH_EVENT_VOTE_STARTED: {
+        mesh_event_vote_started_t *vote_started = (mesh_event_vote_started_t *)event_data;
         ESP_LOGI(MESH_TAG,
                  "<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:"MACSTR"",
-                 event.info.vote_started.attempts,
-                 event.info.vote_started.reason,
-                 MAC2STR(event.info.vote_started.rc_addr.addr));
-        break;
-    case MESH_EVENT_VOTE_STOPPED:
+                 vote_started->attempts,
+                 vote_started->reason,
+                 MAC2STR(vote_started->rc_addr.addr));
+    }
+    break;
+    case MESH_EVENT_VOTE_STOPPED: {
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_VOTE_STOPPED>");
         break;
-    case MESH_EVENT_ROOT_SWITCH_REQ:
+    }
+    case MESH_EVENT_ROOT_SWITCH_REQ: {
+        mesh_event_root_switch_req_t *switch_req = (mesh_event_root_switch_req_t *)event_data;
         ESP_LOGI(MESH_TAG,
                  "<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:"MACSTR"",
-                 event.info.switch_req.reason,
-                 MAC2STR( event.info.switch_req.rc_addr.addr));
-        break;
-    case MESH_EVENT_ROOT_SWITCH_ACK:
+                 switch_req->reason,
+                 MAC2STR( switch_req->rc_addr.addr));
+    }
+    break;
+    case MESH_EVENT_ROOT_SWITCH_ACK: {
         /* new root */
         mesh_layer = esp_mesh_get_layer();
         esp_mesh_get_parent_bssid(&mesh_parent_addr);
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", mesh_layer, MAC2STR(mesh_parent_addr.addr));
-        break;
-    case MESH_EVENT_TODS_STATE:
-        ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d",
-                 event.info.toDS_state);
-        break;
-    case MESH_EVENT_ROOT_FIXED:
+    }
+    break;
+    case MESH_EVENT_TODS_STATE: {
+        mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)event_data;
+        ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", *toDs_state);
+    }
+    break;
+    case MESH_EVENT_ROOT_FIXED: {
+        mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_FIXED>%s",
-                 event.info.root_fixed.is_fixed ? "fixed" : "not fixed");
-        break;
-    case MESH_EVENT_ROOT_ASKED_YIELD:
+                 root_fixed->is_fixed ? "fixed" : "not fixed");
+    }
+    break;
+    case MESH_EVENT_ROOT_ASKED_YIELD: {
+        mesh_event_root_conflict_t *root_conflict = (mesh_event_root_conflict_t *)event_data;
         ESP_LOGI(MESH_TAG,
                  "<MESH_EVENT_ROOT_ASKED_YIELD>"MACSTR", rssi:%d, capacity:%d",
-                 MAC2STR(event.info.root_conflict.addr),
-                 event.info.root_conflict.rssi,
-                 event.info.root_conflict.capacity);
-        break;
-    case MESH_EVENT_CHANNEL_SWITCH:
-        ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHANNEL_SWITCH>new channel:%d", event.info.channel_switch.channel);
-        break;
-    case MESH_EVENT_SCAN_DONE:
+                 MAC2STR(root_conflict->addr),
+                 root_conflict->rssi,
+                 root_conflict->capacity);
+    }
+    break;
+    case MESH_EVENT_CHANNEL_SWITCH: {
+        mesh_event_channel_switch_t *channel_switch = (mesh_event_channel_switch_t *)event_data;
+        ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHANNEL_SWITCH>new channel:%d", channel_switch->channel);
+    }
+    break;
+    case MESH_EVENT_SCAN_DONE: {
+        mesh_event_scan_done_t *scan_done = (mesh_event_scan_done_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_SCAN_DONE>number:%d",
-                 event.info.scan_done.number);
-        break;
-    case MESH_EVENT_NETWORK_STATE:
+                 scan_done->number);
+    }
+    break;
+    case MESH_EVENT_NETWORK_STATE: {
+        mesh_event_network_state_t *network_state = (mesh_event_network_state_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_NETWORK_STATE>is_rootless:%d",
-                 event.info.network_state.is_rootless);
-        break;
-    case MESH_EVENT_STOP_RECONNECTION:
+                 network_state->is_rootless);
+    }
+    break;
+    case MESH_EVENT_STOP_RECONNECTION: {
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOP_RECONNECTION>");
-        break;
-    case MESH_EVENT_FIND_NETWORK:
+    }
+    break;
+    case MESH_EVENT_FIND_NETWORK: {
+        mesh_event_find_network_t *find_network = (mesh_event_find_network_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_FIND_NETWORK>new channel:%d, router BSSID:"MACSTR"",
-                 event.info.find_network.channel, MAC2STR(event.info.find_network.router_bssid));
-        break;
-    case MESH_EVENT_ROUTER_SWITCH:
+                 find_network->channel, MAC2STR(find_network->router_bssid));
+    }
+    break;
+    case MESH_EVENT_ROUTER_SWITCH: {
+        mesh_event_router_switch_t *router_switch = (mesh_event_router_switch_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROUTER_SWITCH>new router:%s, channel:%d, "MACSTR"",
-                 event.info.router_switch.ssid, event.info.router_switch.channel, MAC2STR(event.info.router_switch.bssid));
-        break;
+                 router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid));
+    }
+    break;
     default:
-        ESP_LOGI(MESH_TAG, "unknown id:%d", event.id);
+        ESP_LOGI(MESH_TAG, "unknown id:%d", event_id);
         break;
     }
 }
 
+void ip_event_handler(void *arg, esp_event_base_t event_base,
+                      int32_t event_id, void *event_data)
+{
+    ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
+    ESP_LOGI(MESH_TAG, "<IP_EVENT_STA_GOT_IP>IP:%s", ip4addr_ntoa(&event->ip_info.ip));
+}
+
 void app_main(void)
 {
     ESP_ERROR_CHECK(mesh_light_init());
@@ -347,33 +382,23 @@ void app_main(void)
      * */
     ESP_ERROR_CHECK(tcpip_adapter_dhcps_stop(TCPIP_ADAPTER_IF_AP));
     ESP_ERROR_CHECK(tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA));
-#if 0
-    /* static ip settings */
-    tcpip_adapter_ip_info_t sta_ip;
-    sta_ip.ip.addr = ipaddr_addr("192.168.1.102");
-    sta_ip.gw.addr = ipaddr_addr("192.168.1.1");
-    sta_ip.netmask.addr = ipaddr_addr("255.255.255.0");
-    tcpip_adapter_set_ip_info(WIFI_IF_STA, &sta_ip);
-#endif
+    /*  event initialization */
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
     /*  wifi initialization */
-    ESP_ERROR_CHECK(esp_event_loop_init(NULL, NULL));
     wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_wifi_init(&config));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &ip_event_handler, NULL));
     ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH));
     ESP_ERROR_CHECK(esp_wifi_start());
     /*  mesh initialization */
     ESP_ERROR_CHECK(esp_mesh_init());
+    ESP_ERROR_CHECK(esp_event_handler_register(MESH_EVENT, ESP_EVENT_ANY_ID, &mesh_event_handler, NULL));
     ESP_ERROR_CHECK(esp_mesh_set_max_layer(CONFIG_MESH_MAX_LAYER));
     ESP_ERROR_CHECK(esp_mesh_set_vote_percentage(1));
     ESP_ERROR_CHECK(esp_mesh_set_ap_assoc_expire(10));
-#ifdef MESH_FIX_ROOT
-    ESP_ERROR_CHECK(esp_mesh_fix_root(1));
-#endif
     mesh_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT();
     /* mesh ID */
     memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);
-    /* mesh event callback */
-    cfg.event_cb = &mesh_event_handler;
     /* router */
     cfg.channel = CONFIG_MESH_CHANNEL;
     cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID);

examples/mesh/manual_networking/main/mesh_main.c

@@ -9,7 +9,7 @@
 #include <string.h>
 #include "esp_wifi.h"
 #include "esp_system.h"
-#include "esp_event_loop.h"
+#include "esp_event.h"
 #include "esp_log.h"
 #include "esp_mesh.h"
 #include "esp_mesh_internal.h"
@@ -40,7 +40,6 @@ static int mesh_layer = -1;
 /*******************************************************
  *                Function Declarations
  *******************************************************/
-void mesh_event_handler(mesh_event_t event);
 void mesh_scan_done_handler(int num);
 
 /*******************************************************
@@ -156,58 +155,70 @@ void mesh_scan_done_handler(int num)
     }
 }
 
-void mesh_event_handler(mesh_event_t event)
+void mesh_event_handler(void *arg, esp_event_base_t event_base,
+                        int32_t event_id, void *event_data)
 {
     mesh_addr_t id = {0,};
     static uint8_t last_layer = 0;
-    ESP_LOGD(MESH_TAG, "esp_event_handler:%d", event.id);
+    wifi_scan_config_t scan_config = { 0 };
 
-    switch (event.id) {
-    case MESH_EVENT_STARTED:
+    switch (event_id) {
+    case MESH_EVENT_STARTED: {
         esp_mesh_get_id(&id);
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_STARTED>ID:"MACSTR"", MAC2STR(id.addr));
         mesh_layer = esp_mesh_get_layer();
         ESP_ERROR_CHECK(esp_mesh_set_self_organized(0, 0));
         esp_wifi_scan_stop();
-        wifi_scan_config_t scan_config = { 0 };
         /* mesh softAP is hidden */
         scan_config.show_hidden = 1;
         scan_config.scan_type = WIFI_SCAN_TYPE_PASSIVE;
         ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_config, 0));
-        break;
-    case MESH_EVENT_STOPPED:
+    }
+    break;
+    case MESH_EVENT_STOPPED: {
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOPPED>");
         mesh_layer = esp_mesh_get_layer();
-        break;
-    case MESH_EVENT_CHILD_CONNECTED:
+    }
+    break;
+    case MESH_EVENT_CHILD_CONNECTED: {
+        mesh_event_child_connected_t *child_connected = (mesh_event_child_connected_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"",
-                 event.info.child_connected.aid,
-                 MAC2STR(event.info.child_connected.mac));
-        break;
-    case MESH_EVENT_CHILD_DISCONNECTED:
+                 child_connected->aid,
+                 MAC2STR(child_connected->mac));
+    }
+    break;
+    case MESH_EVENT_CHILD_DISCONNECTED: {
+        mesh_event_child_disconnected_t *child_disconnected = (mesh_event_child_disconnected_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"",
-                 event.info.child_disconnected.aid,
-                 MAC2STR(event.info.child_disconnected.mac));
-        break;
-    case MESH_EVENT_ROUTING_TABLE_ADD:
+                 child_disconnected->aid,
+                 MAC2STR(child_disconnected->mac));
+    }
+    case MESH_EVENT_ROUTING_TABLE_ADD: {
+        mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
         ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d",
-                 event.info.routing_table.rt_size_change,
-                 event.info.routing_table.rt_size_new);
-        break;
-    case MESH_EVENT_ROUTING_TABLE_REMOVE:
+                 routing_table->rt_size_change,
+                 routing_table->rt_size_new);
+    }
+    break;
+    case MESH_EVENT_ROUTING_TABLE_REMOVE: {
+        mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
         ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d",
-                 event.info.routing_table.rt_size_change,
-                 event.info.routing_table.rt_size_new);
-        break;
-    case MESH_EVENT_NO_PARENT_FOUND:
+                 routing_table->rt_size_change,
+                 routing_table->rt_size_new);
+    }
+    break;
+    case MESH_EVENT_NO_PARENT_FOUND: {
+        mesh_event_no_parent_found_t *no_parent = (mesh_event_no_parent_found_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d",
-                 event.info.no_parent.scan_times);
-        /* TODO handler for the failure */
-        break;
-    case MESH_EVENT_PARENT_CONNECTED:
+                 no_parent->scan_times);
+    }
+    /* TODO handler for the failure */
+    break;
+    case MESH_EVENT_PARENT_CONNECTED: {
+        mesh_event_connected_t *connected = (mesh_event_connected_t *)event_data;
         esp_mesh_get_id(&id);
-        mesh_layer = event.info.connected.self_layer;
-        memcpy(&mesh_parent_addr.addr, event.info.connected.connected.bssid, 6);
+        mesh_layer = connected->self_layer;
+        memcpy(&mesh_parent_addr.addr, connected->connected.bssid, 6);
         ESP_LOGI(MESH_TAG,
                  "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR"",
                  last_layer, mesh_layer, MAC2STR(mesh_parent_addr.addr),
@@ -218,59 +229,71 @@ void mesh_event_handler(mesh_event_t event)
         if (esp_mesh_is_root()) {
             tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
         }
-        break;
-    case MESH_EVENT_PARENT_DISCONNECTED:
+    }
+    break;
+    case MESH_EVENT_PARENT_DISCONNECTED: {
+        mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)event_data;
         ESP_LOGI(MESH_TAG,
                  "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d",
-                 event.info.disconnected.reason);
+                 disconnected->reason);
         mesh_disconnected_indicator();
         mesh_layer = esp_mesh_get_layer();
-        if (event.info.disconnected.reason == WIFI_REASON_ASSOC_TOOMANY) {
+        if (disconnected->reason == WIFI_REASON_ASSOC_TOOMANY) {
             esp_wifi_scan_stop();
             scan_config.show_hidden = 1;
             scan_config.scan_type = WIFI_SCAN_TYPE_PASSIVE;
             ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_config, 0));
         }
-        break;
-    case MESH_EVENT_LAYER_CHANGE:
-        mesh_layer = event.info.layer_change.new_layer;
+    }
+    break;
+    case MESH_EVENT_LAYER_CHANGE: {
+        mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)event_data;
+        mesh_layer = layer_change->new_layer;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s",
                  last_layer, mesh_layer,
                  esp_mesh_is_root() ? "<ROOT>" :
                  (mesh_layer == 2) ? "<layer2>" : "");
         last_layer = mesh_layer;
         mesh_connected_indicator(mesh_layer);
-        break;
-    case MESH_EVENT_ROOT_ADDRESS:
+    }
+    break;
+    case MESH_EVENT_ROOT_ADDRESS: {
+        mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"",
-                 MAC2STR(event.info.root_addr.addr));
-        break;
-    case MESH_EVENT_ROOT_GOT_IP:
-        /* root starts to connect to server */
-        ESP_LOGI(MESH_TAG,
-                 "<MESH_EVENT_ROOT_GOT_IP>sta ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR,
-                 IP2STR(&event.info.got_ip.ip_info.ip),
-                 IP2STR(&event.info.got_ip.ip_info.netmask),
-                 IP2STR(&event.info.got_ip.ip_info.gw));
-        break;
-    case MESH_EVENT_ROOT_LOST_IP:
-        ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_LOST_IP>");
-        break;
-    case MESH_EVENT_ROOT_FIXED:
+                 MAC2STR(root_addr->addr));
+    }
+    break;
+    case MESH_EVENT_TODS_STATE: {
+        mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)event_data;
+        ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", *toDs_state);
+    }
+    break;
+    case MESH_EVENT_ROOT_FIXED: {
+        mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_FIXED>%s",
-                 event.info.root_fixed.is_fixed ? "fixed" : "not fixed");
-        break;
-    case MESH_EVENT_SCAN_DONE:
+                 root_fixed->is_fixed ? "fixed" : "not fixed");
+    }
+    break;
+    case MESH_EVENT_SCAN_DONE: {
+        mesh_event_scan_done_t *scan_done = (mesh_event_scan_done_t *)event_data;
         ESP_LOGI(MESH_TAG, "<MESH_EVENT_SCAN_DONE>number:%d",
-                 event.info.scan_done.number);
-        mesh_scan_done_handler(event.info.scan_done.number);
-        break;
+                 scan_done->number);
+        mesh_scan_done_handler(scan_done->number);
+    }
+    break;
     default:
-        ESP_LOGI(MESH_TAG, "unknown id:%d", event.id);
+        ESP_LOGI(MESH_TAG, "unknown id:%d", event_id);
         break;
     }
 }
 
+void ip_event_handler(void *arg, esp_event_base_t event_base,
+                      int32_t event_id, void *event_data)
+{
+    ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
+    ESP_LOGI(MESH_TAG, "<IP_EVENT_STA_GOT_IP>IP:%s", ip4addr_ntoa(&event->ip_info.ip));
+}
+
 void app_main(void)
 {
     ESP_ERROR_CHECK(mesh_light_init());
@@ -283,28 +306,21 @@ void app_main(void)
      * */
     ESP_ERROR_CHECK(tcpip_adapter_dhcps_stop(TCPIP_ADAPTER_IF_AP));
     ESP_ERROR_CHECK(tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA));
-#if 0
-    /* static ip settings */
-    tcpip_adapter_ip_info_t sta_ip;
-    sta_ip.ip.addr = ipaddr_addr("192.168.1.102");
-    sta_ip.gw.addr = ipaddr_addr("192.168.1.1");
-    sta_ip.netmask.addr = ipaddr_addr("255.255.255.0");
-    tcpip_adapter_set_ip_info(WIFI_IF_STA, &sta_ip);
-#endif
+    /*  event initialization */
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
     /*  wifi initialization */
-    ESP_ERROR_CHECK(esp_event_loop_init(NULL, NULL));
     wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_wifi_init(&config));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &ip_event_handler, NULL));
     ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH));
     ESP_ERROR_CHECK(esp_wifi_start());
     /*  mesh initialization */
     ESP_ERROR_CHECK(esp_mesh_init());
+    ESP_ERROR_CHECK(esp_event_handler_register(MESH_EVENT, ESP_EVENT_ANY_ID, &mesh_event_handler, NULL));
     /* mesh enable IE crypto */
     mesh_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT();
     /* mesh ID */
     memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);
-    /* mesh event callback */
-    cfg.event_cb = &mesh_event_handler;
     /* router */
     cfg.channel = CONFIG_MESH_CHANNEL;
     cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID);