ESP32 OTA firmware updates via WiFi mesh network.
https://hendrikschutter.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
261 lines
8.7 KiB
261 lines
8.7 KiB
|
|
/** |
|
* @file Mesh_Network_Handler.c |
|
* @brief Handler for events from mesh network (no messages) |
|
* @author Hendrik Schutter |
|
* @date 20.01.2021 |
|
* |
|
* Additional Infos: IP event received or parrent or child connected or disconnected |
|
*/ |
|
|
|
#include "Mesh_Network.h" |
|
|
|
static const char *LOG_TAG = "mesh_network_handler"; |
|
|
|
/** |
|
* @fn void vMeshNetworkIpEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void *vpEventData) |
|
* @brief received an IP event |
|
* @param arg |
|
* @param event_base |
|
* @param i32EventID |
|
* @param vpEventData |
|
* @return void |
|
* @author ESP-IDF |
|
* @date 20.01.2021 |
|
*/ |
|
void vMeshNetworkIpEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void *vpEventData) |
|
{ |
|
ip_event_got_ip_t *event = (ip_event_got_ip_t *) vpEventData; |
|
ESP_LOGI(LOG_TAG, "<IP_EVENT_STA_GOT_IP>IP:" IPSTR, IP2STR(&event->ip_info.ip)); |
|
if(pChangeStateOfServerWorkerHandle) |
|
{ |
|
pChangeStateOfServerWorkerHandle(true); //signal that this node (root node) has access to internet |
|
} |
|
} |
|
|
|
/** |
|
* @fn void vMeshNetworkMeshEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void* vpEventData) |
|
* @brief received an mesh event |
|
* @param arg |
|
* @param event_base |
|
* @param i32EventID |
|
* @param vpEventData |
|
* @return void |
|
* @author ESP-IDF |
|
* @date 20.01.2021 |
|
*/ |
|
void vMeshNetworkMeshEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void* vpEventData) |
|
{ |
|
mesh_addr_t id = {0,}; |
|
static uint16_t last_layer = 0; |
|
|
|
switch (i32EventID) |
|
{ |
|
case MESH_EVENT_STARTED: |
|
{ |
|
esp_mesh_get_id(&id); |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_MESH_STARTED>ID:"MACSTR"", MAC2STR(id.addr)); |
|
bIsMeshConnected = false; |
|
i32MeshLayer = esp_mesh_get_layer(); |
|
} |
|
break; |
|
case MESH_EVENT_STOPPED: |
|
{ |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_STOPPED>"); |
|
bIsMeshConnected = false; |
|
i32MeshLayer = esp_mesh_get_layer(); |
|
} |
|
break; |
|
case MESH_EVENT_CHILD_CONNECTED: |
|
{ |
|
mesh_event_child_connected_t *child_connected = (mesh_event_child_connected_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"", child_connected->aid, MAC2STR(child_connected->mac)); |
|
|
|
if(pOTAChildConnectHandle){pOTAChildConnectHandle(child_connected->mac);}//add this child to queue using handle |
|
|
|
} |
|
break; |
|
case MESH_EVENT_CHILD_DISCONNECTED: |
|
{ |
|
mesh_event_child_disconnected_t *child_disconnected = (mesh_event_child_disconnected_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"", |
|
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 *)vpEventData; |
|
ESP_LOGW(LOG_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d, layer:%d", |
|
routing_table->rt_size_change, |
|
routing_table->rt_size_new, i32MeshLayer); |
|
} |
|
break; |
|
case MESH_EVENT_ROUTING_TABLE_REMOVE: |
|
{ |
|
mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)vpEventData; |
|
ESP_LOGW(LOG_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d, layer:%d", |
|
routing_table->rt_size_change, |
|
routing_table->rt_size_new, i32MeshLayer); |
|
} |
|
break; |
|
case MESH_EVENT_NO_PARENT_FOUND: |
|
{ |
|
mesh_event_no_parent_found_t *no_parent = (mesh_event_no_parent_found_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d", |
|
no_parent->scan_times); |
|
/* TODO handler for the failure, maybe nominate themselves */ |
|
} |
|
break; |
|
case MESH_EVENT_PARENT_CONNECTED: |
|
{ |
|
mesh_event_connected_t *connected = (mesh_event_connected_t *)vpEventData; |
|
esp_mesh_get_id(&id); |
|
i32MeshLayer = connected->self_layer; |
|
memcpy(&meshParentAddr.addr, connected->connected.bssid, 6); |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR", duty:%d", |
|
last_layer, i32MeshLayer, MAC2STR(meshParentAddr.addr), |
|
esp_mesh_is_root() ? "<ROOT>" : (i32MeshLayer == 2) ? "<layer2>" : "", //print own node title |
|
MAC2STR(id.addr), connected->duty); |
|
last_layer = i32MeshLayer; |
|
bIsMeshConnected = true; |
|
if (esp_mesh_is_root()) |
|
{ |
|
if(esp_netif_dhcpc_start(pNetifSta) == ESP_ERR_ESP_NETIF_DHCP_ALREADY_STARTED) //get a IP from router |
|
{ |
|
if(pChangeStateOfServerWorkerHandle){pChangeStateOfServerWorkerHandle(true);}// signal reconnect |
|
} |
|
} |
|
errMeshNetworkStartReceiveTask();//start receiving |
|
} |
|
break; |
|
case MESH_EVENT_PARENT_DISCONNECTED: |
|
{ |
|
mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d", disconnected->reason); |
|
bIsMeshConnected = false; |
|
if(pChangeStateOfServerWorkerHandle){pChangeStateOfServerWorkerHandle(false);} |
|
i32MeshLayer = esp_mesh_get_layer(); |
|
} |
|
break; |
|
case MESH_EVENT_LAYER_CHANGE: |
|
{ |
|
mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)vpEventData; |
|
i32MeshLayer = layer_change->new_layer; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s", |
|
last_layer, i32MeshLayer, |
|
esp_mesh_is_root() ? "<ROOT>" : (i32MeshLayer == 2) ? "<layer2>" : ""); |
|
last_layer = i32MeshLayer; |
|
} |
|
break; |
|
case MESH_EVENT_ROOT_ADDRESS: |
|
{ |
|
mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"", |
|
MAC2STR(root_addr->addr)); |
|
} |
|
break; |
|
case MESH_EVENT_VOTE_STARTED: |
|
{ |
|
mesh_event_vote_started_t *vote_started = (mesh_event_vote_started_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:"MACSTR"", |
|
vote_started->attempts, |
|
vote_started->reason, |
|
MAC2STR(vote_started->rc_addr.addr)); |
|
} |
|
break; |
|
case MESH_EVENT_VOTE_STOPPED: |
|
{ |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_VOTE_STOPPED>"); |
|
} |
|
break; |
|
case MESH_EVENT_ROOT_SWITCH_REQ: |
|
{ |
|
mesh_event_root_switch_req_t *switch_req = (mesh_event_root_switch_req_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:"MACSTR"", switch_req->reason, |
|
MAC2STR( switch_req->rc_addr.addr)); |
|
} |
|
break; |
|
case MESH_EVENT_ROOT_SWITCH_ACK: |
|
{ |
|
//new root |
|
i32MeshLayer = esp_mesh_get_layer(); |
|
esp_mesh_get_parent_bssid(&meshParentAddr); |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", i32MeshLayer, MAC2STR(meshParentAddr.addr)); |
|
} |
|
break; |
|
case MESH_EVENT_TODS_STATE: |
|
{ |
|
mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)vpEventData; |
|
ESP_LOGI(LOG_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 *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_FIXED>%s", |
|
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 *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_ASKED_YIELD>"MACSTR", rssi:%d, capacity:%d", |
|
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 *)vpEventData; |
|
ESP_LOGI(LOG_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 *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_SCAN_DONE>number:%d", scan_done->number); |
|
} |
|
break; |
|
case MESH_EVENT_NETWORK_STATE: |
|
{ |
|
mesh_event_network_state_t *network_state = (mesh_event_network_state_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_NETWORK_STATE>is_rootless:%d", network_state->is_rootless); |
|
} |
|
break; |
|
case MESH_EVENT_STOP_RECONNECTION: |
|
{ |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_STOP_RECONNECTION>"); |
|
} |
|
break; |
|
case MESH_EVENT_FIND_NETWORK: |
|
{ |
|
mesh_event_find_network_t *find_network = (mesh_event_find_network_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_FIND_NETWORK>new channel:%d, router BSSID:"MACSTR"", |
|
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 *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROUTER_SWITCH>new router:%s, channel:%d, "MACSTR"", |
|
router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid)); |
|
} |
|
break; |
|
case MESH_EVENT_PS_PARENT_DUTY: |
|
{ |
|
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_PS_PARENT_DUTY>duty:%d", ps_duty->duty); |
|
} |
|
break; |
|
case MESH_EVENT_PS_CHILD_DUTY: |
|
{ |
|
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)vpEventData; |
|
ESP_LOGI(LOG_TAG, "<MESH_EVENT_PS_CHILD_DUTY>cidx:%d, "MACSTR", duty:%d", ps_duty->child_connected.aid-1, |
|
MAC2STR(ps_duty->child_connected.mac), ps_duty->duty); |
|
} |
|
break; |
|
default: |
|
ESP_LOGI(LOG_TAG, "unknown id:%d", i32EventID); |
|
break; |
|
} |
|
}
|
|
|