Crash_Override/OVMS3-idf
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

mesh: use new event library

Browse source
This commit is contained in:
qiyuexia 2019-04-16 18:13:13 +08:00 committed by chenyudong
parent f16f4297cd
commit a272e7204d
6 changed files with 237 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
components/esp_event/event_send.c
View file

@ -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_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_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) 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; return err;
} }
// send the event to mesh hook
err = esp_event_mesh_hook(event);
if (err != ESP_OK) {
return err;
}
return ESP_OK; return ESP_OK;
} }

34
components/esp_wifi/include/esp_mesh.h
View file

@ -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_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_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_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 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 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 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_MAX,
} mesh_event_id_t; } mesh_event_id_t;
/** @brief ESP-MESH event base declaration */
ESP_EVENT_DECLARE_BASE(MESH_EVENT);
/** /**
* @brief Device type * @brief Device type
*/ */
@ -427,21 +428,6 @@ typedef union {
mesh_event_router_switch_t router_switch; /**< new router information */ mesh_event_router_switch_t router_switch; /**< new router information */
} mesh_event_info_t; } 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 * @brief Mesh option
*/ */
@ -492,7 +478,6 @@ typedef struct {
uint8_t channel; /**< channel, the mesh network on */ 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 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. */ 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_addr_t mesh_id; /**< mesh network identification */
mesh_router_t router; /**< router configuration */ mesh_router_t router; /**< router configuration */
mesh_ap_cfg_t mesh_ap; /**< mesh softAP configuration */ mesh_ap_cfg_t mesh_ap; /**< mesh softAP configuration */
@ -543,9 +528,6 @@ typedef struct {
/* mesh IE crypto callback function */ /* mesh IE crypto callback function */
extern const mesh_crypto_funcs_t g_wifi_default_mesh_crypto_funcs; 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() { \ #define MESH_INIT_CONFIG_DEFAULT() { \
.crypto_funcs = &g_wifi_default_mesh_crypto_funcs, \ .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); 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 * @brief Enable network Fixed Root Setting
* - Enabling fixed root disables automatic election of the root node via voting. * - Enabling fixed root disables automatic election of the root node via voting.

2
components/esp_wifi/lib_esp32

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

20
components/esp_wifi/src/mesh_event.c
View file

@ -14,24 +14,10 @@
#include <string.h> #include <string.h>
#include "esp_event.h" #include "esp_event.h"
#include "esp_mesh.h"
/* mesh event callback handler */ ESP_EVENT_DEFINE_BASE(MESH_EVENT);
mesh_event_cb_t g_mesh_event_cb = NULL;
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) { return esp_event_post(MESH_EVENT, event_id, event_data, event_data_size, 0);
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;
} }

255
examples/mesh/internal_communication/main/mesh_main.c
View file

@ -9,7 +9,7 @@
#include <string.h> #include <string.h>
#include "esp_wifi.h" #include "esp_wifi.h"
#include "esp_system.h" #include "esp_system.h"
#include "esp_event_loop.h" #include "esp_event.h"
#include "esp_log.h" #include "esp_log.h"
#include "esp_mesh.h" #include "esp_mesh.h"
#include "esp_mesh_internal.h" #include "esp_mesh_internal.h"
@ -19,7 +19,6 @@
/******************************************************* /*******************************************************
* Macros * Macros
*******************************************************/ *******************************************************/
//#define MESH_P2P_TOS_OFF
/******************************************************* /*******************************************************
* Constants * Constants
@ -71,11 +70,9 @@ void esp_mesh_p2p_tx_main(void *arg)
data.data = tx_buf; data.data = tx_buf;
data.size = sizeof(tx_buf); data.size = sizeof(tx_buf);
data.proto = MESH_PROTO_BIN; data.proto = MESH_PROTO_BIN;
#ifdef MESH_P2P_TOS_OFF data.tos = MESH_TOS_P2P;
data.tos = MESH_TOS_DEF;
#endif /* MESH_P2P_TOS_OFF */
is_running = true; is_running = true;
while (is_running) { while (is_running) {
/* non-root do nothing but print */ /* non-root do nothing but print */
if (!esp_mesh_is_root()) { if (!esp_mesh_is_root()) {
@ -138,8 +135,8 @@ void esp_mesh_p2p_rx_main(void *arg)
int flag = 0; int flag = 0;
data.data = rx_buf; data.data = rx_buf;
data.size = RX_SIZE; data.size = RX_SIZE;
is_running = true; is_running = true;
while (is_running) { while (is_running) {
data.size = RX_SIZE; data.size = RX_SIZE;
err = esp_mesh_recv(&from, &data, portMAX_DELAY, &flag, NULL, 0); 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; 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,}; mesh_addr_t id = {0,};
static uint8_t last_layer = 0; static uint8_t last_layer = 0;
ESP_LOGD(MESH_TAG, "esp_event_handler:%d", event.id);
switch (event.id) { switch (event_id) {
case MESH_EVENT_STARTED: case MESH_EVENT_STARTED: {
esp_mesh_get_id(&id); 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; is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer(); mesh_layer = esp_mesh_get_layer();
break; }
case MESH_EVENT_STOPPED: break;
case MESH_EVENT_STOPPED: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOPPED>"); ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOPPED>");
is_mesh_connected = false; is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer(); 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"", ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"",
event.info.child_connected.aid, child_connected->aid,
MAC2STR(event.info.child_connected.mac)); MAC2STR(child_connected->mac));
break; }
case MESH_EVENT_CHILD_DISCONNECTED: 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"", ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"",
event.info.child_disconnected.aid, child_disconnected->aid,
MAC2STR(event.info.child_disconnected.mac)); MAC2STR(child_disconnected->mac));
break; }
case MESH_EVENT_ROUTING_TABLE_ADD: 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", ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d",
event.info.routing_table.rt_size_change, routing_table->rt_size_change,
event.info.routing_table.rt_size_new); routing_table->rt_size_new);
break; }
case MESH_EVENT_ROUTING_TABLE_REMOVE: 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", ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d",
event.info.routing_table.rt_size_change, routing_table->rt_size_change,
event.info.routing_table.rt_size_new); routing_table->rt_size_new);
break; }
case MESH_EVENT_NO_PARENT_FOUND: 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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d",
event.info.no_parent.scan_times); no_parent->scan_times);
/* TODO handler for the failure */ }
break; /* TODO handler for the failure */
case MESH_EVENT_PARENT_CONNECTED: break;
case MESH_EVENT_PARENT_CONNECTED: {
mesh_event_connected_t *connected = (mesh_event_connected_t *)event_data;
esp_mesh_get_id(&id); esp_mesh_get_id(&id);
mesh_layer = event.info.connected.self_layer; mesh_layer = connected->self_layer;
memcpy(&mesh_parent_addr.addr, event.info.connected.connected.bssid, 6); memcpy(&mesh_parent_addr.addr, connected->connected.bssid, 6);
ESP_LOGI(MESH_TAG, ESP_LOGI(MESH_TAG,
"<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR"", "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR"",
last_layer, mesh_layer, MAC2STR(mesh_parent_addr.addr), 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); tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
} }
esp_mesh_comm_p2p_start(); 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, ESP_LOGI(MESH_TAG,
"<MESH_EVENT_PARENT_DISCONNECTED>reason:%d", "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d",
event.info.disconnected.reason); disconnected->reason);
is_mesh_connected = false; is_mesh_connected = false;
mesh_disconnected_indicator(); mesh_disconnected_indicator();
mesh_layer = esp_mesh_get_layer(); mesh_layer = esp_mesh_get_layer();
break; }
case MESH_EVENT_LAYER_CHANGE: break;
mesh_layer = event.info.layer_change.new_layer; 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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s",
last_layer, mesh_layer, last_layer, mesh_layer,
esp_mesh_is_root() ? "<ROOT>" : esp_mesh_is_root() ? "<ROOT>" :
(mesh_layer == 2) ? "<layer2>" : ""); (mesh_layer == 2) ? "<layer2>" : "");
last_layer = mesh_layer; last_layer = mesh_layer;
mesh_connected_indicator(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"", ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"",
MAC2STR(event.info.root_addr.addr)); MAC2STR(root_addr->addr));
break; }
case MESH_EVENT_ROOT_GOT_IP: break;
/* root starts to connect to server */ case MESH_EVENT_VOTE_STARTED: {
ESP_LOGI(MESH_TAG, mesh_event_vote_started_t *vote_started = (mesh_event_vote_started_t *)event_data;
"<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:
ESP_LOGI(MESH_TAG, ESP_LOGI(MESH_TAG,
"<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:"MACSTR"", "<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:"MACSTR"",
event.info.vote_started.attempts, vote_started->attempts,
event.info.vote_started.reason, vote_started->reason,
MAC2STR(event.info.vote_started.rc_addr.addr)); MAC2STR(vote_started->rc_addr.addr));
break; }
case MESH_EVENT_VOTE_STOPPED: break;
case MESH_EVENT_VOTE_STOPPED: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_VOTE_STOPPED>"); ESP_LOGI(MESH_TAG, "<MESH_EVENT_VOTE_STOPPED>");
break; 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, ESP_LOGI(MESH_TAG,
"<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:"MACSTR"", "<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:"MACSTR"",
event.info.switch_req.reason, switch_req->reason,
MAC2STR( event.info.switch_req.rc_addr.addr)); MAC2STR( switch_req->rc_addr.addr));
break; }
case MESH_EVENT_ROOT_SWITCH_ACK: break;
case MESH_EVENT_ROOT_SWITCH_ACK: {
/* new root */ /* new root */
mesh_layer = esp_mesh_get_layer(); mesh_layer = esp_mesh_get_layer();
esp_mesh_get_parent_bssid(&mesh_parent_addr); 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)); 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: break;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", case MESH_EVENT_TODS_STATE: {
event.info.toDS_state); mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)event_data;
break; ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", *toDs_state);
case MESH_EVENT_ROOT_FIXED: }
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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_FIXED>%s",
event.info.root_fixed.is_fixed ? "fixed" : "not fixed"); root_fixed->is_fixed ? "fixed" : "not fixed");
break; }
case MESH_EVENT_ROOT_ASKED_YIELD: 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, ESP_LOGI(MESH_TAG,
"<MESH_EVENT_ROOT_ASKED_YIELD>"MACSTR", rssi:%d, capacity:%d", "<MESH_EVENT_ROOT_ASKED_YIELD>"MACSTR", rssi:%d, capacity:%d",
MAC2STR(event.info.root_conflict.addr), MAC2STR(root_conflict->addr),
event.info.root_conflict.rssi, root_conflict->rssi,
event.info.root_conflict.capacity); root_conflict->capacity);
break; }
case MESH_EVENT_CHANNEL_SWITCH: break;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHANNEL_SWITCH>new channel:%d", event.info.channel_switch.channel); case MESH_EVENT_CHANNEL_SWITCH: {
break; mesh_event_channel_switch_t *channel_switch = (mesh_event_channel_switch_t *)event_data;
case MESH_EVENT_SCAN_DONE: 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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_SCAN_DONE>number:%d",
event.info.scan_done.number); scan_done->number);
break; }
case MESH_EVENT_NETWORK_STATE: 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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_NETWORK_STATE>is_rootless:%d",
event.info.network_state.is_rootless); network_state->is_rootless);
break; }
case MESH_EVENT_STOP_RECONNECTION: break;
case MESH_EVENT_STOP_RECONNECTION: {
ESP_LOGI(MESH_TAG, "<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"", 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)); find_network->channel, MAC2STR(find_network->router_bssid));
break; }
case MESH_EVENT_ROUTER_SWITCH: 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"", 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)); router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid));
break; }
break;
default: default:
ESP_LOGI(MESH_TAG, "unknown id:%d", event.id); ESP_LOGI(MESH_TAG, "unknown id:%d", event_id);
break; 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) void app_main(void)
{ {
ESP_ERROR_CHECK(mesh_light_init()); 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_dhcps_stop(TCPIP_ADAPTER_IF_AP));
ESP_ERROR_CHECK(tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA)); ESP_ERROR_CHECK(tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA));
#if 0 /* event initialization */
/* static ip settings */ ESP_ERROR_CHECK(esp_event_loop_create_default());
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
/* wifi initialization */ /* wifi initialization */
ESP_ERROR_CHECK(esp_event_loop_init(NULL, NULL));
wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT(); wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&config)); 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_set_storage(WIFI_STORAGE_FLASH));
ESP_ERROR_CHECK(esp_wifi_start()); ESP_ERROR_CHECK(esp_wifi_start());
/* mesh initialization */ /* mesh initialization */
ESP_ERROR_CHECK(esp_mesh_init()); 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_max_layer(CONFIG_MESH_MAX_LAYER));
ESP_ERROR_CHECK(esp_mesh_set_vote_percentage(1)); ESP_ERROR_CHECK(esp_mesh_set_vote_percentage(1));
ESP_ERROR_CHECK(esp_mesh_set_ap_assoc_expire(10)); 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_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT();
/* mesh ID */ /* mesh ID */
memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6); memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);
/* mesh event callback */
cfg.event_cb = &mesh_event_handler;
/* router */ /* router */
cfg.channel = CONFIG_MESH_CHANNEL; cfg.channel = CONFIG_MESH_CHANNEL;
cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID); cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID);

164
examples/mesh/manual_networking/main/mesh_main.c
View file

@ -9,7 +9,7 @@
#include <string.h> #include <string.h>
#include "esp_wifi.h" #include "esp_wifi.h"
#include "esp_system.h" #include "esp_system.h"
#include "esp_event_loop.h" #include "esp_event.h"
#include "esp_log.h" #include "esp_log.h"
#include "esp_mesh.h" #include "esp_mesh.h"
#include "esp_mesh_internal.h" #include "esp_mesh_internal.h"
@ -40,7 +40,6 @@ static int mesh_layer = -1;
/******************************************************* /*******************************************************
* Function Declarations * Function Declarations
*******************************************************/ *******************************************************/
void mesh_event_handler(mesh_event_t event);
void mesh_scan_done_handler(int num); 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,}; mesh_addr_t id = {0,};
static uint8_t last_layer = 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) { switch (event_id) {
case MESH_EVENT_STARTED: case MESH_EVENT_STARTED: {
esp_mesh_get_id(&id); esp_mesh_get_id(&id);
ESP_LOGI(MESH_TAG, "<MESH_EVENT_STARTED>ID:"MACSTR"", MAC2STR(id.addr)); ESP_LOGI(MESH_TAG, "<MESH_EVENT_STARTED>ID:"MACSTR"", MAC2STR(id.addr));
mesh_layer = esp_mesh_get_layer(); mesh_layer = esp_mesh_get_layer();
ESP_ERROR_CHECK(esp_mesh_set_self_organized(0, 0)); ESP_ERROR_CHECK(esp_mesh_set_self_organized(0, 0));
esp_wifi_scan_stop(); esp_wifi_scan_stop();
wifi_scan_config_t scan_config = { 0 };
/* mesh softAP is hidden */ /* mesh softAP is hidden */
scan_config.show_hidden = 1; scan_config.show_hidden = 1;
scan_config.scan_type = WIFI_SCAN_TYPE_PASSIVE; scan_config.scan_type = WIFI_SCAN_TYPE_PASSIVE;
ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_config, 0)); 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>"); ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOPPED>");
mesh_layer = esp_mesh_get_layer(); 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"", ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"",
event.info.child_connected.aid, child_connected->aid,
MAC2STR(event.info.child_connected.mac)); MAC2STR(child_connected->mac));
break; }
case MESH_EVENT_CHILD_DISCONNECTED: 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"", ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"",
event.info.child_disconnected.aid, child_disconnected->aid,
MAC2STR(event.info.child_disconnected.mac)); MAC2STR(child_disconnected->mac));
break; }
case MESH_EVENT_ROUTING_TABLE_ADD: 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", ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d",
event.info.routing_table.rt_size_change, routing_table->rt_size_change,
event.info.routing_table.rt_size_new); routing_table->rt_size_new);
break; }
case MESH_EVENT_ROUTING_TABLE_REMOVE: 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", ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d",
event.info.routing_table.rt_size_change, routing_table->rt_size_change,
event.info.routing_table.rt_size_new); routing_table->rt_size_new);
break; }
case MESH_EVENT_NO_PARENT_FOUND: 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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d",
event.info.no_parent.scan_times); no_parent->scan_times);
/* TODO handler for the failure */ }
break; /* TODO handler for the failure */
case MESH_EVENT_PARENT_CONNECTED: break;
case MESH_EVENT_PARENT_CONNECTED: {
mesh_event_connected_t *connected = (mesh_event_connected_t *)event_data;
esp_mesh_get_id(&id); esp_mesh_get_id(&id);
mesh_layer = event.info.connected.self_layer; mesh_layer = connected->self_layer;
memcpy(&mesh_parent_addr.addr, event.info.connected.connected.bssid, 6); memcpy(&mesh_parent_addr.addr, connected->connected.bssid, 6);
ESP_LOGI(MESH_TAG, ESP_LOGI(MESH_TAG,
"<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR"", "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR"",
last_layer, mesh_layer, MAC2STR(mesh_parent_addr.addr), 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()) { if (esp_mesh_is_root()) {
tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA); 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, ESP_LOGI(MESH_TAG,
"<MESH_EVENT_PARENT_DISCONNECTED>reason:%d", "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d",
event.info.disconnected.reason); disconnected->reason);
mesh_disconnected_indicator(); mesh_disconnected_indicator();
mesh_layer = esp_mesh_get_layer(); 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(); esp_wifi_scan_stop();
scan_config.show_hidden = 1; scan_config.show_hidden = 1;
scan_config.scan_type = WIFI_SCAN_TYPE_PASSIVE; scan_config.scan_type = WIFI_SCAN_TYPE_PASSIVE;
ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_config, 0)); ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_config, 0));
} }
break; }
case MESH_EVENT_LAYER_CHANGE: break;
mesh_layer = event.info.layer_change.new_layer; 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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s",
last_layer, mesh_layer, last_layer, mesh_layer,
esp_mesh_is_root() ? "<ROOT>" : esp_mesh_is_root() ? "<ROOT>" :
(mesh_layer == 2) ? "<layer2>" : ""); (mesh_layer == 2) ? "<layer2>" : "");
last_layer = mesh_layer; last_layer = mesh_layer;
mesh_connected_indicator(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"", ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"",
MAC2STR(event.info.root_addr.addr)); MAC2STR(root_addr->addr));
break; }
case MESH_EVENT_ROOT_GOT_IP: break;
/* root starts to connect to server */ case MESH_EVENT_TODS_STATE: {
ESP_LOGI(MESH_TAG, mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)event_data;
"<MESH_EVENT_ROOT_GOT_IP>sta ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR, ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", *toDs_state);
IP2STR(&event.info.got_ip.ip_info.ip), }
IP2STR(&event.info.got_ip.ip_info.netmask), break;
IP2STR(&event.info.got_ip.ip_info.gw)); case MESH_EVENT_ROOT_FIXED: {
break; mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)event_data;
case MESH_EVENT_ROOT_LOST_IP:
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_LOST_IP>");
break;
case MESH_EVENT_ROOT_FIXED:
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_FIXED>%s", ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_FIXED>%s",
event.info.root_fixed.is_fixed ? "fixed" : "not fixed"); root_fixed->is_fixed ? "fixed" : "not fixed");
break; }
case MESH_EVENT_SCAN_DONE: 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", ESP_LOGI(MESH_TAG, "<MESH_EVENT_SCAN_DONE>number:%d",
event.info.scan_done.number); scan_done->number);
mesh_scan_done_handler(event.info.scan_done.number); mesh_scan_done_handler(scan_done->number);
break; }
break;
default: default:
ESP_LOGI(MESH_TAG, "unknown id:%d", event.id); ESP_LOGI(MESH_TAG, "unknown id:%d", event_id);
break; 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) void app_main(void)
{ {
ESP_ERROR_CHECK(mesh_light_init()); 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_dhcps_stop(TCPIP_ADAPTER_IF_AP));
ESP_ERROR_CHECK(tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA)); ESP_ERROR_CHECK(tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA));
#if 0 /* event initialization */
/* static ip settings */ ESP_ERROR_CHECK(esp_event_loop_create_default());
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
/* wifi initialization */ /* wifi initialization */
ESP_ERROR_CHECK(esp_event_loop_init(NULL, NULL));
wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT(); wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&config)); 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_set_storage(WIFI_STORAGE_FLASH));
ESP_ERROR_CHECK(esp_wifi_start()); ESP_ERROR_CHECK(esp_wifi_start());
/* mesh initialization */ /* mesh initialization */
ESP_ERROR_CHECK(esp_mesh_init()); 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 enable IE crypto */
mesh_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT(); mesh_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT();
/* mesh ID */ /* mesh ID */
memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6); memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);
/* mesh event callback */
cfg.event_cb = &mesh_event_handler;
/* router */ /* router */
cfg.channel = CONFIG_MESH_CHANNEL; cfg.channel = CONFIG_MESH_CHANNEL;
cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID); cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID);