Browse Source

cleanup

feature/mesh_network
Hendrik Schutter 1 year ago
parent
commit
378f6e9ad0
  1. 2
      components/mesh_ota/CMakeLists.txt
  2. 9
      components/mesh_ota/include/mesh_network.h
  3. 261
      components/mesh_ota/mesh_network.c
  4. 236
      components/mesh_ota/mesh_network_handler.c

2
components/mesh_ota/CMakeLists.txt

@ -1,4 +1,4 @@
idf_component_register(SRCS "mesh_network.c" "mesh_ota.c"
idf_component_register(SRCS "mesh_network_handler.c" "mesh_network.c" "mesh_ota.c"
INCLUDE_DIRS "include"
REQUIRES nvs_flash
esp_http_client

9
components/mesh_ota/include/mesh_network.h

@ -13,16 +13,23 @@
#define RX_SIZE (1234)
#define TX_SIZE (1234)
static bool bIsMeshConnected;
static int32_t i32MeshLayer;
static mesh_addr_t mesh_parent_addr;
static esp_netif_t* netif_sta;
esp_err_t errMeshNetworkInitialize();
esp_err_t errMeshNetworkInitializeWiFi();
esp_err_t errMeshNetworkInitializeRouter(mesh_cfg_t* cfg);
bool bCheckMACEquality(uint8_t* pu8aMAC, uint8_t* pu8bMAC);
esp_err_t errGetChildren(mesh_addr_t children[], uint16_t* pu16ChildrenSize);
esp_err_t errGetChildren(mesh_addr_t* pChildren, uint16_t* pu16ChildrenSize);
esp_err_t errSendPacket(mesh_addr_t* dest, struct ota_mesh_packet* packet);
void vMeshEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void* vpEventData);
void vIPEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void *event_data);
esp_err_t errStartReceiveTask();
void vTaskReceiveMeshData(void *arg);
#endif /* H_MESH_NETWORK */

261
components/mesh_ota/mesh_network.c

@ -5,18 +5,15 @@ static const char *LOG_TAG = "mesh_network";
static const uint8_t MESH_ID[6] = { 0x77, 0x77, 0x77, 0x77, 0x77, 0x77};
static uint8_t tx_buf[TX_SIZE] = { 0, };
static uint8_t rx_buf[RX_SIZE] = { 0, };
static bool is_mesh_connected = false;
static mesh_addr_t mesh_parent_addr;
static int mesh_layer = -1;
static esp_netif_t *netif_sta = NULL;
uint8_t ownMAC[6];
static uint8_t u8NodeMAC[6];
esp_err_t errMeshNetworkInitialize()
{
//init module variables
esp_err_t err;
bIsMeshConnected = false;
i32MeshLayer = -1;
netif_sta = NULL;
err = nvs_flash_init(); //init non-volatile storage
@ -74,7 +71,7 @@ esp_err_t errMeshNetworkInitialize()
/* mesh start */
ERROR_CHECK(esp_mesh_start());
ERROR_CHECK(esp_base_mac_addr_get(ownMAC))
ERROR_CHECK(esp_base_mac_addr_get(u8NodeMAC))
//debug info
ESP_LOGD(LOG_TAG, "mesh starts successfully, heap:%d, %s<%d>%s, ps:%d\n", esp_get_minimum_free_heap_size(),
@ -82,7 +79,7 @@ esp_err_t errMeshNetworkInitialize()
esp_mesh_get_topology(), esp_mesh_get_topology() ? "(chain)":"(tree)", esp_mesh_is_ps_enabled());
ESP_LOGI(LOG_TAG, "Node MAC: \"%x:%x:%x:%x:%x:%x\" ", ownMAC[0], ownMAC[1], ownMAC[2], ownMAC[3], ownMAC[4], ownMAC[5]);
ESP_LOGI(LOG_TAG, "Node MAC: \"%x:%x:%x:%x:%x:%x\" ", u8NodeMAC[0], u8NodeMAC[1], u8NodeMAC[2], u8NodeMAC[3], u8NodeMAC[4], u8NodeMAC[5]);
return ESP_OK;
}
@ -129,7 +126,7 @@ bool bCheckMACEquality(uint8_t* pu8aMAC, uint8_t* pu8bMAC)
return bRet;
}
esp_err_t errGetChildren(mesh_addr_t children[], uint16_t* pu16ChildrenSize)
esp_err_t errGetChildren(mesh_addr_t* pChildren, uint16_t* pu16ChildrenSize)
{
esp_err_t err = ESP_OK;
int route_table_size = 0;
@ -141,11 +138,11 @@ esp_err_t errGetChildren(mesh_addr_t children[], uint16_t* pu16ChildrenSize)
{
for(uint16_t index = 0; index < esp_mesh_get_routing_table_size(); index++)
{
if(! (bCheckMACEquality(ownMAC, route_table[index].addr)) )
if(! (bCheckMACEquality(u8NodeMAC, route_table[index].addr)) )
{
//child node
//ESP_LOGI(MESH_TAG, "adding Node: \"0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\" ", route_table[index].addr[0], route_table[index].addr[1], route_table[index].addr[2], route_table[index].addr[3], route_table[index].addr[4], route_table[index].addr[5]);
children[*pu16ChildrenSize] = route_table[index];
pChildren[*pu16ChildrenSize] = route_table[index];
*pu16ChildrenSize = (*pu16ChildrenSize)+1;
}
}
@ -168,7 +165,26 @@ esp_err_t errSendPacket(mesh_addr_t* dest, struct ota_mesh_packet* packet)
}
*/
void esp_mesh_p2p_rx_main(void *arg)
esp_err_t errStartReceiveTask()
{
esp_err_t err = ESP_OK;
BaseType_t xReturned;
//static bool is_comm_p2p_started = false;
// if (!is_comm_p2p_started)
// {
//is_comm_p2p_started = true;
xReturned = xTaskCreate(vTaskReceiveMeshData, "ReceiveMeshData", 7000, NULL, 5, NULL);
if(xReturned != pdPASS)
{
err = ESP_FAIL;
}
//}
return err;
}
void vTaskReceiveMeshData(void *arg)
{
esp_err_t err;
mesh_addr_t from;
@ -187,6 +203,8 @@ void esp_mesh_p2p_rx_main(void *arg)
continue;
}
struct ota_mesh_packet packet;
memcpy(&packet, (uint8_t *)rx_buf, sizeof(struct ota_mesh_packet));
@ -219,226 +237,13 @@ void esp_mesh_p2p_rx_main(void *arg)
default:
ESP_LOGE(LOG_TAG, "recv: something");
break;
}
}//end switch
} //end while
vTaskDelete(NULL);
}
esp_err_t esp_mesh_comm_p2p_start(void)
{
static bool is_comm_p2p_started = false;
if (!is_comm_p2p_started)
{
is_comm_p2p_started = true;
xTaskCreate(esp_mesh_p2p_rx_main, "MPRX", 7000, NULL, 5, NULL);
}
return ESP_OK;
}
void vMeshEventHandler(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));
is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_STOPPED: {
ESP_LOGI(LOG_TAG, "<MESH_EVENT_STOPPED>");
is_mesh_connected = false;
mesh_layer = 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));
}
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, mesh_layer);
}
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, mesh_layer);
}
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 */
break;
case MESH_EVENT_PARENT_CONNECTED: {
mesh_event_connected_t *connected = (mesh_event_connected_t *)vpEventData;
esp_mesh_get_id(&id);
mesh_layer = connected->self_layer;
memcpy(&mesh_parent_addr.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, mesh_layer, MAC2STR(mesh_parent_addr.addr),
esp_mesh_is_root() ? "<ROOT>" :
(mesh_layer == 2) ? "<layer2>" : "", MAC2STR(id.addr), connected->duty);
last_layer = mesh_layer;
// mesh_connected_indicator(mesh_layer);
is_mesh_connected = true;
if (esp_mesh_is_root()) {
esp_netif_dhcpc_start(netif_sta);
}
esp_mesh_comm_p2p_start();//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);
is_mesh_connected = false;
// mesh_disconnected_indicator();
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_LAYER_CHANGE: {
mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)vpEventData;
mesh_layer = layer_change->new_layer;
ESP_LOGI(LOG_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: {
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 */
mesh_layer = esp_mesh_get_layer();
esp_mesh_get_parent_bssid(&mesh_parent_addr);
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", mesh_layer, MAC2STR(mesh_parent_addr.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;
}
}
void vIPEventHandler(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));
}

236
components/mesh_ota/mesh_network_handler.c

@ -0,0 +1,236 @@
#include "mesh_ota.h"
static const char *LOG_TAG = "mesh_network_handler";
void vIPEventHandler(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));
}
void vMeshEventHandler(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));
}
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(&mesh_parent_addr.addr, connected->connected.bssid, 6);
//WTF
ESP_LOGI(LOG_TAG, "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR", duty:%d",
last_layer, i32MeshLayer, MAC2STR(mesh_parent_addr.addr),
esp_mesh_is_root() ? "<ROOT>" :
(i32MeshLayer == 2) ? "<layer2>" : "", MAC2STR(id.addr), connected->duty);
last_layer = i32MeshLayer;
//mesh_connected_indicator(i32MeshLayer);
bIsMeshConnected = true;
if (esp_mesh_is_root())
{
esp_netif_dhcpc_start(netif_sta); //get a IP from router
}
errStartReceiveTask();//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;
// mesh_disconnected_indicator();
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;
//WTF
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;
//mesh_connected_indicator(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(&mesh_parent_addr);
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", i32MeshLayer, MAC2STR(mesh_parent_addr.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;
}
}
Loading…
Cancel
Save

Du besuchst diese Seite mit einem veralteten IPv4-Internetzugang. Möglicherweise treten in Zukunft Probleme mit der Erreichbarkeit und Performance auf. Bitte frage deinen Internetanbieter oder Netzwerkadministrator nach IPv6-Unterstützung.
You are visiting this site with an outdated IPv4 internet access. You may experience problems with accessibility and performance in the future. Please ask your ISP or network administrator for IPv6 support.
Weitere Infos | More Information
Klicke zum schließen | Click to close