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

added control for http_ota task

Browse Source
This commit is contained in:
Hendrik Schutter
2021-01-17 23:27:01 +01:00
parent 62d16a437a
commit c6829f0483
7 changed files with 665 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
components/mesh_ota/Mesh_OTA.c
View File

@ -1,5 +1,153 @@
#include "Mesh_OTA.h"
static const char *LOG_TAG = "mesh_ota";
xQueueHandle queueNodes; //nodes that should be checked for ota update (contains children and parent)
xQueueHandle queueMessageOTA; //mesh ota controll messages like "OTA_Version_Response" "OTA_ACK"
SemaphoreHandle_t bsStartStopServerWorker; //binary semaphore
esp_err_t errMeshOTAInitialize()
{
esp_err_t err = ESP_OK;
BaseType_t xReturned;
//create queue to store nodes for ota worker task
queueNodes = xQueueCreate(QUEUE_NODES_SIZE, sizeof(mesh_addr_t));
if (queueNodes == 0) // Queue not created
{
ESP_LOGE(LOG_TAG, "Unable to create Queue for Nodes");
err = ESP_FAIL;
}
if(err == ESP_OK)
{
//create queue to store ota messages
queueMessageOTA = xQueueCreate(QUEUE_MESSAGE_OTA_SIZE, sizeof(MESH_PACKET_t));
if (queueMessageOTA == 0) // Queue not created
{
ESP_LOGE(LOG_TAG, "Unable to create Queue for OTA Messages");
err = ESP_FAIL;
}
}
if(err == ESP_OK)
{
bsStartStopServerWorker = xSemaphoreCreateBinary();
if( bsStartStopServerWorker == NULL )
{
ESP_LOGE(LOG_TAG, "Unable to create Mutex to represent state of Server worker");
err = ESP_FAIL;
}
}
ERROR_CHECK(errMeshNetworkSetChildConnectedHandle(vAddNodeToPossibleUpdatableQueue));
ERROR_CHECK(errMeshNetworkSetOTAMessageHandleHandle(vAddOTAControllMessageToQueue));
ERROR_CHECK(errMeshNetworkSetChangeStateOfServerWorkerHandle(vChangeStateOfServerWorker));
if(err == ESP_OK)
{
xReturned = xTaskCreate(vTaskServerWorker, "vTaskServerWorker", 4096, NULL, 5, NULL);
if(xReturned != pdPASS)
{
ESP_LOGE(LOG_TAG, "Unable to create the server worker task");
err = ESP_FAIL;
}
}
return err;
}
void vAddNodeToPossibleUpdatableQueue(uint8_t* pu8Data)
{
//send payload to node queue
mesh_addr_t addrNode;
memcpy(&addrNode.addr, (uint8_t *)pu8Data, 6); //copy MAC
if (xQueueSend(queueNodes, &addrNode, portMAX_DELAY) != pdPASS)
{
ESP_LOGE(LOG_TAG, "Unable to push node into node queue");
}
else
{
ESP_LOGI(LOG_TAG, "added node \"%x:%x:%x:%x:%x:%x\" to possible updatable queue", addrNode.addr[0], addrNode.addr[1], addrNode.addr[2], addrNode.addr[3], addrNode.addr[4], addrNode.addr[5]);
}
}
void vAddOTAControllMessageToQueue(MESH_PACKET_t* puMeshPacket)
{
//send ota packet to packet queue
if (xQueueSend(queueMessageOTA, puMeshPacket, portMAX_DELAY) != pdPASS)
{
ESP_LOGE(LOG_TAG, "Unable to push ota packet into packet queue");
}
else
{
ESP_LOGI(LOG_TAG, "added ota controll message to queue");
}
}
void vChangeStateOfServerWorker(bool bState) //allow access via function ptn to networl_handler
{
static bool bLastState = false;
if(bState != bLastState) //change only if necessary
{
ESP_LOGI(LOG_TAG, "server worker change handler");
if(bState == true)
{
if (xSemaphoreGive(bsStartStopServerWorker) != pdTRUE)
{
ESP_LOGE(LOG_TAG, "Unable to give mutex to activate the server worker");
}
}
else
{
if (xSemaphoreTake(bsStartStopServerWorker,( TickType_t ) 10 ) != pdTRUE)
{
ESP_LOGE(LOG_TAG, "Unable to obtain mutex to deactivate the server worker");
}
}
bLastState = bState;
}
}
void vTaskOTAWorker(void *arg)
{
}
void vTaskServerWorker(void *arg)
{
while(true)
{
xSemaphoreTake(bsStartStopServerWorker, portMAX_DELAY); //wait for binary semaphore that allows to start the worker
xSemaphoreGive(bsStartStopServerWorker); //free binary semaphore, this allows the handler to change is to taken
if (esp_mesh_is_root()) //check again that this node is the root node
{
ESP_LOGI(LOG_TAG, "DEMO HTTP request");
//server get version
//ota update if newer
//lock ota mutex
vTaskDelay( (SERVER_CHECK_INTERVAL*1000) / portTICK_PERIOD_MS); //sleep till next server check
}
}
}
/*
* 999.999.999
* Return true if remote version is newer (higher) than local version
@ -20,15 +168,15 @@ bool bNewerVersion(const char* pu8Local, const char* pu8Remote)
char* pu8TokenRemote = strtok_r(u8RemoteTmp, ".", &pu8saveptrRemote); //split tokens
while( (u8Index <= 2) && (bReturn == false)) //loop through tokens
{
u8Index++;
if(atoi(pu8TokenLocal) < atoi(pu8TokenRemote))
{
bReturn = true; //version number difference --> stop loop
u8Index++;
if(atoi(pu8TokenLocal) < atoi(pu8TokenRemote))
{
bReturn = true; //version number difference --> stop loop
}
pu8TokenLocal = strtok_r(NULL, ".", &pu8saveptrLocal); //split tokens
pu8TokenRemote = strtok_r(NULL, ".", &pu8saveptrRemote); //split tokens
}
pu8TokenLocal = strtok_r(NULL, ".", &pu8saveptrLocal); //split tokens
pu8TokenRemote = strtok_r(NULL, ".", &pu8saveptrRemote); //split tokens
}
return bReturn;
}
@ -51,61 +199,61 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
*pu32StartOffset = 0U; //reset offset to zero
while((u32DataIndex < *pu32DataLenght) && (bImageStartOffsetFound == false))
{
//search for magic byte
if(pu8Data[u32DataIndex] == 0xe9)
{
//magic byte found
while ((u8FirstDotIndex < 3) && (u32FirstDotOffset == 0))
{
//search first dot in version number
if((u32DataIndex+49+u8FirstDotIndex) < *pu32DataLenght)
//search for magic byte
if(pu8Data[u32DataIndex] == 0xe9)
{
if((pu8Data[(u32DataIndex+49+u8FirstDotIndex)] == 0x2e))
{
//first dot found
u32FirstDotOffset = (u32DataIndex+49+u8FirstDotIndex);
}
}
u8FirstDotIndex++;
}
//magic byte found
while ((u8FirstDotIndex < 3) && (u32FirstDotOffset == 0))
{
//search first dot in version number
if((u32DataIndex+49+u8FirstDotIndex) < *pu32DataLenght)
{
if((pu8Data[(u32DataIndex+49+u8FirstDotIndex)] == 0x2e))
{
//first dot found
u32FirstDotOffset = (u32DataIndex+49+u8FirstDotIndex);
}
}
u8FirstDotIndex++;
}
while ((u8SecondDotIndex < 3) && (u32SecondDotOffset == 0) && (u32FirstDotOffset != 0))
{
//search first dot in version number
if((u32FirstDotOffset+(u8SecondDotIndex+2)) < *pu32DataLenght)
{
if((pu8Data[(u32FirstDotOffset+(u8SecondDotIndex+2))] == 0x2e))
{
//second dot found
u32SecondDotOffset = (u32FirstDotOffset+(u8SecondDotIndex+2));
}
}
u8SecondDotIndex++;
}
while ((u8SecondDotIndex < 3) && (u32SecondDotOffset == 0) && (u32FirstDotOffset != 0))
{
//search first dot in version number
if((u32FirstDotOffset+(u8SecondDotIndex+2)) < *pu32DataLenght)
{
if((pu8Data[(u32FirstDotOffset+(u8SecondDotIndex+2))] == 0x2e))
{
//second dot found
u32SecondDotOffset = (u32FirstDotOffset+(u8SecondDotIndex+2));
}
}
u8SecondDotIndex++;
}
if((u32FirstDotOffset != 0) && (u32SecondDotOffset != 0))
{
//image start found based on magic byte and version number systax
*pu32StartOffset = u32DataIndex; //store image start offset
bImageStartOffsetFound = true;
}
else
{
// this is propably not the magic byte --> reset
u32FirstDotOffset = 0;
u32SecondDotOffset = 0;
u8FirstDotIndex = 0;
u8SecondDotIndex = 0;
}
if((u32FirstDotOffset != 0) && (u32SecondDotOffset != 0))
{
//image start found based on magic byte and version number systax
*pu32StartOffset = u32DataIndex; //store image start offset
bImageStartOffsetFound = true;
}
else
{
// this is propably not the magic byte --> reset
u32FirstDotOffset = 0;
u32SecondDotOffset = 0;
u8FirstDotIndex = 0;
u8SecondDotIndex = 0;
}
}
u32DataIndex++;
}
u32DataIndex++;
}
if(bImageStartOffsetFound == false)
{
errReturn = ESP_ERR_NOT_FOUND;
}
{
errReturn = ESP_ERR_NOT_FOUND;
}
return errReturn;
}
@ -119,17 +267,15 @@ esp_err_t errExtractVersionNumber(const char* pu8Data, uint32_t* pu32DataLenght,
err = errFindImageStart(pu8Data, pu32DataLenght, &u32StartOffset); //get image start offset
if(err == ESP_OK)
{
//image found
strncpy(pc8RemoteVersionNumber, pu8Data+(u32StartOffset+48), 11); //copy version number
pc8RemoteVersionNumber[12] = '\0';
}
{
//image found
strncpy(pc8RemoteVersionNumber, pu8Data+(u32StartOffset+48), 11); //copy version number
pc8RemoteVersionNumber[12] = '\0';
}
return err;
}
/*
esp_err_t esp_mesh_ota_send(mesh_addr_t* dest)
{
esp_err_t err = ESP_OK;