completed demo app blinky_led

This commit is contained in:
Hendrik Schutter 2021-01-16 18:23:10 +01:00
parent 62b9b1255f
commit 62d16a437a
10 changed files with 348 additions and 250 deletions

View File

@ -4,12 +4,12 @@
* 999.999.999 * 999.999.999
* Return true if remote version is newer (higher) than local version * Return true if remote version is newer (higher) than local version
*/ */
bool bNewerVersion(const char* pu8Local, const char* pu8Remote) bool bNewerVersion(const char* pu8Local, const char* pu8Remote)
{ {
char u8LocalTmp[12]; //local version char u8LocalTmp[12]; //local version
char u8RemoteTmp[12]; //remote version char u8RemoteTmp[12]; //remote version
char* pu8saveptrLocal; //context for strok_r char* pu8saveptrLocal; //context for strok_r
char* pu8saveptrRemote; //context for strok_r char* pu8saveptrRemote; //context for strok_r
bool bReturn = false; //flag to stop loop bool bReturn = false; //flag to stop loop
uint8_t u8Index = 0; //numbers counter in version string uint8_t u8Index = 0; //numbers counter in version string
@ -49,7 +49,7 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
uint8_t u8SecondDotIndex = 0; uint8_t u8SecondDotIndex = 0;
*pu32StartOffset = 0U; //reset offset to zero *pu32StartOffset = 0U; //reset offset to zero
while((u32DataIndex < *pu32DataLenght) && (bImageStartOffsetFound == false)) while((u32DataIndex < *pu32DataLenght) && (bImageStartOffsetFound == false))
{ {
//search for magic byte //search for magic byte
@ -67,7 +67,7 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
u32FirstDotOffset = (u32DataIndex+49+u8FirstDotIndex); u32FirstDotOffset = (u32DataIndex+49+u8FirstDotIndex);
} }
} }
u8FirstDotIndex++; u8FirstDotIndex++;
} }
while ((u8SecondDotIndex < 3) && (u32SecondDotOffset == 0) && (u32FirstDotOffset != 0)) while ((u8SecondDotIndex < 3) && (u32SecondDotOffset == 0) && (u32FirstDotOffset != 0))

View File

@ -4,11 +4,13 @@
static const char *LOG_TAG = "mesh_network"; static const char *LOG_TAG = "mesh_network";
static uint8_t tx_buf[CONFIG_MESH_MESSAGE_SIZE] = { 0, }; static uint8_t tx_buf[CONFIG_MESH_MESSAGE_SIZE] = { 0, };
static uint8_t rx_buf[CONFIG_MESH_MESSAGE_SIZE] = { 0, }; static uint8_t rx_buf[CONFIG_MESH_MESSAGE_SIZE] = { 0, };
static uint8_t u8NodeMAC[6]; uint8_t u8ownMAC[6];
esp_netif_t* netif_sta; esp_netif_t* netif_sta;
bool bIsMeshConnected; bool bIsMeshConnected;
int32_t i32MeshLayer; int32_t i32MeshLayer;
mesh_addr_t mesh_parent_addr; mesh_addr_t meshParentAddr;
void (*pAppRxHandle)(uint8_t*, uint8_t* );
esp_err_t errMeshNetworkInitialize() esp_err_t errMeshNetworkInitialize()
{ {
@ -74,7 +76,7 @@ esp_err_t errMeshNetworkInitialize()
/* mesh start */ /* mesh start */
ERROR_CHECK(esp_mesh_start()); ERROR_CHECK(esp_mesh_start());
ERROR_CHECK(esp_base_mac_addr_get(u8NodeMAC)) ERROR_CHECK(esp_base_mac_addr_get(u8ownMAC))
//debug info //debug info
ESP_LOGD(LOG_TAG, "mesh starts successfully, heap:%d, %s<%d>%s, ps:%d\n", esp_get_minimum_free_heap_size(), ESP_LOGD(LOG_TAG, "mesh starts successfully, heap:%d, %s<%d>%s, ps:%d\n", esp_get_minimum_free_heap_size(),
@ -82,7 +84,7 @@ esp_err_t errMeshNetworkInitialize()
esp_mesh_get_topology(), esp_mesh_get_topology() ? "(chain)":"(tree)", esp_mesh_is_ps_enabled()); 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\" ", u8NodeMAC[0], u8NodeMAC[1], u8NodeMAC[2], u8NodeMAC[3], u8NodeMAC[4], u8NodeMAC[5]); ESP_LOGI(LOG_TAG, "Node MAC: \"%x:%x:%x:%x:%x:%x\" ", u8ownMAC[0], u8ownMAC[1], u8ownMAC[2], u8ownMAC[3], u8ownMAC[4], u8ownMAC[5]);
return ESP_OK; return ESP_OK;
} }
@ -97,7 +99,6 @@ esp_err_t errMeshNetworkInitializeWiFi()
ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH)); ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH));
ERROR_CHECK(esp_wifi_start()); ERROR_CHECK(esp_wifi_start());
return err; return err;
} }
esp_err_t errMeshNetworkInitializeRouter(mesh_cfg_t* cfg) esp_err_t errMeshNetworkInitializeRouter(mesh_cfg_t* cfg)
@ -141,7 +142,7 @@ esp_err_t errGetChildren(mesh_addr_t* pChildren, uint16_t* pu16ChildrenSize)
{ {
for(uint16_t index = 0; index < esp_mesh_get_routing_table_size(); index++) for(uint16_t index = 0; index < esp_mesh_get_routing_table_size(); index++)
{ {
if(! (bCheckMACEquality(u8NodeMAC, route_table[index].addr)) ) if(! (bCheckMACEquality(u8ownMAC, route_table[index].addr)) )
{ {
//child node //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]); //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]);
@ -153,6 +154,37 @@ esp_err_t errGetChildren(mesh_addr_t* pChildren, uint16_t* pu16ChildrenSize)
return err; return err;
} }
esp_err_t errGetParentNode(mesh_addr_t* pMeshParentAddr)
{
esp_err_t err = ESP_OK;
if(bIsMeshConnected == false)
{
err = ESP_FAIL;
}
else
{
memcpy(pMeshParentAddr, &meshParentAddr, sizeof(mesh_addr_t));
}
return err;
}
void vGetOwnAddr(mesh_addr_t* pMeshOwnAddr)
{
memcpy(pMeshOwnAddr->addr, u8ownMAC, 6);
}
bool bIsRootNode()
{
return esp_mesh_is_root();
}
esp_err_t errMeshNetworkSetAppReceiveHandle(void (*pAppRxHandleTmp)(uint8_t * pu8Data, uint8_t* pu8Sender))
{
pAppRxHandle = pAppRxHandleTmp; //set handle from app as receive handle if an app packet is received
return ESP_OK;
}
esp_err_t errSendMeshPacket(mesh_addr_t* pAddrDest, MESH_PACKET_t* pPacket) esp_err_t errSendMeshPacket(mesh_addr_t* pAddrDest, MESH_PACKET_t* pPacket)
{ {
esp_err_t err; esp_err_t err;
@ -162,11 +194,12 @@ esp_err_t errSendMeshPacket(mesh_addr_t* pAddrDest, MESH_PACKET_t* pPacket)
data.proto = MESH_PROTO_BIN; data.proto = MESH_PROTO_BIN;
data.tos = MESH_TOS_P2P; data.tos = MESH_TOS_P2P;
memcpy(tx_buf, (uint8_t *)pPacket, sizeof(MESH_PACKET_t)); memcpy(tx_buf, (uint8_t *)pPacket, sizeof(MESH_PACKET_t));
err = esp_mesh_send(pAddrDest, &data, MESH_DATA_P2P, NULL, 0); err = esp_mesh_send(pAddrDest, &data, MESH_DATA_P2P, NULL, 0);
return err; return err;
} }
esp_err_t errStartReceiveTask() esp_err_t errStartReceiveTask()
{ {
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
@ -199,34 +232,27 @@ void vTaskReceiveMeshData(void *arg)
ESP_LOGE(LOG_TAG, "err:0x%x, size:%d", err, data.size); ESP_LOGE(LOG_TAG, "err:0x%x, size:%d", err, data.size);
continue; continue;
} }
MESH_PACKET_t packet;
memcpy(&packet, (uint8_t *)rx_buf, sizeof(MESH_PACKET_t));
/*
struct ota_mesh_packet packet;
memcpy(&packet, (uint8_t *)rx_buf, sizeof(struct ota_mesh_packet));
switch (packet.type) switch (packet.type)
{ {
case APP_Version_Request: case APP_Data:
ESP_LOGI(LOG_TAG, "recv: APP_Version_Request"); ESP_LOGD(LOG_TAG, "recv: APP_Data");
packet.type=APP_Version_Response; //call the rx handle from app
packet.au8Payload[0] = 42; //TODO get current running version pAppRxHandle(packet.au8Payload, from.addr); //hand over payload and sender of this mesh packet
// ESP_ERROR_CHECK (esp_mesh_send_packet(&from, &packet)); //send back to parent
break; break;
case APP_Version_Response: case OTA_Version_Request:
ESP_LOGI(LOG_TAG, "recv: APP_Version_Response - App Version %i: ", packet.au8Payload[0]); ESP_LOGI(LOG_TAG, "recv: OTA_Version_Request");
//check if node is out-dated break;
// esp_mesh_ota_send(&from); case OTA_Version_Respone:
ESP_LOGI(LOG_TAG, "recv: OTA_Version_Respone");
break; break;
case OTA_Data: case OTA_Data:
ESP_LOGI(LOG_TAG, "recv: OTA_Data"); ESP_LOGI(LOG_TAG, "recv: OTA_Data");
//esp_mesh_ota_receive(&from, &packet);
packet.type=OTA_ACK;
//ESP_ERROR_CHECK (esp_mesh_send_packet(&from, &packet)); //send back to parent
break; break;
case OTA_ACK: case OTA_ACK:
ESP_LOGI(LOG_TAG, "recv: OTA_ACK"); ESP_LOGI(LOG_TAG, "recv: OTA_ACK");
//esp_mesh_ota_send(&from);
break; break;
case OTA_Complete: case OTA_Complete:
ESP_LOGI(LOG_TAG, "recv: OTA_Complete"); ESP_LOGI(LOG_TAG, "recv: OTA_Complete");
@ -235,9 +261,6 @@ void vTaskReceiveMeshData(void *arg)
ESP_LOGE(LOG_TAG, "recv: something"); ESP_LOGE(LOG_TAG, "recv: something");
break; break;
}//end switch }//end switch
*/
} //end while } //end while
} }

View File

@ -15,205 +15,205 @@ void vMeshEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventI
static uint16_t last_layer = 0; static uint16_t last_layer = 0;
switch (i32EventID) switch (i32EventID)
{ {
case MESH_EVENT_STARTED: case MESH_EVENT_STARTED:
{ {
esp_mesh_get_id(&id); esp_mesh_get_id(&id);
ESP_LOGI(LOG_TAG, "<MESH_EVENT_MESH_STARTED>ID:"MACSTR"", MAC2STR(id.addr)); ESP_LOGI(LOG_TAG, "<MESH_EVENT_MESH_STARTED>ID:"MACSTR"", MAC2STR(id.addr));
bIsMeshConnected = false; bIsMeshConnected = false;
i32MeshLayer = esp_mesh_get_layer(); i32MeshLayer = esp_mesh_get_layer();
} }
break; break;
case MESH_EVENT_STOPPED: case MESH_EVENT_STOPPED:
{ {
ESP_LOGI(LOG_TAG, "<MESH_EVENT_STOPPED>"); ESP_LOGI(LOG_TAG, "<MESH_EVENT_STOPPED>");
bIsMeshConnected = false; bIsMeshConnected = false;
i32MeshLayer = esp_mesh_get_layer(); i32MeshLayer = esp_mesh_get_layer();
} }
break; break;
case MESH_EVENT_CHILD_CONNECTED: case MESH_EVENT_CHILD_CONNECTED:
{ {
mesh_event_child_connected_t *child_connected = (mesh_event_child_connected_t *)vpEventData; mesh_event_child_connected_t *child_connected = (mesh_event_child_connected_t *)vpEventData;
ESP_LOGI(LOG_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"", ESP_LOGI(LOG_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"",
child_connected->aid, child_connected->aid,
MAC2STR(child_connected->mac)); MAC2STR(child_connected->mac));
} }
break; break;
case MESH_EVENT_CHILD_DISCONNECTED: case MESH_EVENT_CHILD_DISCONNECTED:
{ {
mesh_event_child_disconnected_t *child_disconnected = (mesh_event_child_disconnected_t *)vpEventData; mesh_event_child_disconnected_t *child_disconnected = (mesh_event_child_disconnected_t *)vpEventData;
ESP_LOGI(LOG_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"", ESP_LOGI(LOG_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"",
child_disconnected->aid, child_disconnected->aid,
MAC2STR(child_disconnected->mac)); MAC2STR(child_disconnected->mac));
} }
break; 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 *)vpEventData; 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", ESP_LOGW(LOG_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d, layer:%d",
routing_table->rt_size_change, routing_table->rt_size_change,
routing_table->rt_size_new, i32MeshLayer); routing_table->rt_size_new, i32MeshLayer);
} }
break; break;
case MESH_EVENT_ROUTING_TABLE_REMOVE: case MESH_EVENT_ROUTING_TABLE_REMOVE:
{ {
mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)vpEventData; 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", ESP_LOGW(LOG_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d, layer:%d",
routing_table->rt_size_change, routing_table->rt_size_change,
routing_table->rt_size_new, i32MeshLayer); routing_table->rt_size_new, i32MeshLayer);
} }
break; break;
case MESH_EVENT_NO_PARENT_FOUND: case MESH_EVENT_NO_PARENT_FOUND:
{ {
mesh_event_no_parent_found_t *no_parent = (mesh_event_no_parent_found_t *)vpEventData; 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", ESP_LOGI(LOG_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d",
no_parent->scan_times); no_parent->scan_times);
/* TODO handler for the failure, maybe nominate themselves */ /* TODO handler for the failure, maybe nominate themselves */
} }
break; break;
case MESH_EVENT_PARENT_CONNECTED: 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())
{ {
mesh_event_connected_t *connected = (mesh_event_connected_t *)vpEventData; ESP_ERROR_CHECK(esp_netif_dhcpc_start(netif_sta)); //get a IP from router
esp_mesh_get_id(&id);
i32MeshLayer = 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, i32MeshLayer, MAC2STR(mesh_parent_addr.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())
{
ESP_ERROR_CHECK(esp_netif_dhcpc_start(netif_sta)); //get a IP from router
}
errStartReceiveTask();//start receiving
} }
break; errStartReceiveTask();//start receiving
}
break;
case MESH_EVENT_PARENT_DISCONNECTED: case MESH_EVENT_PARENT_DISCONNECTED:
{ {
mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)vpEventData; mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)vpEventData;
ESP_LOGI(LOG_TAG, "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d", disconnected->reason); ESP_LOGI(LOG_TAG, "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d", disconnected->reason);
bIsMeshConnected = false; bIsMeshConnected = false;
i32MeshLayer = esp_mesh_get_layer(); i32MeshLayer = esp_mesh_get_layer();
} }
break; break;
case MESH_EVENT_LAYER_CHANGE: case MESH_EVENT_LAYER_CHANGE:
{ {
mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)vpEventData; mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)vpEventData;
i32MeshLayer = layer_change->new_layer; i32MeshLayer = layer_change->new_layer;
ESP_LOGI(LOG_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s", ESP_LOGI(LOG_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s",
last_layer, i32MeshLayer, last_layer, i32MeshLayer,
esp_mesh_is_root() ? "<ROOT>" : (i32MeshLayer == 2) ? "<layer2>" : ""); esp_mesh_is_root() ? "<ROOT>" : (i32MeshLayer == 2) ? "<layer2>" : "");
last_layer = i32MeshLayer; last_layer = i32MeshLayer;
} }
break; break;
case MESH_EVENT_ROOT_ADDRESS: case MESH_EVENT_ROOT_ADDRESS:
{ {
mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)vpEventData; mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)vpEventData;
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"", ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"",
MAC2STR(root_addr->addr)); MAC2STR(root_addr->addr));
} }
break; break;
case MESH_EVENT_VOTE_STARTED: case MESH_EVENT_VOTE_STARTED:
{ {
mesh_event_vote_started_t *vote_started = (mesh_event_vote_started_t *)vpEventData; 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"", ESP_LOGI(LOG_TAG, "<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:"MACSTR"",
vote_started->attempts, vote_started->attempts,
vote_started->reason, vote_started->reason,
MAC2STR(vote_started->rc_addr.addr)); MAC2STR(vote_started->rc_addr.addr));
} }
break; break;
case MESH_EVENT_VOTE_STOPPED: case MESH_EVENT_VOTE_STOPPED:
{ {
ESP_LOGI(LOG_TAG, "<MESH_EVENT_VOTE_STOPPED>"); ESP_LOGI(LOG_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 *)vpEventData; 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, ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:"MACSTR"", switch_req->reason,
MAC2STR( switch_req->rc_addr.addr)); MAC2STR( switch_req->rc_addr.addr));
} }
break; break;
case MESH_EVENT_ROOT_SWITCH_ACK: case MESH_EVENT_ROOT_SWITCH_ACK:
{ {
//new root //new root
i32MeshLayer = esp_mesh_get_layer(); i32MeshLayer = esp_mesh_get_layer();
esp_mesh_get_parent_bssid(&mesh_parent_addr); esp_mesh_get_parent_bssid(&meshParentAddr);
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", i32MeshLayer, MAC2STR(mesh_parent_addr.addr)); ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", i32MeshLayer, MAC2STR(meshParentAddr.addr));
} }
break; break;
case MESH_EVENT_TODS_STATE: case MESH_EVENT_TODS_STATE:
{ {
mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)vpEventData; 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); ESP_LOGI(LOG_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", *toDs_state);
} }
break; break;
case MESH_EVENT_ROOT_FIXED: case MESH_EVENT_ROOT_FIXED:
{ {
mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)vpEventData; mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)vpEventData;
ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_FIXED>%s", ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_FIXED>%s",
root_fixed->is_fixed ? "fixed" : "not fixed"); root_fixed->is_fixed ? "fixed" : "not fixed");
} }
break; break;
case MESH_EVENT_ROOT_ASKED_YIELD: case MESH_EVENT_ROOT_ASKED_YIELD:
{ {
mesh_event_root_conflict_t *root_conflict = (mesh_event_root_conflict_t *)vpEventData; 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", ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROOT_ASKED_YIELD>"MACSTR", rssi:%d, capacity:%d",
MAC2STR(root_conflict->addr), root_conflict->rssi, root_conflict->capacity); MAC2STR(root_conflict->addr), root_conflict->rssi, root_conflict->capacity);
} }
break; break;
case MESH_EVENT_CHANNEL_SWITCH: case MESH_EVENT_CHANNEL_SWITCH:
{ {
mesh_event_channel_switch_t *channel_switch = (mesh_event_channel_switch_t *)vpEventData; 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); ESP_LOGI(LOG_TAG, "<MESH_EVENT_CHANNEL_SWITCH>new channel:%d", channel_switch->channel);
} }
break; break;
case MESH_EVENT_SCAN_DONE: case MESH_EVENT_SCAN_DONE:
{ {
mesh_event_scan_done_t *scan_done = (mesh_event_scan_done_t *)vpEventData; 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); ESP_LOGI(LOG_TAG, "<MESH_EVENT_SCAN_DONE>number:%d", scan_done->number);
} }
break; break;
case MESH_EVENT_NETWORK_STATE: case MESH_EVENT_NETWORK_STATE:
{ {
mesh_event_network_state_t *network_state = (mesh_event_network_state_t *)vpEventData; 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); ESP_LOGI(LOG_TAG, "<MESH_EVENT_NETWORK_STATE>is_rootless:%d", network_state->is_rootless);
} }
break; break;
case MESH_EVENT_STOP_RECONNECTION: case MESH_EVENT_STOP_RECONNECTION:
{ {
ESP_LOGI(LOG_TAG, "<MESH_EVENT_STOP_RECONNECTION>"); ESP_LOGI(LOG_TAG, "<MESH_EVENT_STOP_RECONNECTION>");
} }
break; break;
case MESH_EVENT_FIND_NETWORK: case MESH_EVENT_FIND_NETWORK:
{ {
mesh_event_find_network_t *find_network = (mesh_event_find_network_t *)vpEventData; 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"", ESP_LOGI(LOG_TAG, "<MESH_EVENT_FIND_NETWORK>new channel:%d, router BSSID:"MACSTR"",
find_network->channel, MAC2STR(find_network->router_bssid)); find_network->channel, MAC2STR(find_network->router_bssid));
} }
break; break;
case MESH_EVENT_ROUTER_SWITCH: case MESH_EVENT_ROUTER_SWITCH:
{ {
mesh_event_router_switch_t *router_switch = (mesh_event_router_switch_t *)vpEventData; 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"", ESP_LOGI(LOG_TAG, "<MESH_EVENT_ROUTER_SWITCH>new router:%s, channel:%d, "MACSTR"",
router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid)); router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid));
} }
break; break;
case MESH_EVENT_PS_PARENT_DUTY: case MESH_EVENT_PS_PARENT_DUTY:
{ {
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)vpEventData; 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); ESP_LOGI(LOG_TAG, "<MESH_EVENT_PS_PARENT_DUTY>duty:%d", ps_duty->duty);
} }
break; break;
case MESH_EVENT_PS_CHILD_DUTY: case MESH_EVENT_PS_CHILD_DUTY:
{ {
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)vpEventData; 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, 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); MAC2STR(ps_duty->child_connected.mac), ps_duty->duty);
} }
break; break;
default: default:
ESP_LOGI(LOG_TAG, "unknown id:%d", i32EventID); ESP_LOGI(LOG_TAG, "unknown id:%d", i32EventID);
break; break;

View File

@ -33,10 +33,10 @@ enum ota_packet_type
err = (x); \ err = (x); \
if (err != ESP_OK) \ if (err != ESP_OK) \
{ \ { \
ESP_LOGE(LOG_TAG, "%s failed with error: %d -> %s", #x, err, esp_err_to_name(err)); \ ESP_LOGE(LOG_TAG, "%s failed with error: 0x%x -> %s", #x, err, esp_err_to_name(err)); \
} \ } \
} \ } \
bool bNewerVersion(const char* pu8Local, const char* pu8Remote); bool bNewerVersion(const char* pu8Local, const char* pu8Remote);
esp_err_t errExtractVersionNumber(const char* pu8Data, uint32_t* pu32DataLenght, char* pc8RemoteVersionNumber); esp_err_t errExtractVersionNumber(const char* pu8Data, uint32_t* pu32DataLenght, char* pc8RemoteVersionNumber);

View File

@ -49,9 +49,9 @@
struct meshPacket struct meshPacket
{ {
enum otaMeshPacketType enum otaMeshPacketType
{ {
APP_Data, //data for application APP_Data, //data for application
OTA_Version_Request, //send own version in payload OTA_Version_Request, //send own version in payload
OTA_Version_Respone, //send own version in payload OTA_Version_Respone, //send own version in payload
OTA_Data, //send image segment OTA_Data, //send image segment
@ -65,20 +65,31 @@ typedef struct meshPacket MESH_PACKET_t;
extern bool bIsMeshConnected; extern bool bIsMeshConnected;
extern int32_t i32MeshLayer; extern int32_t i32MeshLayer;
extern mesh_addr_t mesh_parent_addr; extern mesh_addr_t meshParentAddr;
extern esp_netif_t* netif_sta; extern esp_netif_t* netif_sta;
extern uint8_t u8ownMAC[6];
esp_err_t errMeshNetworkInitialize(); esp_err_t errMeshNetworkInitialize();
esp_err_t errMeshNetworkInitializeWiFi(); esp_err_t errMeshNetworkInitializeWiFi();
esp_err_t errMeshNetworkInitializeRouter(mesh_cfg_t* cfg); esp_err_t errMeshNetworkInitializeRouter(mesh_cfg_t* cfg);
esp_err_t errMeshNetworkSetAppReceiveHandle(void (*pFuncParam)(uint8_t * pu8Data, uint8_t* pu8Sender));
bool bCheckMACEquality(uint8_t* pu8aMAC, uint8_t* pu8bMAC); bool bCheckMACEquality(uint8_t* pu8aMAC, uint8_t* pu8bMAC);
void vGetOwnAddr(mesh_addr_t* pMeshOwnAddr);
esp_err_t errGetParentNode(mesh_addr_t* pMeshParentAddr);
esp_err_t errGetChildren(mesh_addr_t* pChildren, uint16_t* pu16ChildrenSize); esp_err_t errGetChildren(mesh_addr_t* pChildren, uint16_t* pu16ChildrenSize);
void vMeshEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void* vpEventData); bool bIsRootNode();
void vIPEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void *event_data);
esp_err_t errStartReceiveTask(); esp_err_t errStartReceiveTask();
void vTaskReceiveMeshData(void *arg); void vTaskReceiveMeshData(void *arg);
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 errSendMeshPacket(mesh_addr_t* pAddrDest, MESH_PACKET_t* pPacket); esp_err_t errSendMeshPacket(mesh_addr_t* pAddrDest, MESH_PACKET_t* pPacket);
#endif /* H_MESH_NETWORK */ #endif /* H_MESH_NETWORK */

View File

@ -26,7 +26,7 @@
#include "mbedtls/ctr_drbg.h" #include "mbedtls/ctr_drbg.h"
#include "mbedtls/error.h" #include "mbedtls/error.h"
#include "mbedtls/certs.h" #include "mbedtls/certs.h"
#include "esp_crt_bundle.h" #include "esp_crt_bundle.h"
#ifndef CONFIG_OTA_HTTPS_URL #ifndef CONFIG_OTA_HTTPS_URL
#define CONFIG_OTA_HTTPS_URL "https://exmaple.com/theImage.bin" #define CONFIG_OTA_HTTPS_URL "https://exmaple.com/theImage.bin"
@ -63,7 +63,7 @@ struct HTTPS_Client
typedef int32_t https_client_ret_t; typedef int32_t https_client_ret_t;
typedef struct HTTPS_Client HTTPS_Client_t; typedef struct HTTPS_Client HTTPS_Client_t;
https_client_ret_t https_clientInitialize(); https_client_ret_t https_clientInitialize();
https_client_ret_t https_clientRetrieveData(char* pu8Data, uint32_t* pu32DataLenght, uint32_t* pu32BytesRead); https_client_ret_t https_clientRetrieveData(char* pu8Data, uint32_t* pu32DataLenght, uint32_t* pu32BytesRead);
https_client_ret_t https_clientDeinitialize(); https_client_ret_t https_clientDeinitialize();

View File

@ -1,11 +1,11 @@
#include "Blinky_LED.h" #include "Blinky_LED.h"
static const char *LOG_TAG = "blinky_led"; static const char *LOG_TAG = "blinky_led";
static bool bLEDisOn = true; static bool bLEDisOn = false; //set led default off
static mesh_addr_t addrParent; //addr of parent node
xQueueHandle queueBlinkyLEDPackets; static mesh_addr_t childrenAddr[CONFIG_MESH_ROUTE_TABLE_SIZE]; //array of children attached to this node
static uint16_t u16ChildrenSize; //number of children attached to this node
xQueueHandle queueBlinkyLEDPackets; //handle for led action queue
esp_err_t errBlinkyLEDInitialize() esp_err_t errBlinkyLEDInitialize()
{ {
@ -14,16 +14,20 @@ esp_err_t errBlinkyLEDInitialize()
vGPIOInitialize(); vGPIOInitialize();
queueBlinkyLEDPackets = xQueueCreate(5, sizeof (BLINKY_PACKET_t)); //create queue to store led action created from BTN and mesh network events
queueBlinkyLEDPackets = xQueueCreate(5, sizeof(BLINKY_PACKET_t));
if (queueBlinkyLEDPackets == 0) // Queue not created if (queueBlinkyLEDPackets == 0) // Queue not created
{ {
ESP_LOGE(LOG_TAG, "Unable to create Queue for Application Packets"); ESP_LOGE(LOG_TAG, "Unable to create Queue for Application Packets");
err = ESP_FAIL; err = ESP_FAIL;
} }
//register the receiver handle in mesh network
ERROR_CHECK(errMeshNetworkSetAppReceiveHandle(rxHandle));
if(err == ESP_OK) if(err == ESP_OK)
{ {
xReturned = xTaskCreate(vTaskReadUserInput, "vTaskReadUserInput", 2048, NULL, 5, NULL); xReturned = xTaskCreate(vTaskReadUserInput, "vTaskReadUserInput", 4096, NULL, 5, NULL);
if(xReturned != pdPASS) if(xReturned != pdPASS)
{ {
err = ESP_FAIL; err = ESP_FAIL;
@ -32,7 +36,7 @@ esp_err_t errBlinkyLEDInitialize()
if(err == ESP_OK) if(err == ESP_OK)
{ {
xReturned = xTaskCreate(vTaskReceiveData, "vTaskReceiveData", 2048, NULL, 5, NULL); xReturned = xTaskCreate(vTaskReceiveData, "vTaskReceiveData", 4096, NULL, 5, NULL);
if(xReturned != pdPASS) if(xReturned != pdPASS)
{ {
err = ESP_FAIL; err = ESP_FAIL;
@ -58,27 +62,65 @@ void vGPIOInitialize()
gpio_config(&gpioConf); gpio_config(&gpioConf);
} }
void rxHandle(uint8_t* pu8Data, uint8_t* pu8Sender)
{
//send payload to app queue
BLINKY_PACKET_t bTmpPacket;
memcpy(&bTmpPacket, (uint8_t *)pu8Data, sizeof(BLINKY_PACKET_t));
memcpy(&bTmpPacket.meshSenderAddr, (uint8_t *)pu8Sender, 6); //copy MAC from sender into app packet
if (xQueueSend(queueBlinkyLEDPackets, &bTmpPacket, portMAX_DELAY) != pdPASS)
{
ESP_LOGE(LOG_TAG, "Unable to push packet from mesh into Queue");
}
}
void vTaskReadUserInput(void *arg) void vTaskReadUserInput(void *arg)
{ {
BLINKY_PACKET_t bTmpStateLED = LED_OFF; esp_err_t err = ESP_OK;
BLINKY_PACKET_t bTmpPacket;
MESH_PACKET_t meshPacket;
bTmpPacket.type = LED_OFF; //default off
meshPacket.type = APP_Data; //this is a app packet
while(true) while(true)
{ { //check for BTN press
if(gpio_get_level(GPIO_BOOT_BTN) == 0) if(gpio_get_level(GPIO_BOOT_BTN) == 0)
{ {
err = ESP_OK;
if(bLEDisOn == false) if(bLEDisOn == false)
{ {
ESP_LOGI(LOG_TAG,"switch ON"); bTmpPacket.type = LED_ON;
bTmpStateLED = LED_ON;
} }
else else
{ {
ESP_LOGI(LOG_TAG,"switch OFF"); bTmpPacket.type = LED_OFF;
bTmpStateLED = LED_OFF;
} }
if (xQueueSend(queueBlinkyLEDPackets, &bTmpStateLED, portMAX_DELAY) != pdPASS) //push led action into queue
if (xQueueSend(queueBlinkyLEDPackets, &bTmpPacket, portMAX_DELAY) != pdPASS)
{ {
ESP_LOGE(LOG_TAG, "Unable to push packet into Queue"); ESP_LOGE(LOG_TAG, "Unable to push packet into queue");
}
memcpy(meshPacket.au8Payload, &bTmpPacket, sizeof(BLINKY_PACKET_t));
if(bIsRootNode() == false)
{
//this node is not root --> send led action to parent
ERROR_CHECK(errGetParentNode(&addrParent));
ERROR_CHECK(errSendMeshPacket(&addrParent, &meshPacket));
}
else
{
//this node is root --> send led action to children
ERROR_CHECK(errGetChildren(childrenAddr, &u16ChildrenSize));
for (uint16_t u16Index = 0; u16Index < u16ChildrenSize; u16Index++)
{
ERROR_CHECK (errSendMeshPacket(&childrenAddr[u16Index], &meshPacket));
}
} }
vTaskDelay(200 / portTICK_PERIOD_MS); vTaskDelay(200 / portTICK_PERIOD_MS);
} }
@ -88,37 +130,55 @@ void vTaskReadUserInput(void *arg)
void vTaskReceiveData(void *arg) void vTaskReceiveData(void *arg)
{ {
BLINKY_PACKET_t bTmpStateLED = LED_OFF; esp_err_t err = ESP_OK;
MESH_PACKET_t meshPacket;
BLINKY_PACKET_t bTmpPacket;
bTmpPacket.type = LED_OFF; //default off
meshPacket.type = APP_Data; //this is a app packet
while (1) while (1)
{ {
if (xQueueReceive(queueBlinkyLEDPackets, &bTmpStateLED, portMAX_DELAY) != pdTRUE) if (xQueueReceive(queueBlinkyLEDPackets, &bTmpPacket, portMAX_DELAY) != pdTRUE)
{ {
ESP_LOGE(LOG_TAG, "Unable to receive packet from Queue"); ESP_LOGE(LOG_TAG, "Unable to receive packet from Queue");
} }
else else
{ {
err = ESP_OK;
//Successfully RECEIVED the packet //Successfully RECEIVED the packet
switch (bTmpStateLED) switch (bTmpPacket.type)
{ {
case LED_ON: case LED_ON:
bLEDisOn = true; bLEDisOn = true;
gpio_set_level(GPIO_LED, 1); //switch on gpio_set_level(GPIO_LED, 1); //switch on
ESP_LOGI(LOG_TAG,"rec ON"); ESP_LOGI(LOG_TAG,"switch LED ON");
break; break;
case LED_OFF: case LED_OFF:
bLEDisOn = false; bLEDisOn = false;
gpio_set_level(GPIO_LED, 0); //switch off gpio_set_level(GPIO_LED, 0); //switch off
ESP_LOGI(LOG_TAG,"rec OFF"); ESP_LOGI(LOG_TAG,"switch LED OFF");
break; break;
default: default:
bLEDisOn = false; bLEDisOn = false;
gpio_set_level(GPIO_LED, 0); //switch off gpio_set_level(GPIO_LED, 0); //switch off
ESP_LOGI(LOG_TAG,"switch LED OFF");
break; break;
} }
} }
ERROR_CHECK(errGetChildren(childrenAddr, &u16ChildrenSize)); //get all children attached to this node
memcpy(meshPacket.au8Payload, &bTmpPacket, sizeof(BLINKY_PACKET_t)); //copy led action in mesh packet payload
for (uint16_t u16Index = 0; u16Index < u16ChildrenSize; u16Index++)
{ //loop through children
if(bCheckMACEquality(bTmpPacket.meshSenderAddr.addr, childrenAddr[u16Index].addr) == false) //exclude the sender node
{
ERROR_CHECK (errSendMeshPacket(&childrenAddr[u16Index], &meshPacket)); //send to child
}
}
vTaskDelay(200 / portTICK_PERIOD_MS); vTaskDelay(200 / portTICK_PERIOD_MS);
} }
} }

View File

@ -11,25 +11,29 @@
#include "Mesh_OTA.h" #include "Mesh_OTA.h"
#define GPIO_BOOT_BTN 0 #define GPIO_BOOT_BTN 0 //GPIO0 (Boot BTN)
#define GPIO_LED 2 #define GPIO_LED 2 //GPIO2 (internal blue LED in DevKit V1.0)
#define GPIO_INPUT_PIN_SEL (1ULL<<GPIO_BOOT_BTN) #define GPIO_INPUT_PIN_SEL (1ULL<<GPIO_BOOT_BTN)
enum blinky_packet_type struct blinky_packet
{ {
LED_OFF, enum blinky_packet_type
LED_ON, {
LED_OFF,
LED_ON,
} type;
mesh_addr_t meshSenderAddr; //stores addr of sender of this packet
}; };
typedef enum blinky_packet_type BLINKY_PACKET_t; typedef struct blinky_packet BLINKY_PACKET_t;
esp_err_t errBlinkyLEDInitialize(); esp_err_t errBlinkyLEDInitialize();
void vGPIOInitialize(); void vGPIOInitialize();
void rxHandle(uint8_t* pu8Data, uint8_t* pu8Sender);
void vTaskReadUserInput(void *arg); void vTaskReadUserInput(void *arg);
void vTaskReceiveData(void *arg); void vTaskReceiveData(void *arg);
#endif /* H_BLINKY_LED */ #endif /* H_BLINKY_LED */

View File

@ -19,13 +19,13 @@ static const char *LOG_TAG = "esp_main";
void app_main(void) void app_main(void)
{ {
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
ESP_LOGI(LOG_TAG, "hardcoded: 0.0.1"); ESP_LOGI(LOG_TAG, "hardcoded: 0.0.1");
err = errMeshNetworkInitialize(); err = errMeshNetworkInitialize();
ESP_ERROR_CHECK(err); ESP_ERROR_CHECK(err);
//start ota //start ota
//start app //start app
errBlinkyLEDInitialize(); errBlinkyLEDInitialize();
} }

View File

@ -159,7 +159,7 @@ CONFIG_MESH_AP_AUTHMODE=3
CONFIG_MESH_AP_PASSWD="qaws1234" CONFIG_MESH_AP_PASSWD="qaws1234"
CONFIG_MESH_AP_CONNECTIONS=6 CONFIG_MESH_AP_CONNECTIONS=6
CONFIG_MESH_ROUTE_TABLE_SIZE=50 CONFIG_MESH_ROUTE_TABLE_SIZE=50
CONFIG_MESH_MESSAGE_SIZE=1500 CONFIG_MESH_MESSAGE_SIZE=1234
CONFIG_OTA_HTTPS_SERVER_COMMON_NAME="ota.hendrikschutter.com" CONFIG_OTA_HTTPS_SERVER_COMMON_NAME="ota.hendrikschutter.com"
CONFIG_OTA_HTTPS_SERVER_PORT="443" CONFIG_OTA_HTTPS_SERVER_PORT="443"
CONFIG_OTA_HTTPS_URL="https://ota.hendrikschutter.com/mesh_ota.bin" CONFIG_OTA_HTTPS_URL="https://ota.hendrikschutter.com/mesh_ota.bin"