486 lines
17 KiB
C
486 lines
17 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
|
|
|
|
const esp_partition_t* pOTAPartition; //pointer to ota partition
|
|
|
|
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)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
esp_err_t err;
|
|
bool bNewOTAImage = false; // true if a new ota image was downloaded and validated
|
|
bool bFirstRun = true;
|
|
|
|
while(true)
|
|
{
|
|
err = ESP_OK;
|
|
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
|
|
{
|
|
if(bFirstRun == true)
|
|
{
|
|
ERROR_CHECK(https_clientInitialize());
|
|
bFirstRun = false;
|
|
}
|
|
|
|
ERROR_CHECK(https_clientConnectToServer());
|
|
ERROR_CHECK(https_clientValidateServer());
|
|
ERROR_CHECK(https_clientSendRequest());
|
|
|
|
ERROR_CHECK(errOTAHTTPS(&bNewOTAImage));
|
|
https_clientReset();
|
|
|
|
if(bNewOTAImage == true)
|
|
{
|
|
//set want reboot
|
|
ESP_LOGI(LOG_TAG, "Updated successfully via HTTPS, will reboot if possible");
|
|
}
|
|
|
|
|
|
|
|
vTaskDelay( (SERVER_CHECK_INTERVAL*1000) / portTICK_PERIOD_MS); //sleep till next server check
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
|
|
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
|
|
|
|
ERROR_CHECK(https_clientRetrieveData(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
|
|
{
|
|
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
|
|
|
|
//TODO lock ota mutex
|
|
|
|
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 https download");
|
|
do
|
|
{
|
|
//TODO progress log
|
|
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(https_clientRetrieveData(u8OTABuffer, &u32BufferLenght, &u32BytesRead)); //download next data segment
|
|
}
|
|
}
|
|
while ((u32BytesRead > 0) && (err == ESP_OK)); //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
|
|
}
|
|
//TODO unlock ota mutex
|
|
} //end newer version on server
|
|
} //end version number extracted
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Return true if remote version is newer (higher) than local version
|
|
*/
|
|
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
|
|
bool bReturn = false; //flag to stop loop
|
|
uint8_t u8Index = 0; //numbers counter in version string
|
|
|
|
strcpy(u8LocalTmp, pu8Local); //copy in tmp
|
|
strcpy(u8RemoteTmp, pu8Remote); //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;
|
|
}
|
|
|
|
/*
|
|
esp_err_t esp_mesh_ota_send(mesh_addr_t* dest)
|
|
{
|
|
esp_err_t err = ESP_OK;
|
|
|
|
static uint32_t u32index;
|
|
|
|
const esp_partition_t * pBootPartition = esp_ota_get_boot_partition();
|
|
|
|
if((*pBootPartition).subtype == 0)
|
|
{
|
|
|
|
int data_read = 0;
|
|
|
|
struct ota_mesh_packet packet;
|
|
packet.type=OTA_Data;
|
|
|
|
if(u32index == 1024)
|
|
{
|
|
//all data read
|
|
data_read = 0;
|
|
u32index = 0;
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(MESH_TAG, "OTA-Data read: %i", u32index);
|
|
err = esp_partition_read(pBootPartition, (1024*u32index), packet.au8Payload, 1024 );
|
|
ESP_ERROR_CHECK(err);
|
|
data_read = 1024;
|
|
u32index++;
|
|
}
|
|
|
|
if (data_read > 0)
|
|
{
|
|
//send ota fragemnt to node
|
|
esp_mesh_send_packet(dest, &packet);
|
|
}
|
|
|
|
ESP_ERROR_CHECK(err);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(MESH_TAG, "Subtype: %d", (*pBootPartition).subtype);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
esp_err_t esp_mesh_ota_receive(mesh_addr_t* dest, struct ota_mesh_packet* packet)
|
|
{
|
|
esp_err_t err = ESP_OK;
|
|
static esp_ota_handle_t otaHandle;
|
|
static uint32_t u32index;
|
|
|
|
const esp_partition_t * pBootPartition = esp_ota_get_boot_partition();
|
|
const esp_partition_t * pOTAPartition = esp_ota_get_next_update_partition(pBootPartition);
|
|
|
|
if(u32index == 0)
|
|
{
|
|
//first run
|
|
|
|
err = esp_ota_begin(pOTAPartition, OTA_SIZE_UNKNOWN, &otaHandle);
|
|
ESP_ERROR_CHECK(err);
|
|
}
|
|
|
|
ESP_LOGI(MESH_TAG, "OTA-Data write: %i", u32index);
|
|
err = esp_ota_write(otaHandle, packet->au8Payload, 1024);
|
|
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGE(MESH_TAG, "OTA-Data write error: %i at %i", err, u32index);
|
|
}
|
|
|
|
ESP_ERROR_CHECK(err);
|
|
|
|
|
|
|
|
if(u32index >= 1023)
|
|
{
|
|
//ota update complete
|
|
|
|
ESP_LOGI(MESH_TAG, "OTA-Data complete arrived: %i", u32index);
|
|
err = esp_ota_end(otaHandle);
|
|
ESP_ERROR_CHECK(err);
|
|
esp_app_desc_t otaPartitionDesc;
|
|
err = esp_ota_get_partition_description(pOTAPartition, &otaPartitionDesc);
|
|
ESP_ERROR_CHECK(err);
|
|
ESP_LOGI(MESH_TAG, "pOTAPartition project_name: %s", (otaPartitionDesc).project_name);
|
|
|
|
err = esp_ota_set_boot_partition(pOTAPartition);
|
|
ESP_ERROR_CHECK(err);
|
|
|
|
struct ota_mesh_packet retPacket;
|
|
retPacket.type=OTA_Complete;
|
|
ESP_ERROR_CHECK (esp_mesh_send_packet(dest, &retPacket)); //send back to parent
|
|
|
|
//check if this node has children --> Update them
|
|
|
|
esp_restart();
|
|
}
|
|
|
|
u32index++;
|
|
|
|
|
|
return err;
|
|
}
|
|
*/ |