2021-01-20 20:55:33 +01:00
# include "Mesh_OTA_Util.h"
# include "Mesh_OTA_Globals.h"
static const char * LOG_TAG = " mesh_ota " ;
2021-01-20 21:40:51 +01:00
bool bMeshOtaUtilNewerVersion ( const char * pu8Local , const char * pu8Remote )
2021-01-20 20:55:33 +01:00
{
/*
* 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 ;
}
2021-01-20 21:40:51 +01:00
esp_err_t errMeshOtaUtilExtractVersionNumber ( 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 = errMeshOtaUtilFindImageStart ( 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 errMeshOtaUtilFindImageStart ( const char * pu8Data , uint32_t * pu32DataLenght , uint32_t * pu32StartOffset )
2021-01-20 20:55:33 +01:00
{
/*
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 ;
}
2021-01-20 21:40:51 +01:00
esp_err_t errMeshOtaUtilSendOTAVersionRequest ( mesh_addr_t * pMeshReceiverAddr )
2021-01-20 20:55:33 +01:00
{
esp_err_t err = ESP_OK ;
2021-01-20 21:40:51 +01:00
MESH_PACKET_t packet ;
packet . type = OTA_Version_Request ;
2021-01-20 20:55:33 +01:00
2021-01-20 21:40:51 +01:00
const esp_partition_t * pBootPartition ; //pointer to boot partition (that will booted after reset)
esp_app_desc_t bootPartitionDesc ; //Metadata from boot partition
2021-01-20 20:55:33 +01:00
2021-01-20 21:40:51 +01:00
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 ( pMeshReceiverAddr , & packet ) ;
2021-01-20 20:55:33 +01:00
return err ;
}
2021-01-20 21:40:51 +01:00
esp_err_t errMeshOtaUtilSendOTAVersionResponse ( 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
ESP_LOGI ( LOG_TAG , " Send OTA_Version_Response to 0x%x " , pMeshReceiverAddr - > addr [ 5 ] ) ;
err = errMeshNetworkSendMeshPacket ( pMeshReceiverAddr , & packet ) ;
return err ;
}
void vMeshOtaUtilPrintOTAProgress ( const uint32_t * const pu32TotalImageSize , const uint32_t * const pu32BytesWritten , OTA_MESH_ROLE_t eRole )
2021-01-20 20:55:33 +01:00
{
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 ;
}
}
2021-01-20 21:40:51 +01:00
void vMeshOtaUtilAddAllNeighboursToQueue ( void )
2021-01-20 20:55:33 +01:00
{
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
2021-01-20 21:40:51 +01:00
err = errMeshNetworkGetParentNode ( & addrParent ) ;
2021-01-20 20:55:33 +01:00
if ( err = = ESP_OK )
{
2021-01-20 21:40:51 +01:00
vMeshOtaUtilAddNodeToPossibleUpdatableQueue ( addrParent . addr ) ;
2021-01-20 20:55:33 +01:00
ESP_LOGI ( LOG_TAG , " added parent " ) ;
}
err = ESP_OK ; //reset error code
2021-01-20 21:40:51 +01:00
ERROR_CHECK ( errMeshNetworkGetChildren ( childrenAddr , & u16ChildrenSize ) ) ; //get all children
2021-01-20 20:55:33 +01:00
for ( uint16_t u16Index = 0 ; ( ( u16Index < u16ChildrenSize ) & & ( err = = ESP_OK ) ) ; u16Index + + )
{
2021-01-20 21:40:51 +01:00
vMeshOtaUtilAddNodeToPossibleUpdatableQueue ( childrenAddr [ u16Index ] . addr ) ;
2021-01-20 20:55:33 +01:00
ESP_LOGI ( LOG_TAG , " added child " ) ;
}
}
2021-01-20 21:40:51 +01:00
void vMeshOtaUtilClearOtaMessageQueue ( mesh_addr_t * pMeshNodeAddr )
2021-01-20 20:55:33 +01:00
{
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 )
{
2021-01-20 21:40:51 +01:00
if ( ! ( bMeshNetworkCheckMACEquality ( sMeshPacket . meshSenderAddr . addr , pMeshNodeAddr - > addr ) ) )
2021-01-20 20:55:33 +01:00
{
//received OTA message is NOT from pMeshNodeAddr --> keep it in queue
2021-01-20 21:40:51 +01:00
vMeshOtaUtilAddOtaMessageToQueue ( & sMeshPacket ) ;
2021-01-20 20:55:33 +01:00
}
else
{
ESP_LOGI ( LOG_TAG , " Removed type %i from node 0x%x " , sMeshPacket . type , pMeshNodeAddr - > addr [ 5 ] ) ;
}
}
} //end OTA message loop
}
2021-01-20 21:40:51 +01:00
void vMeshOtaUtilAddNodeToPossibleUpdatableQueue ( uint8_t * pu8MAC )
2021-01-20 20:55:33 +01:00
{
2021-01-20 21:40:51 +01:00
//send payload to node queues
mesh_addr_t addrNode ;
memcpy ( & addrNode . addr , ( uint8_t * ) pu8MAC , 6 ) ; //copy MAC
2021-01-20 20:55:33 +01:00
2021-01-20 21:40:51 +01:00
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 ] ) ;
}
}
2021-01-20 20:55:33 +01:00
2021-01-20 21:40:51 +01:00
void vMeshOtaUtilAddOtaMessageToQueue ( 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
{
switch ( puMeshPacket - > type )
{
case OTA_Abort :
ESP_LOGI ( LOG_TAG , " added ota message to queue: OTA_Abort from 0x%x " , puMeshPacket - > meshSenderAddr . addr [ 5 ] ) ;
break ;
case OTA_Version_Request :
ESP_LOGI ( LOG_TAG , " added ota message to queue: OTA_Version_Request from 0x%x " , puMeshPacket - > meshSenderAddr . addr [ 5 ] ) ;
break ;
case OTA_Version_Response :
ESP_LOGI ( LOG_TAG , " added ota message to queue: OTA_Version Response from 0x%x " , puMeshPacket - > meshSenderAddr . addr [ 5 ] ) ;
break ;
default :
break ;
}
}
2021-01-20 20:55:33 +01:00
}
2021-01-20 21:40:51 +01:00
void vMeshOtaUtilChangeStateOfServerWorker ( 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 ;
}
}