893 lines
39 KiB
C
893 lines
39 KiB
C
#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
|
||
SemaphoreHandle_t bsOTAProcess; //binary semaphore
|
||
|
||
const esp_partition_t* pOTAPartition; //pointer to ota partition
|
||
bool bWantReboot; //flag to signal pending reboot
|
||
|
||
esp_err_t errMeshOTAInitialize()
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
BaseType_t xReturned;
|
||
bWantReboot = false;
|
||
|
||
//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;
|
||
}
|
||
}
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
bsOTAProcess = xSemaphoreCreateBinary();
|
||
if( bsOTAProcess == NULL )
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to create Mutex to grant access to OTA Process");
|
||
err = ESP_FAIL;
|
||
}
|
||
}
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
xSemaphoreGive(bsOTAProcess); //unlock binary semaphore
|
||
if( bsOTAProcess == NULL )
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to unlock Mutex to grant access to OTA Process");
|
||
err = ESP_FAIL;
|
||
}
|
||
}
|
||
|
||
ERROR_CHECK(errMeshNetworkSetChildConnectedHandle(vAddNodeToPossibleUpdatableQueue));
|
||
ERROR_CHECK(errMeshNetworkSetOTAMessageHandleHandle(vAddOTAControllMessageToQueue));
|
||
ERROR_CHECK(errMeshNetworkSetChangeStateOfServerWorkerHandle(vChangeStateOfServerWorker));
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
pOTAPartition = esp_ota_get_next_update_partition(NULL); //get ota partition
|
||
|
||
if(pOTAPartition == NULL)
|
||
{
|
||
err = ESP_FAIL;
|
||
ESP_LOGE(LOG_TAG, "unable to get next ota partition");
|
||
}
|
||
}
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
xReturned = xTaskCreate(vTaskServerWorker, "vTaskServerWorker", 8192, NULL, 5, NULL);
|
||
if(xReturned != pdPASS)
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to create the server worker task");
|
||
err = ESP_FAIL;
|
||
}
|
||
}
|
||
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
xReturned = xTaskCreate(vTaskOTAWorker, "vTaskOTAWorker", 8192, NULL, 5, NULL);
|
||
if(xReturned != pdPASS)
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to create the OTA worker task");
|
||
err = ESP_FAIL;
|
||
}
|
||
}
|
||
|
||
return err;
|
||
}
|
||
|
||
void vAddNodeToPossibleUpdatableQueue(uint8_t* pu8MAC)
|
||
{
|
||
//send payload to node queues
|
||
mesh_addr_t addrNode;
|
||
memcpy(&addrNode.addr, (uint8_t *)pu8MAC, 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 message to queue: %i (type)", puMeshPacket->type);
|
||
}
|
||
}
|
||
|
||
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 vTaskServerWorker(void *arg)
|
||
{
|
||
esp_err_t err;
|
||
bool bNewOTAImage; //true if a new ota image was downloaded and validated
|
||
bool bFirstRun = true;
|
||
|
||
while(true)
|
||
{
|
||
err = ESP_OK;
|
||
bNewOTAImage = false;
|
||
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, "Checking firmware image on server");
|
||
|
||
if(bFirstRun == true)
|
||
{
|
||
ERROR_CHECK(errHTTPSClientInitialize());
|
||
bFirstRun = false;
|
||
}
|
||
|
||
ERROR_CHECK(errHTTPSClientConnectToServer());
|
||
ERROR_CHECK(errHTTPSClientValidateServer());
|
||
ERROR_CHECK(errHTTPSClientSendRequest());
|
||
|
||
ERROR_CHECK(errOTAHTTPS(&bNewOTAImage));
|
||
errHTTPSClientReset();
|
||
|
||
if(bNewOTAImage == true)
|
||
{
|
||
//set want reboot
|
||
ESP_LOGI(LOG_TAG, "Updated successfully via HTTPS, set pending reboot");
|
||
bWantReboot = true;
|
||
vAddAllNeighboursToQueue(); //add all existing neighbours to queue (aparent will not be added because this node is the root)
|
||
}
|
||
vTaskDelay( (SERVER_CHECK_INTERVAL*1000) / portTICK_PERIOD_MS); //sleep till next server checks
|
||
}
|
||
}
|
||
}
|
||
|
||
void vTaskOTAWorker(void *arg)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
bool bNewOTAImage; //true if a new ota image was downloaded and validated
|
||
mesh_addr_t meshNodeAddr; //node that should be checked for ota update
|
||
|
||
while(true)
|
||
{
|
||
err = ESP_OK;
|
||
bNewOTAImage = false;
|
||
|
||
if((uxQueueSpacesAvailable(queueNodes) - QUEUE_NODES_SIZE) == 0)
|
||
{
|
||
//nodes queue is empty
|
||
ESP_LOGI(LOG_TAG, "nodes queue is empty");
|
||
|
||
if(bWantReboot == true)
|
||
{
|
||
ESP_LOGI(LOG_TAG, "ESP32 Reboot ...");
|
||
//vTaskDelay( (1000) / portTICK_PERIOD_MS);
|
||
//esp_restart();
|
||
}
|
||
|
||
ERROR_CHECK(errOTAMeshSlave(&bNewOTAImage));
|
||
}
|
||
else
|
||
{
|
||
//queue not empty
|
||
ESP_LOGI(LOG_TAG, "nodes queue not empty: %i", (QUEUE_NODES_SIZE - uxQueueSpacesAvailable(queueNodes)));
|
||
|
||
if (xQueueReceive(queueNodes, &meshNodeAddr, ((100) / portTICK_PERIOD_MS)) != pdTRUE)
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to receive OTA Messages from Queue");
|
||
err = ESP_FAIL;
|
||
}
|
||
|
||
ERROR_CHECK(errOTAMeshMaster(&bNewOTAImage, &meshNodeAddr));
|
||
|
||
if (err != ESP_OK)
|
||
{
|
||
//OTA process faild --> add back to queue
|
||
vAddNodeToPossibleUpdatableQueue(meshNodeAddr.addr);
|
||
}
|
||
}
|
||
|
||
if(bNewOTAImage == true)
|
||
{
|
||
//set want reboot
|
||
ESP_LOGI(LOG_TAG, "Updated successfully via Mesh, set pending reboot");
|
||
bWantReboot = true;
|
||
vAddAllNeighboursToQueue(); //add all existing neighbours to queue
|
||
}
|
||
vTaskDelay( (1000) / portTICK_PERIOD_MS);
|
||
}
|
||
}
|
||
|
||
esp_err_t errOTAHTTPS(bool* pbNewOTAImage)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
char u8OTABuffer[OTA_HTTPS_SEGMENT_SIZE]; //store image segment from server before ota write
|
||
uint32_t u32BufferLenght = OTA_HTTPS_SEGMENT_SIZE; //size of buffer
|
||
uint32_t u32BytesRead = 0; //number of bytes that are read from server, <= u32BufferLenght
|
||
char pcRemoteVersionNumber[12]; //string for version number in server image
|
||
const esp_partition_t* pBootPartition; //pointer to boot partition (that will booted after reset)
|
||
static esp_ota_handle_t otaHandle; //OTA process handle
|
||
uint32_t u32StartOffset = 0U; //start offset for image (exclude the http response data)
|
||
esp_app_desc_t bootPartitionDesc; //Metadate from boot partition
|
||
uint32_t u32OTABytesWritten = 0U; //counter unsed for progress log
|
||
|
||
ERROR_CHECK(errHTTPSClientRetrieveData(u8OTABuffer, &u32BufferLenght, &u32BytesRead)); //read first bytes if image, including the version
|
||
|
||
ERROR_CHECK(errExtractVersionNumber(u8OTABuffer, &u32BytesRead, pcRemoteVersionNumber)); //extract version numbers
|
||
|
||
if(err == ESP_OK) //check if version number is found
|
||
{
|
||
xSemaphoreTake(bsOTAProcess, portMAX_DELAY); //wait for binary semaphore that allows to start the OTA process
|
||
|
||
pBootPartition = esp_ota_get_boot_partition(); //get boot partition (that will booted after reset), not the running partition
|
||
ERROR_CHECK(esp_ota_get_partition_description(pBootPartition, &bootPartitionDesc)); //get metadata of partition
|
||
|
||
if(bNewerVersion((bootPartitionDesc).version, pcRemoteVersionNumber)) //compare local and remote version
|
||
{
|
||
// server image is newer --> OTA update required
|
||
ESP_LOGI(LOG_TAG, "Server: image is newer --> OTA update required");
|
||
|
||
ERROR_CHECK(errFindImageStart(u8OTABuffer, &u32BufferLenght, &u32StartOffset)); //get image start offset
|
||
|
||
ERROR_CHECK(esp_ota_begin(pOTAPartition, OTA_SIZE_UNKNOWN, &otaHandle)); //start ota update process
|
||
if(err == ESP_OK)
|
||
{
|
||
//image download and ota partition write
|
||
ESP_LOGI(LOG_TAG, "start OTA download via HTTPS");
|
||
do
|
||
{
|
||
vPrintOTAProgress(&(pOTAPartition->size), &u32OTABytesWritten, Receiver);
|
||
ERROR_CHECK(esp_ota_write(otaHandle, (const void*) u8OTABuffer+u32StartOffset, (u32BytesRead-u32StartOffset)));
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
//write was succsesfull
|
||
u32StartOffset = 0U; //reset the offset for next download
|
||
ERROR_CHECK(errHTTPSClientRetrieveData(u8OTABuffer, &u32BufferLenght, &u32BytesRead)); //download next data segment
|
||
u32OTABytesWritten = u32OTABytesWritten + u32BytesRead; //update counter
|
||
}
|
||
}
|
||
while ((u32BytesRead > 0) && (err == ESP_OK) && (u32OTABytesWritten <= pOTAPartition->size)); //loop until error or complete image downloaded
|
||
}
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
//no error occurred --> finish ota update process
|
||
ERROR_CHECK(esp_ota_end(otaHandle)); //finish process
|
||
ERROR_CHECK(esp_ota_set_boot_partition(pOTAPartition)); //set new image as boot
|
||
if(err == ESP_OK)
|
||
{
|
||
*pbNewOTAImage = true; //image validated
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//error occurred --> abort ota update process
|
||
ESP_LOGE(LOG_TAG, "abort ota process due to error 0x%x -> %s", err, esp_err_to_name(err));
|
||
ERROR_CHECK(esp_ota_abort(otaHandle));
|
||
*pbNewOTAImage = false; //ota update failed
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ESP_LOGI(LOG_TAG, "server image is NOT newer --> OTA update NOT required");
|
||
}
|
||
xSemaphoreGive(bsOTAProcess); //free binary semaphore, this allows other tasks to start the OTA process
|
||
} //end version number extracted
|
||
return err;
|
||
}
|
||
|
||
esp_err_t errOTAMeshSlave(bool* pbNewOTAImage)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
MESH_PACKET_t sOTAMessage;
|
||
const esp_partition_t* pBootPartition; //pointer to boot partition (that will booted after reset)
|
||
esp_app_desc_t bootPartitionDesc; //Metadate from boot partition
|
||
*pbNewOTAImage = false; //set default false
|
||
|
||
//read OTAMessages queue
|
||
if(uxQueueSpacesAvailable(queueMessageOTA) < QUEUE_MESSAGE_OTA_SIZE)
|
||
{
|
||
//queue not empty
|
||
if (xQueueReceive(queueMessageOTA, &sOTAMessage, ((100) / portTICK_PERIOD_MS)) != pdTRUE)
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to receive OTA Messages from Queue");
|
||
err = ESP_FAIL;
|
||
}
|
||
|
||
if((err == ESP_OK) && (sOTAMessage.type == OTA_Version_Request)) //if OTA_Version_Request
|
||
{
|
||
xSemaphoreTake(bsOTAProcess, portMAX_DELAY); //wait for binary semaphore that allows to start the OTA process
|
||
|
||
pBootPartition = esp_ota_get_boot_partition(); //get boot partition (that will booted after reset), not the running partition
|
||
ERROR_CHECK(esp_ota_get_partition_description(pBootPartition, &bootPartitionDesc)); //get metadata of partition
|
||
|
||
//send OTA_Version_Response to sender of OTA_Version_Request packet wirh version in payload
|
||
ERROR_CHECK(errSendOTAVersionResponse(&sOTAMessage.meshSenderAddr));
|
||
|
||
if((bNewerVersion((bootPartitionDesc).version, (char*) sOTAMessage.au8Payload)) && (err == ESP_OK)) //compare local and remote version
|
||
{
|
||
//remote newer as local
|
||
ESP_LOGI(LOG_TAG, "remote image on node is newer --> OTA update required");
|
||
// --> this version older --> start OTA_Rx --> set pbNewOTAImage true
|
||
ERROR_CHECK(errOTAMeshReceive(pbNewOTAImage, &sOTAMessage.meshSenderAddr));
|
||
}
|
||
|
||
if((bNewerVersion((char*) sOTAMessage.au8Payload, (bootPartitionDesc).version)) && (err == ESP_OK)) //compare remote and local version
|
||
{
|
||
//local newer as remote
|
||
ESP_LOGI(LOG_TAG, "remote image on node is older --> OTA send required");
|
||
// --> this version newer --> start OTA_Tx
|
||
ERROR_CHECK(errOTAMeshTransmit(&sOTAMessage.meshSenderAddr));
|
||
}
|
||
xSemaphoreGive(bsOTAProcess); //free binary semaphore, this allows other tasks to start the OTA process
|
||
}
|
||
}
|
||
return err;
|
||
}
|
||
|
||
esp_err_t errOTAMeshMaster(bool* pbNewOTAImage, mesh_addr_t* pMeshNodeAddr)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
MESH_PACKET_t sOTAMessage;
|
||
const esp_partition_t* pBootPartition; //pointer to boot partition (that will booted after reset)
|
||
esp_app_desc_t bootPartitionDesc; //Metadata from boot partition
|
||
bool bNodeIsConnected = false;
|
||
bool bNodeIsResponding = false;
|
||
|
||
*pbNewOTAImage = false; //set default false
|
||
|
||
if(bIsNodeNeighbour(pMeshNodeAddr) == true) //check if node is still connected
|
||
{
|
||
bNodeIsConnected = true; //node is one of the neighbours
|
||
xSemaphoreTake(bsOTAProcess, portMAX_DELAY); //wait for binary semaphore that allows to start the OTA process
|
||
|
||
ERROR_CHECK(errSendOTAVersionRequest(pMeshNodeAddr)); //send OTA_VERSION_REQUEST with local version in payload
|
||
|
||
for (uint32_t u32Index = 0; u32Index < QUEUE_MESSAGE_OTA_SIZE; u32Index++) //loop through all OTA messages
|
||
{
|
||
if(uxQueueSpacesAvailable(queueMessageOTA) < QUEUE_MESSAGE_OTA_SIZE)
|
||
{
|
||
//queue not empty
|
||
if (xQueueReceive(queueMessageOTA, &sOTAMessage, ((3000) / portTICK_PERIOD_MS)) != pdTRUE)
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to receive OTA Messages from queue");
|
||
err = ESP_FAIL;
|
||
}
|
||
|
||
if((err == ESP_OK) && (sOTAMessage.type == OTA_Version_Response) && (bCheckMACEquality(sOTAMessage.meshSenderAddr.addr, pMeshNodeAddr->addr))) //if OTA_Version_Request
|
||
{
|
||
bNodeIsResponding = true;
|
||
pBootPartition = esp_ota_get_boot_partition(); //get boot partition (that will booted after reset), not the running partition
|
||
ERROR_CHECK(esp_ota_get_partition_description(pBootPartition, &bootPartitionDesc)); //get metadata of partition
|
||
|
||
if((bNewerVersion((bootPartitionDesc).version, (char*) sOTAMessage.au8Payload)) && (err == ESP_OK)) //compare local and remote version
|
||
{
|
||
//remote newer as local
|
||
ESP_LOGI(LOG_TAG, "Mesh: remote image on node is newer --> OTA update required");
|
||
// --> this version older --> start OTA_Rx --> set pbNewOTAImage true
|
||
ERROR_CHECK(errOTAMeshReceive(pbNewOTAImage, &sOTAMessage.meshSenderAddr));
|
||
}
|
||
|
||
if((bNewerVersion((char*) sOTAMessage.au8Payload, (bootPartitionDesc).version)) && (err == ESP_OK)) //compare remote and local version
|
||
{
|
||
//local newer as remote
|
||
ESP_LOGI(LOG_TAG, "Mesh: remote image on node is older --> OTA send required");
|
||
// --> this version newer --> start OTA_Tx
|
||
ERROR_CHECK(errOTAMeshTransmit(&sOTAMessage.meshSenderAddr));
|
||
}
|
||
}
|
||
else if (err == ESP_OK)
|
||
{
|
||
//received from wrong node or type --> back to queue
|
||
vAddOTAControllMessageToQueue(&sOTAMessage);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// OTA Message queue is empty --> wait some time
|
||
vTaskDelay( (1000/QUEUE_MESSAGE_OTA_SIZE) / portTICK_PERIOD_MS);
|
||
}
|
||
}//end loop
|
||
xSemaphoreGive(bsOTAProcess); //free binary semaphore, this allows other tasks to start the OTA process
|
||
}
|
||
|
||
if((bNodeIsResponding == false) && (bNodeIsConnected == true))
|
||
{
|
||
//add node back to queue if connected and NOT responding
|
||
vAddNodeToPossibleUpdatableQueue(pMeshNodeAddr->addr);
|
||
}
|
||
return err;
|
||
}
|
||
|
||
bool bNewerVersion(const char* pu8Local, const char* pu8Remote)
|
||
{
|
||
/*
|
||
* Return true if remote version is newer (higher) than local version
|
||
*/
|
||
char u8LocalTmp[12]; //local version
|
||
char u8RemoteTmp[12]; //remote version
|
||
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
|
||
|
||
strncpy(u8LocalTmp, pu8Local, 12); //copy in tmp
|
||
strncpy(u8RemoteTmp, pu8Remote, 12); //copy in tmp
|
||
|
||
char* pu8TokenLocal = strtok_r(u8LocalTmp, ".", &pu8saveptrLocal); //split tokens
|
||
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
|
||
}
|
||
pu8TokenLocal = strtok_r(NULL, ".", &pu8saveptrLocal); //split tokens
|
||
pu8TokenRemote = strtok_r(NULL, ".", &pu8saveptrRemote); //split tokens
|
||
}
|
||
return bReturn;
|
||
}
|
||
|
||
esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint32_t* pu32StartOffset)
|
||
{
|
||
/*
|
||
Offset value
|
||
0 = 0xE9 (first byte in image --> magic byte)
|
||
48 = first digit of version number
|
||
*/
|
||
|
||
esp_err_t errReturn = ESP_OK;
|
||
bool bImageStartOffsetFound = false;
|
||
uint32_t u32DataIndex = 0;
|
||
uint32_t u32FirstDotOffset = 0;
|
||
uint32_t u32SecondDotOffset = 0;
|
||
uint8_t u8FirstDotIndex = 0;
|
||
uint8_t u8SecondDotIndex = 0;
|
||
|
||
*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)
|
||
{
|
||
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++;
|
||
}
|
||
|
||
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++;
|
||
}
|
||
|
||
if(bImageStartOffsetFound == false)
|
||
{
|
||
errReturn = ESP_ERR_NOT_FOUND;
|
||
}
|
||
|
||
return errReturn;
|
||
}
|
||
|
||
esp_err_t errExtractVersionNumber(const char* pu8Data, uint32_t* pu32DataLenght, char* pc8RemoteVersionNumber)
|
||
{
|
||
uint32_t u32StartOffset;
|
||
esp_err_t err = ESP_OK;
|
||
|
||
strcpy(pc8RemoteVersionNumber, "999.999.999"); //init value
|
||
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';
|
||
}
|
||
return err;
|
||
}
|
||
|
||
void vPrintOTAProgress(const uint32_t* const pu32TotalImageSize, const uint32_t* const pu32BytesWritten, OTA_MESH_ROLE_t eRole)
|
||
{
|
||
uint32_t u32Percentage = 0U;
|
||
static uint32_t u32LastPercentage = 0U;
|
||
|
||
if((*pu32BytesWritten) >= (*pu32TotalImageSize))
|
||
{
|
||
u32Percentage = 100;
|
||
}
|
||
else
|
||
{
|
||
u32Percentage = (uint32_t) (((float) (*pu32BytesWritten)/(float) (*pu32TotalImageSize)) * 100.0);
|
||
}
|
||
|
||
if((u32Percentage-u32LastPercentage) >= OTA_PROGRESS_LOG_INTERVAL)
|
||
{
|
||
if(eRole == Transmitter)
|
||
{
|
||
ESP_LOGI(LOG_TAG, "Transmitting OTA update: %i %%", u32Percentage);
|
||
}
|
||
|
||
if(eRole == Receiver)
|
||
{
|
||
ESP_LOGI(LOG_TAG, "Receiving OTA update: %i %%", u32Percentage);
|
||
}
|
||
|
||
|
||
|
||
u32LastPercentage = u32Percentage;
|
||
}
|
||
}
|
||
|
||
void vAddAllNeighboursToQueue(void)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
|
||
mesh_addr_t addrParent; //addr of parent node
|
||
mesh_addr_t childrenAddr[CONFIG_MESH_ROUTE_TABLE_SIZE]; //array of children attached to this node
|
||
uint16_t u16ChildrenSize = 0U; //number of children attached to this node
|
||
|
||
err = errGetParentNode(&addrParent);
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
vAddNodeToPossibleUpdatableQueue(addrParent.addr);
|
||
ESP_LOGI(LOG_TAG, "added parent");
|
||
}
|
||
|
||
err = ESP_OK; //reset error code
|
||
|
||
ERROR_CHECK(errGetChildren(childrenAddr, &u16ChildrenSize)); //get all children
|
||
|
||
for (uint16_t u16Index = 0; ((u16Index < u16ChildrenSize) && (err == ESP_OK)); u16Index++)
|
||
{
|
||
vAddNodeToPossibleUpdatableQueue(childrenAddr[u16Index].addr);
|
||
ESP_LOGI(LOG_TAG, "added child");
|
||
}
|
||
}
|
||
|
||
esp_err_t errSendOTAVersionResponse(mesh_addr_t* pMeshReceiverAddr)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
MESH_PACKET_t packet;
|
||
packet.type = OTA_Version_Response;
|
||
|
||
const esp_partition_t* pBootPartition; //pointer to boot partition (that will booted after reset)
|
||
esp_app_desc_t bootPartitionDesc; //Metadata from boot partition
|
||
|
||
pBootPartition = esp_ota_get_boot_partition(); //get boot partition (that will booted after reset), not the running partition
|
||
ERROR_CHECK(esp_ota_get_partition_description(pBootPartition, &bootPartitionDesc)); //get metadate of partition
|
||
memcpy(&packet.au8Payload, &bootPartitionDesc.version, 12); //copy local version to OTA_Version_Response packet
|
||
err = errSendMeshPacket(pMeshReceiverAddr, &packet);
|
||
return err;
|
||
}
|
||
|
||
esp_err_t errSendOTAVersionRequest(mesh_addr_t* pMeshReceiverAddr)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
MESH_PACKET_t packet;
|
||
packet.type = OTA_Version_Request;
|
||
|
||
const esp_partition_t* pBootPartition; //pointer to boot partition (that will booted after reset)
|
||
esp_app_desc_t bootPartitionDesc; //Metadata from boot partition
|
||
|
||
pBootPartition = esp_ota_get_boot_partition(); //get boot partition (that will booted after reset), not the running partition
|
||
ERROR_CHECK(esp_ota_get_partition_description(pBootPartition, &bootPartitionDesc)); //get metadate of partition
|
||
memcpy(&packet.au8Payload, &bootPartitionDesc.version, 12); //copy local version to OTA_Version_Request packet
|
||
err = errSendMeshPacket(pMeshReceiverAddr, &packet);
|
||
return err;
|
||
}
|
||
|
||
esp_err_t errOTAMeshTransmit(mesh_addr_t* pMeshNodeAddr)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
const esp_partition_t* pBootPartition; //pointer to boot partition (that will booted after reset)
|
||
MESH_PACKET_t sMeshPacket; //packet for sending and receiving
|
||
uint32_t u32Index = 0U; //index for partition read offset
|
||
bool bAbort = false; //abort the OTA process
|
||
bool bNodeIsResponding = false; //remote node is still active
|
||
uint32_t u32OTABytesWritten = 0U;
|
||
|
||
pBootPartition = esp_ota_get_boot_partition(); //get boot partition (that will booted after reset), not the running partition
|
||
|
||
//loop through partition to read in segmensts until end or error or abort called
|
||
while( ((OTA_MESH_SEGMENT_SIZE * u32Index) < pBootPartition->size) && (err == ESP_OK) && (bAbort == false))
|
||
{
|
||
bNodeIsResponding = false; //reset to default
|
||
|
||
// read partition with offset based in index
|
||
ERROR_CHECK(esp_partition_read(pBootPartition, (OTA_MESH_SEGMENT_SIZE * u32Index), sMeshPacket.au8Payload, OTA_MESH_SEGMENT_SIZE));
|
||
u32OTABytesWritten = ((u32Index+1) * OTA_MESH_SEGMENT_SIZE);
|
||
vPrintOTAProgress(&(pBootPartition->size), &u32OTABytesWritten, Transmitter);
|
||
|
||
if(err == ESP_OK)
|
||
{
|
||
//no error while read --> send OTA_DATA packet
|
||
sMeshPacket.type = OTA_Data;
|
||
|
||
if((OTA_MESH_SEGMENT_SIZE * (u32Index+1)) >= pBootPartition->size) //check if last segment
|
||
{
|
||
//last partition image segment --> send OTA_Complete
|
||
sMeshPacket.type = OTA_Complete;
|
||
}
|
||
|
||
err = errSendMeshPacket(pMeshNodeAddr, &sMeshPacket);
|
||
}
|
||
else
|
||
{
|
||
// error while read --> send OTA_ABORT and abort this OTA process
|
||
sMeshPacket.type = OTA_Abort;
|
||
bAbort = true;
|
||
errSendMeshPacket(pMeshNodeAddr, &sMeshPacket);
|
||
}
|
||
|
||
// loop through all OTA messages or until abort is called or error
|
||
for (uint32_t u32Index = 0; ((u32Index < QUEUE_MESSAGE_OTA_SIZE) && (bAbort == false) && (err == ESP_OK)); u32Index++) //loop through all OTA messages
|
||
{
|
||
if(uxQueueSpacesAvailable(queueMessageOTA) < QUEUE_MESSAGE_OTA_SIZE)
|
||
{
|
||
//queue not empty
|
||
if (xQueueReceive(queueMessageOTA, &sMeshPacket, ((3000) / portTICK_PERIOD_MS)) != pdTRUE)
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to receive OTA Messages from queue");
|
||
err = ESP_FAIL;
|
||
}
|
||
|
||
if((err == ESP_OK) && (bCheckMACEquality(sMeshPacket.meshSenderAddr.addr, pMeshNodeAddr->addr))) //if OTA_Version_Request
|
||
{
|
||
//packet from node received
|
||
switch (sMeshPacket.type)
|
||
{
|
||
case OTA_ACK: //increase index for next round
|
||
u32Index++;
|
||
bNodeIsResponding = true;
|
||
break;
|
||
case OTA_Abort: //abort this OTA process
|
||
bAbort = true;
|
||
bNodeIsResponding = true;
|
||
break;
|
||
default:
|
||
//receives wrong OTA message type from node --> back to queue
|
||
vAddOTAControllMessageToQueue(&sMeshPacket);
|
||
break;
|
||
}
|
||
}
|
||
else if (err == ESP_OK)
|
||
{
|
||
//received from wrong node --> back to queue
|
||
vAddOTAControllMessageToQueue(&sMeshPacket);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// OTA Message queue is empty --> wait some time
|
||
vTaskDelay( (1000/QUEUE_MESSAGE_OTA_SIZE) / portTICK_PERIOD_MS);
|
||
}
|
||
|
||
}//end OTA message loop
|
||
|
||
if(bNodeIsResponding == false)
|
||
{
|
||
//no abort was called but node didn’t responded
|
||
bAbort = true;
|
||
err = ESP_FAIL; //this OTA process failed with error
|
||
}
|
||
}//end of partition segment loop
|
||
return err;
|
||
}
|
||
|
||
esp_err_t errOTAMeshReceive(bool* pbNewOTAImage, mesh_addr_t* pMeshNodeAddr)
|
||
{
|
||
esp_err_t err = ESP_OK;
|
||
MESH_PACKET_t sMeshPacket; //packet for sending and receiving
|
||
bool bComplete = false; //complete the OTA process
|
||
bool bAbort = false; //abort the OTA process
|
||
bool bNodeIsResponding = false; //remote node is still active
|
||
uint32_t u32OTABytesWritten = 0U; //counter unsed for progress log
|
||
static esp_ota_handle_t otaHandle; //OTA process handle
|
||
*pbNewOTAImage = false;
|
||
|
||
ERROR_CHECK(esp_ota_begin(pOTAPartition, OTA_SIZE_UNKNOWN, &otaHandle)); //start ota update process
|
||
|
||
//partition segement loop through partition to read in segmensts until end or error or abort called
|
||
while((bComplete == false) && (err == ESP_OK) && (bAbort == false) && (u32OTABytesWritten <= pOTAPartition->size))
|
||
{
|
||
bNodeIsResponding = false; //reset to default
|
||
|
||
// loop through all OTA messages or until abort is called
|
||
for (uint32_t u32Index = 0; ((u32Index < QUEUE_MESSAGE_OTA_SIZE) && (bAbort == false)); u32Index++) //loop through all OTA messages
|
||
{
|
||
if(uxQueueSpacesAvailable(queueMessageOTA) < QUEUE_MESSAGE_OTA_SIZE)
|
||
{
|
||
//queue not empty
|
||
if (xQueueReceive(queueMessageOTA, &sMeshPacket, ((3000) / portTICK_PERIOD_MS)) != pdTRUE)
|
||
{
|
||
ESP_LOGE(LOG_TAG, "Unable to receive OTA Messages from queue");
|
||
err = ESP_FAIL;
|
||
}
|
||
|
||
if((err == ESP_OK) && (bCheckMACEquality(sMeshPacket.meshSenderAddr.addr, pMeshNodeAddr->addr))) //if OTA_Version_Request
|
||
{
|
||
//packet from node received
|
||
switch (sMeshPacket.type)
|
||
{
|
||
case OTA_Complete: //signal end of this OTA process, fall through because same behavior as OTA_Data
|
||
bComplete = true;
|
||
//fall through
|
||
case OTA_Data: //data segement received
|
||
bNodeIsResponding = true;
|
||
ERROR_CHECK(esp_ota_write(otaHandle, sMeshPacket.au8Payload, OTA_MESH_SEGMENT_SIZE));
|
||
u32OTABytesWritten = ((u32Index+1) * OTA_MESH_SEGMENT_SIZE);
|
||
vPrintOTAProgress(&(pOTAPartition->size), &u32OTABytesWritten, Receiver);
|
||
break;
|
||
case OTA_Abort: //abort this OTA process
|
||
bAbort = true;
|
||
bNodeIsResponding = true;
|
||
break;
|
||
default:
|
||
//receives wrong OTA message type from node --> back to queue
|
||
vAddOTAControllMessageToQueue(&sMeshPacket);
|
||
break;
|
||
}
|
||
}
|
||
else if (err == ESP_OK)
|
||
{
|
||
//received from wrong node --> back to queue
|
||
vAddOTAControllMessageToQueue(&sMeshPacket);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// OTA Message queue is empty --> wait some time
|
||
vTaskDelay( (1000/QUEUE_MESSAGE_OTA_SIZE) / portTICK_PERIOD_MS);
|
||
}
|
||
|
||
}//end of OTA message loop
|
||
|
||
if(bNodeIsResponding == false)
|
||
{
|
||
//no abort was called but node didn’t responded --> error
|
||
bAbort = true; //this will stop the partition segement loop
|
||
err = ESP_FAIL; //this OTA process failed with error
|
||
}
|
||
else
|
||
{
|
||
//node has responded with OTA_DATA or OTA_Complete or OTA_ABORT
|
||
if(err == ESP_OK)
|
||
{
|
||
|
||
if(bAbort == false)
|
||
{
|
||
//no error while ota write --> send OTA_ACK packet
|
||
sMeshPacket.type = OTA_ACK;
|
||
err = errSendMeshPacket(pMeshNodeAddr, &sMeshPacket);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// error while read --> send OTA_ABORT and abort this OTA process
|
||
sMeshPacket.type = OTA_Abort;
|
||
bAbort = true;
|
||
errSendMeshPacket(pMeshNodeAddr, &sMeshPacket);
|
||
}
|
||
}
|
||
}//end of partition segement loop
|
||
|
||
if(bComplete == true)
|
||
{
|
||
//all OTA segments received --> validate
|
||
ERROR_CHECK(esp_ota_end(otaHandle));
|
||
ERROR_CHECK(esp_ota_set_boot_partition(pOTAPartition));
|
||
if(err == ESP_OK)
|
||
{
|
||
//successfully updated OTA partition
|
||
*pbNewOTAImage = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//not all OTA segments received --> abort this OTA process
|
||
ERROR_CHECK(esp_ota_abort(otaHandle));
|
||
}
|
||
return err;
|
||
}
|