ESP32 OTA firmware updates via WiFi mesh network. https://hendrikschutter.com
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

701 lines
26 KiB

#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 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 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(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);
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)); //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
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
}
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
}
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; //Metadate from boot partition
*pbNewOTAImage = false; //set default false
//get node
//check if node is still connected
// --> send OTA_Version_Request
// --> read OTA_Version_Response (if from this node) (all other OTA message add again)
// --> this version older --> start OTA_Rx --> vAddAllNeighboursToQueue(); //add all existing neighbours to queues
// --> this version newer --> start OTA_Tx
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
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)
{
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)
{
ESP_LOGI(LOG_TAG, "OTA update progress: %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 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;
}
*/

Du besuchst diese Seite mit einem veralteten IPv4-Internetzugang. Möglicherweise treten in Zukunft Probleme mit der Erreichbarkeit und Performance auf. Bitte frage deinen Internetanbieter oder Netzwerkadministrator nach IPv6-Unterstützung.
You are visiting this site with an outdated IPv4 internet access. You may experience problems with accessibility and performance in the future. Please ask your ISP or network administrator for IPv6 support.
Weitere Infos | More Information
Klicke zum schließen | Click to close