localhorst/ESP32-Mesh-OTA
1
0
Fork 0
Code Issues Pull Requests Releases Activity

completed demo app blinky_led

Browse Source
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
components/mesh_ota/Mesh_OTA.c
View File

@ -4,12 +4,12 @@
* 999.999.999
* 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 u8RemoteTmp[12]; //remote version
char* pu8saveptrLocal; //context for strok_r
char* pu8saveptrRemote; //context for strok_r
char* pu8saveptrLocal; //context for strok_r
char* pu8saveptrRemote; //context for strok_r
bool bReturn = false; //flag to stop loop
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;
*pu32StartOffset = 0U; //reset offset to zero
while((u32DataIndex < *pu32DataLenght) && (bImageStartOffsetFound == false))
{
//search for magic byte
@ -67,7 +67,7 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
u32FirstDotOffset = (u32DataIndex+49+u8FirstDotIndex);
}
}
u8FirstDotIndex++;
u8FirstDotIndex++;
}
while ((u8SecondDotIndex < 3) && (u32SecondDotOffset == 0) && (u32FirstDotOffset != 0))

79
components/mesh_ota/Mesh_network.c
View File

@ -4,11 +4,13 @@
static const char *LOG_TAG = "mesh_network";
static uint8_t tx_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;
bool bIsMeshConnected;
int32_t i32MeshLayer;
mesh_addr_t mesh_parent_addr;
mesh_addr_t meshParentAddr;
void (*pAppRxHandle)(uint8_t*, uint8_t* );
esp_err_t errMeshNetworkInitialize()
{
@ -74,7 +76,7 @@ esp_err_t errMeshNetworkInitialize()
/* 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
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_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;
}
@ -97,7 +99,6 @@ esp_err_t errMeshNetworkInitializeWiFi()
ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH));
ERROR_CHECK(esp_wifi_start());
return err;
}
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++)
{
if(! (bCheckMACEquality(u8NodeMAC, route_table[index].addr)) )
if(! (bCheckMACEquality(u8ownMAC, 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]);
@ -153,6 +154,37 @@ esp_err_t errGetChildren(mesh_addr_t* pChildren, uint16_t* pu16ChildrenSize)
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 err;
@ -162,11 +194,12 @@ esp_err_t errSendMeshPacket(mesh_addr_t* pAddrDest, MESH_PACKET_t* pPacket)
data.proto = MESH_PROTO_BIN;
data.tos = MESH_TOS_P2P;
memcpy(tx_buf, (uint8_t *)pPacket, sizeof(MESH_PACKET_t));
err = esp_mesh_send(pAddrDest, &data, MESH_DATA_P2P, NULL, 0);
return err;
}
esp_err_t errStartReceiveTask()
{
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);
continue;
}
/*
struct ota_mesh_packet packet;
memcpy(&packet, (uint8_t *)rx_buf, sizeof(struct ota_mesh_packet));
MESH_PACKET_t packet;
memcpy(&packet, (uint8_t *)rx_buf, sizeof(MESH_PACKET_t));
switch (packet.type)
{
case APP_Version_Request:
ESP_LOGI(LOG_TAG, "recv: APP_Version_Request");
packet.type=APP_Version_Response;
packet.au8Payload[0] = 42; //TODO get current running version
// ESP_ERROR_CHECK (esp_mesh_send_packet(&from, &packet)); //send back to parent
case APP_Data:
ESP_LOGD(LOG_TAG, "recv: APP_Data");
//call the rx handle from app
pAppRxHandle(packet.au8Payload, from.addr); //hand over payload and sender of this mesh packet
break;
case APP_Version_Response:
ESP_LOGI(LOG_TAG, "recv: APP_Version_Response - App Version %i: ", packet.au8Payload[0]);
//check if node is out-dated
// esp_mesh_ota_send(&from);
case OTA_Version_Request:
ESP_LOGI(LOG_TAG, "recv: OTA_Version_Request");
break;
case OTA_Version_Respone:
ESP_LOGI(LOG_TAG, "recv: OTA_Version_Respone");
break;
case 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;
case OTA_ACK:
ESP_LOGI(LOG_TAG, "recv: OTA_ACK");
//esp_mesh_ota_send(&from);
break;
case OTA_Complete:
ESP_LOGI(LOG_TAG, "recv: OTA_Complete");
@ -235,9 +261,6 @@ void vTaskReceiveMeshData(void *arg)
ESP_LOGE(LOG_TAG, "recv: something");
break;
}//end switch
*/
} //end while
}

344
components/mesh_ota/Mesh_network_handler.c
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;
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_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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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())
{
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);
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
ESP_ERROR_CHECK(esp_netif_dhcpc_start(netif_sta)); //get a IP from router
}
break;
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;
i32MeshLayer = esp_mesh_get_layer();
}
break;
{
mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)vpEventData;
ESP_LOGI(LOG_TAG, "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d", disconnected->reason);
bIsMeshConnected = 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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
//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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;

4
components/mesh_ota/include/Mesh_OTA.h
View File

@ -33,10 +33,10 @@ enum ota_packet_type
err = (x); \
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);
esp_err_t errExtractVersionNumber(const char* pu8Data, uint32_t* pu32DataLenght, char* pc8RemoteVersionNumber);

23
components/mesh_ota/include/Mesh_network.h
View File

@ -49,9 +49,9 @@
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_Respone, //send own version in payload
OTA_Data, //send image segment
@ -65,20 +65,31 @@ typedef struct meshPacket MESH_PACKET_t;
extern bool bIsMeshConnected;
extern int32_t i32MeshLayer;
extern mesh_addr_t mesh_parent_addr;
extern mesh_addr_t meshParentAddr;
extern esp_netif_t* netif_sta;
extern uint8_t u8ownMAC[6];
esp_err_t errMeshNetworkInitialize();
esp_err_t errMeshNetworkInitializeWiFi();
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);
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);
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);
bool bIsRootNode();
esp_err_t errStartReceiveTask();
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);
#endif /* H_MESH_NETWORK */

4
components/mesh_ota/include/https_client.h
View File

@ -26,7 +26,7 @@
#include "mbedtls/ctr_drbg.h"
#include "mbedtls/error.h"
#include "mbedtls/certs.h"
#include "esp_crt_bundle.h"
#include "esp_crt_bundle.h"
#ifndef CONFIG_OTA_HTTPS_URL
#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 struct HTTPS_Client HTTPS_Client_t;
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_clientDeinitialize();

102
main/Blinky_LED.c
View File

@ -1,11 +1,11 @@
#include "Blinky_LED.h"
static const char *LOG_TAG = "blinky_led";
static bool bLEDisOn = true;
xQueueHandle queueBlinkyLEDPackets;
static bool bLEDisOn = false; //set led default off
static mesh_addr_t addrParent; //addr of parent node
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()
{
@ -14,16 +14,20 @@ esp_err_t errBlinkyLEDInitialize()
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
{
ESP_LOGE(LOG_TAG, "Unable to create Queue for Application Packets");
err = ESP_FAIL;
}
//register the receiver handle in mesh network
ERROR_CHECK(errMeshNetworkSetAppReceiveHandle(rxHandle));
if(err == ESP_OK)
{
xReturned = xTaskCreate(vTaskReadUserInput, "vTaskReadUserInput", 2048, NULL, 5, NULL);
xReturned = xTaskCreate(vTaskReadUserInput, "vTaskReadUserInput", 4096, NULL, 5, NULL);
if(xReturned != pdPASS)
{
err = ESP_FAIL;
@ -32,7 +36,7 @@ esp_err_t errBlinkyLEDInitialize()
if(err == ESP_OK)
{
xReturned = xTaskCreate(vTaskReceiveData, "vTaskReceiveData", 2048, NULL, 5, NULL);
xReturned = xTaskCreate(vTaskReceiveData, "vTaskReceiveData", 4096, NULL, 5, NULL);
if(xReturned != pdPASS)
{
err = ESP_FAIL;
@ -58,27 +62,65 @@ void vGPIOInitialize()
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)
{
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)
{
{ //check for BTN press
if(gpio_get_level(GPIO_BOOT_BTN) == 0)
{
err = ESP_OK;
if(bLEDisOn == false)
{
ESP_LOGI(LOG_TAG,"switch ON");
bTmpStateLED = LED_ON;
bTmpPacket.type = LED_ON;
}
else
{
ESP_LOGI(LOG_TAG,"switch OFF");
bTmpStateLED = LED_OFF;
bTmpPacket.type = 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);
}
@ -88,37 +130,55 @@ void vTaskReadUserInput(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)
{
if (xQueueReceive(queueBlinkyLEDPackets, &bTmpStateLED, portMAX_DELAY) != pdTRUE)
if (xQueueReceive(queueBlinkyLEDPackets, &bTmpPacket, portMAX_DELAY) != pdTRUE)
{
ESP_LOGE(LOG_TAG, "Unable to receive packet from Queue");
}
else
{
err = ESP_OK;
//Successfully RECEIVED the packet
switch (bTmpStateLED)
switch (bTmpPacket.type)
{
case LED_ON:
bLEDisOn = true;
gpio_set_level(GPIO_LED, 1); //switch on
ESP_LOGI(LOG_TAG,"rec ON");
ESP_LOGI(LOG_TAG,"switch LED ON");
break;
case LED_OFF:
bLEDisOn = false;
gpio_set_level(GPIO_LED, 0); //switch off
ESP_LOGI(LOG_TAG,"rec OFF");
ESP_LOGI(LOG_TAG,"switch LED OFF");
break;
default:
bLEDisOn = false;
gpio_set_level(GPIO_LED, 0); //switch off
ESP_LOGI(LOG_TAG,"switch LED OFF");
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);
}
}

26
main/Blinky_LED.h
View File

@ -11,25 +11,29 @@
#include "Mesh_OTA.h"
#define GPIO_BOOT_BTN 0
#define GPIO_LED 2
#define GPIO_BOOT_BTN 0 //GPIO0 (Boot BTN)
#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
{
LED_OFF,
LED_ON,
struct blinky_packet
{
enum blinky_packet_type
{
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();
void vGPIOInitialize();
void rxHandle(uint8_t* pu8Data, uint8_t* pu8Sender);
void vTaskReadUserInput(void *arg);
void vTaskReceiveData(void *arg);
#endif /* H_BLINKY_LED */

4
main/Main.c
View File

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

2
sdkconfig
View File

@ -159,7 +159,7 @@ CONFIG_MESH_AP_AUTHMODE=3
CONFIG_MESH_AP_PASSWD="qaws1234"
CONFIG_MESH_AP_CONNECTIONS=6
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_PORT="443"
CONFIG_OTA_HTTPS_URL="https://ota.hendrikschutter.com/mesh_ota.bin"