335 lines
13 KiB
C
335 lines
13 KiB
C
#include "Mesh_OTA_Util.h"
|
|
#include "Mesh_OTA_Globals.h"
|
|
|
|
static const char *LOG_TAG = "mesh_ota";
|
|
|
|
bool bMeshOtaUtilNewerVersion(const char* cpu8Local, const char* cpu8Remote)
|
|
{
|
|
/*
|
|
* 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, cpu8Local, 12); //copy in tmp
|
|
strncpy(u8RemoteTmp, cpu8Remote, 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 errMeshOtaUtilExtractVersionNumber(const char* cpu8Data, uint32_t* const cpcu32DataLenght, char* const pc8RemoteVersionNumber)
|
|
{
|
|
uint32_t u32StartOffset;
|
|
esp_err_t err = ESP_OK;
|
|
|
|
strcpy(pc8RemoteVersionNumber, "999.999.999"); //init value
|
|
err = errMeshOtaUtilFindImageStart(cpu8Data, cpcu32DataLenght, &u32StartOffset); //get image start offset
|
|
|
|
if(err == ESP_OK)
|
|
{
|
|
//image found
|
|
strncpy(pc8RemoteVersionNumber, cpu8Data+(u32StartOffset+48), 11); //copy version number
|
|
pc8RemoteVersionNumber[12] = '\0';
|
|
}
|
|
return err;
|
|
}
|
|
|
|
esp_err_t errMeshOtaUtilFindImageStart(const char* const cpu8Data, const uint32_t* const cpcu32DataLenght, uint32_t* const cpu32StartOffset)
|
|
{
|
|
/*
|
|
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;
|
|
|
|
*cpu32StartOffset = 0U; //reset offset to zero
|
|
|
|
while((u32DataIndex < *cpcu32DataLenght) && (bImageStartOffsetFound == false))
|
|
{
|
|
//search for magic byte
|
|
if(cpu8Data[u32DataIndex] == 0xe9)
|
|
{
|
|
//magic byte found
|
|
while ((u8FirstDotIndex < 3) && (u32FirstDotOffset == 0))
|
|
{
|
|
//search first dot in version number
|
|
if((u32DataIndex+49+u8FirstDotIndex) < *cpcu32DataLenght)
|
|
{
|
|
if((cpu8Data[(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)) < *cpcu32DataLenght)
|
|
{
|
|
if((cpu8Data[(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
|
|
*cpu32StartOffset = 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 errMeshOtaUtilSendOTAVersionRequest(const mesh_addr_t* const cpcMeshReceiverAddr)
|
|
{
|
|
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 = errMeshNetworkSendMeshPacket(cpcMeshReceiverAddr, &packet);
|
|
return err;
|
|
}
|
|
|
|
esp_err_t errMeshOtaUtilSendOTAVersionResponse(const mesh_addr_t* const cpcMeshReceiverAddr)
|
|
{
|
|
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
|
|
|
|
ESP_LOGI(LOG_TAG, "Send OTA_Version_Response to 0x%x", cpcMeshReceiverAddr->addr[5]);
|
|
|
|
err = errMeshNetworkSendMeshPacket(cpcMeshReceiverAddr, &packet);
|
|
return err;
|
|
}
|
|
|
|
void vMeshOtaUtilPrintOTAProgress(const uint32_t* const cpcu32TotalImageSize, const uint32_t* const cpcu32BytesWritten, const OTA_MESH_ROLE_t ceRole)
|
|
{
|
|
uint32_t u32Percentage = 0U;
|
|
static uint32_t u32LastPercentage = 0U;
|
|
|
|
if((*cpcu32BytesWritten) >= (*cpcu32TotalImageSize))
|
|
{
|
|
u32Percentage = 100;
|
|
}
|
|
else
|
|
{
|
|
u32Percentage = (uint32_t) (((float) (*cpcu32BytesWritten)/(float) (*cpcu32TotalImageSize)) * 100.0);
|
|
}
|
|
|
|
if((u32Percentage-u32LastPercentage) >= OTA_PROGRESS_LOG_INTERVAL)
|
|
{
|
|
if(ceRole == Transmitter)
|
|
{
|
|
ESP_LOGI(LOG_TAG, "Transmitting OTA update: %i %%", u32Percentage);
|
|
}
|
|
|
|
if(ceRole == Receiver)
|
|
{
|
|
ESP_LOGI(LOG_TAG, "Receiving OTA update: %i %%", u32Percentage);
|
|
}
|
|
|
|
|
|
|
|
u32LastPercentage = u32Percentage;
|
|
}
|
|
}
|
|
|
|
void vMeshOtaUtilAddAllNeighboursToQueue(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 = errMeshNetworkGetParentNode(&addrParent);
|
|
|
|
if(err == ESP_OK)
|
|
{
|
|
vMeshOtaUtilAddNodeToPossibleUpdatableQueue(addrParent.addr);
|
|
ESP_LOGI(LOG_TAG, "added parent");
|
|
}
|
|
|
|
err = ESP_OK; //reset error code
|
|
|
|
ERROR_CHECK(errMeshNetworkGetChildren(childrenAddr, &u16ChildrenSize)); //get all children
|
|
|
|
for (uint16_t u16Index = 0; ((u16Index < u16ChildrenSize) && (err == ESP_OK)); u16Index++)
|
|
{
|
|
vMeshOtaUtilAddNodeToPossibleUpdatableQueue(childrenAddr[u16Index].addr);
|
|
ESP_LOGI(LOG_TAG, "added child");
|
|
}
|
|
}
|
|
|
|
void vMeshOtaUtilClearOtaMessageQueue(const mesh_addr_t* const cpcMeshNodeAddr)
|
|
{
|
|
MESH_PACKET_t sMeshPacket; //packet for sending and receiving
|
|
for (uint32_t u32Index = 0; (u32Index < QUEUE_MESSAGE_OTA_SIZE); u32Index++) //loop through all OTA messages
|
|
{
|
|
if (xQueueReceive(queueMessageOTA, &sMeshPacket, 0) == pdTRUE)
|
|
{
|
|
if(!(bMeshNetworkCheckMACEquality(sMeshPacket.meshSenderAddr.addr, cpcMeshNodeAddr->addr)))
|
|
{
|
|
//received OTA message is NOT from cpcMeshNodeAddr --> keep it in queue
|
|
vMeshOtaUtilAddOtaMessageToQueue(&sMeshPacket);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(LOG_TAG, "Removed type %i from node 0x%x", sMeshPacket.type, cpcMeshNodeAddr->addr[5]);
|
|
}
|
|
}
|
|
}//end OTA message loop
|
|
}
|
|
|
|
void vMeshOtaUtilClearNeighboursQueue(const mesh_addr_t* const cpcMeshNodeAddr)
|
|
{
|
|
mesh_addr_t sNode; //packet for sending and receiving
|
|
for (uint32_t u32Index = 0; (u32Index < QUEUE_MESSAGE_OTA_SIZE); u32Index++) //loop through all OTA messages
|
|
{
|
|
if (xQueueReceive(queueNodes, &sNode, 0) == pdTRUE)
|
|
{
|
|
if(!(bMeshNetworkCheckMACEquality(sNode.addr, cpcMeshNodeAddr->addr)))
|
|
{
|
|
//node is NOT cpcMeshNodeAddr --> keep it in queue
|
|
vMeshOtaUtilAddNodeToPossibleUpdatableQueue(cpcMeshNodeAddr->addr);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(LOG_TAG, "Removed node 0x%x", cpcMeshNodeAddr->addr[5]);
|
|
}
|
|
}
|
|
}//end OTA message loop
|
|
}
|
|
|
|
|
|
void vMeshOtaUtilAddNodeToPossibleUpdatableQueue(const uint8_t* const cpcu8MAC)
|
|
{
|
|
//send payload to node queues
|
|
mesh_addr_t addrNode;
|
|
memcpy(&addrNode.addr, (uint8_t *)cpcu8MAC, 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 vMeshOtaUtilAddOtaMessageToQueue(const MESH_PACKET_t* const cpcuMeshPacket)
|
|
{
|
|
//send ota packet to packet queue
|
|
if (xQueueSend(queueMessageOTA, cpcuMeshPacket, portMAX_DELAY) != pdPASS)
|
|
{
|
|
ESP_LOGE(LOG_TAG, "Unable to push ota packet into packet queue");
|
|
}
|
|
else
|
|
{
|
|
switch (cpcuMeshPacket->type)
|
|
{
|
|
case OTA_Abort:
|
|
ESP_LOGI(LOG_TAG, "added ota message to queue: OTA_Abort from 0x%x", cpcuMeshPacket->meshSenderAddr.addr[5]);
|
|
break;
|
|
case OTA_Version_Request:
|
|
ESP_LOGI(LOG_TAG, "added ota message to queue: OTA_Version_Request from 0x%x", cpcuMeshPacket->meshSenderAddr.addr[5]);
|
|
break;
|
|
|
|
case OTA_Version_Response:
|
|
ESP_LOGI(LOG_TAG, "added ota message to queue: OTA_Version Response from 0x%x", cpcuMeshPacket->meshSenderAddr.addr[5]);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void vMeshOtaUtilChangeStateOfServerWorker(const bool cbState) //allow access via function ptn to network_handler
|
|
{
|
|
static bool bLastState = false;
|
|
|
|
if(cbState != bLastState) //change only if necessary
|
|
{
|
|
ESP_LOGI(LOG_TAG, "server worker change handler");
|
|
|
|
if(cbState == 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 = cbState;
|
|
}
|
|
}
|