262 lines
8.7 KiB
C
262 lines
8.7 KiB
C
|
|
/**
|
|
* @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;
|
|
}
|
|
}
|