completed demo app blinky_led

components/mesh_ota/Mesh_network.c

@@ -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;
         }
-
+        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)
         {
-        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;
-        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;
         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
 }
 

components/mesh_ota/Mesh_network_handler.c

@@ -76,9 +76,9 @@ void vMeshEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventI
         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); 
+        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(mesh_parent_addr.addr),
+        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;
@@ -140,8 +140,8 @@ void vMeshEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventI
     {
         //new root
         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;
         case MESH_EVENT_TODS_STATE: 

components/mesh_ota/include/Mesh_OTA.h

@@ -33,7 +33,7 @@ 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));   \
             }                                                                                           \
     }                                                                                                   \
 

components/mesh_ota/include/Mesh_network.h

@@ -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);
+bool bIsRootNode();
-void vIPEventHandler(void *arg, esp_event_base_t event_base, int32_t i32EventID, void *event_data);
+
 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 */
 

main/Blinky_LED.c

@@ -1,11 +1,11 @@
-
-
 #include "Blinky_LED.h"
 
 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()
 {
@@ -14,6 +14,7 @@ esp_err_t errBlinkyLEDInitialize()
 
     vGPIOInitialize();
 
+    //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
     {
@@ -21,9 +22,12 @@ esp_err_t errBlinkyLEDInitialize()
         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");
+                bTmpPacket.type = LED_ON;
-                bTmpStateLED = LED_ON;
             }
             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);
         }
@@ -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);
     }
 }

main/Blinky_LED.h

@@ -11,22 +11,26 @@
 
 #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)
 
+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);
 

sdkconfig

@@ -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"