Browse Source

cleanup

feature/ota_https
Hendrik Schutter 1 year ago
parent
commit
0f38c893d9
  1. 15
      components/mesh_ota/https_client.c
  2. 1
      components/mesh_ota/include/https_client.h
  3. 1
      components/mesh_ota/include/mesh_ota.h
  4. 83
      components/mesh_ota/mesh_ota.c
  5. 6
      components/mesh_ota/test/test_image_hex.h
  6. 1
      components/mesh_ota/test/test_mesh_ota.c
  7. 85
      main/main.c
  8. 699
      main/main.c.orig
  9. 2
      sdkconfig

15
components/mesh_ota/https_client.c

@ -61,10 +61,9 @@ https_client_ret_t https_clientInitialize()
break;
default:
i32RetHTTPClient = HTTPS_CLIENT_ERROR;
ESP_LOGE(TAG, "Unknown error while init");
ESP_LOGE(TAG, "Unknown error while init https client");
break;
}
return i32RetHTTPClient;
}
@ -72,8 +71,9 @@ https_client_ret_t https_clientRetrieveData(char* pu8Data, uint32_t* pu32DataLen
{
https_client_ret_t i32RetHTTPClient = HTTPS_CLIENT_OK;
int32_t i32RetRetrieveData = ESP_OK;
bzero(pu8Data, *pu32DataLenght);
bool bRetriveData = true;
bzero(pu8Data, *pu32DataLenght);
*pu32BytesRead = 0U;
while (bRetriveData)
@ -103,7 +103,6 @@ https_client_ret_t https_clientRetrieveData(char* pu8Data, uint32_t* pu32DataLen
//all data read --> stop reading
bRetriveData = false;
pu32BytesRead = 0;
}
if(i32RetRetrieveData == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY)
@ -120,15 +119,15 @@ https_client_ret_t https_clientDeinitialize()
{
https_client_ret_t i32RetHTTPClient = HTTPS_CLIENT_OK;
i32RetHTTPClient = mbedtls_ssl_close_notify(&sHTTPS_ClientConfig.ssl);
i32RetHTTPClient = mbedtls_ssl_close_notify(&sHTTPS_ClientConfig.ssl); //close session
if(i32RetHTTPClient != ESP_OK)
{
ESP_LOGE(TAG, "mbedtls_ssl_close_notify returned 0x%x", i32RetHTTPClient);
}
mbedtls_ssl_session_reset(&sHTTPS_ClientConfig.ssl);
mbedtls_net_free(&sHTTPS_ClientConfig.server_fd);
mbedtls_ssl_session_reset(&sHTTPS_ClientConfig.ssl); //reset embedssl
mbedtls_net_free(&sHTTPS_ClientConfig.server_fd); //free ram
return i32RetHTTPClient;
}
@ -267,7 +266,7 @@ https_client_ret_t https_clientSendRequest()
https_client_ret_t i32RetHTTPClient = HTTPS_CLIENT_OK;
int32_t i32RetSendRequest = ESP_OK;
uint32_t u32WrittenBytes = 0;
bool bWrite = true;
bool bWrite = true; //flag to stop loop
//Writing HTTP request
while((u32WrittenBytes < strlen(REQUEST)) && bWrite)

1
components/mesh_ota/include/https_client.h

@ -44,7 +44,6 @@
#define CONFIG_OTA_HTTPS_SERVER_COMMON_NAME "exmaple.com"
#endif
#define HTTPS_CLIENT_OK 0
#define HTTPS_CLIENT_ERROR -1
#define HTTPS_CLIENT_ERROR_INIT_EMBEDTLS -2

1
components/mesh_ota/include/mesh_ota.h

@ -16,7 +16,6 @@
#include "https_client.h"
bool bNewerVersion(const char* pu8Local, const char* pu8Remote);
esp_err_t errExtractVersionNumber(const char* pu8Data, uint32_t* pu32DataLenght, char* pc8RemoteVersionNumber);
esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint32_t* pu32StartOffset);

83
components/mesh_ota/mesh_ota.c

@ -1,43 +1,34 @@
#include "mesh_ota.h"
/*
* 999.999.999
* Return true if remote version is newer (higher) than local version
*/
bool bNewerVersion(const char* pu8Local, const char* pu8Remote) {
char u8LocalTmp[12];
char u8RemoteTmp[12];
char* pu8saveptrLocal;
char* pu8saveptrRemote;
strcpy(u8LocalTmp, pu8Local);
strcpy(u8RemoteTmp, pu8Remote);
char* pu8TokenLocal = strtok_r(u8LocalTmp, ".", &pu8saveptrLocal);
char* pu8TokenRemote = strtok_r(u8RemoteTmp, ".", &pu8saveptrRemote) ;
bool bReturn = false;
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
uint8_t u8Index = 0;
strcpy(u8LocalTmp, pu8Local); //copy in tmp
strcpy(u8RemoteTmp, pu8Remote); //copy in tmp
while( (u8Index <= 2) && (bReturn == false)) {
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;
bReturn = true; //version number difference --> stop loop
}
pu8TokenLocal = strtok_r(NULL, ".", &pu8saveptrLocal);
pu8TokenRemote = strtok_r(NULL, ".", &pu8saveptrRemote) ;
pu8TokenLocal = strtok_r(NULL, ".", &pu8saveptrLocal); //split tokens
pu8TokenRemote = strtok_r(NULL, ".", &pu8saveptrRemote); //split tokens
}
return bReturn;
}
@ -45,30 +36,26 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
{
/*
Offset value
0 = E9
0 = 0xE9 (first byte in image --> magic byte)
48 = first digit of version number
*/
esp_err_t errReturn = ESP_OK;
bool bImageStartOffsetFound = false;
*pu32StartOffset = 0U;
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
printf("\n magic byte found: %i\n", u32DataIndex);
while ((u8FirstDotIndex < 3) && (u32FirstDotOffset == 0))
{
//search first dot in version number
@ -76,9 +63,8 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
{
if((pu8Data[(u32DataIndex+49+u8FirstDotIndex)] == 0x2e))
{
//first do found
//first dot found
u32FirstDotOffset = (u32DataIndex+49+u8FirstDotIndex);
//printf("First dot offset: %i\n", u32FirstDotOffset);
}
}
u8FirstDotIndex++;
@ -86,15 +72,13 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
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 do found
//second dot found
u32SecondDotOffset = (u32FirstDotOffset+(u8SecondDotIndex+2));
//printf("Second dot offset: %i\n", u32SecondDotOffset);
}
}
u8SecondDotIndex++;
@ -115,10 +99,7 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
u8SecondDotIndex = 0;
}
}
u32DataIndex++;
//putchar(pu8Data[i]);
//printf("%x ", pu8Data[u32DataIndex]);
}
if(bImageStartOffsetFound == false)
@ -131,25 +112,17 @@ esp_err_t errFindImageStart(const char* pu8Data, uint32_t* pu32DataLenght, uint3
esp_err_t errExtractVersionNumber(const char* pu8Data, uint32_t* pu32DataLenght, char* pc8RemoteVersionNumber)
{
strcpy(pc8RemoteVersionNumber, "999.999.999"); //init value
uint32_t u32StartOffset;
esp_err_t err = ESP_OK;
esp_err_t err = errFindImageStart(pu8Data, pu32DataLenght, &u32StartOffset);
strcpy(pc8RemoteVersionNumber, "999.999.999"); //init value
err = errFindImageStart(pu8Data, pu32DataLenght, &u32StartOffset); //get image start offset
if(err == ESP_OK)
{
printf("\nImage start found: %i\n", u32StartOffset);
strncpy(pc8RemoteVersionNumber, pu8Data+(u32StartOffset+48), 11);
pc8RemoteVersionNumber[12] = '\0';
printf("remote version number %s\n\n", pc8RemoteVersionNumber);
//image found
strncpy(pc8RemoteVersionNumber, pu8Data+(u32StartOffset+48), 11); //copy version number
pc8RemoteVersionNumber[12] = '\0';
}
return err;
}

6
components/mesh_ota/test/test_image_hex.h

@ -1,7 +1,6 @@
#ifndef H_TEST_IMAGE_HEX
#define H_TEST_IMAGE_HEX
//with http response + 0.0.1
char dataWithHttpRespone0_0_1[] =
{
@ -32,7 +31,6 @@ char dataWithHttpRespone0_0_1[] =
0x65, 0x2f, 0x68, 0x65, 0x6e, 0x64, 0x72, 0x69, 0x6b, 0x2f, 0x65, 0x73, 0x70, 0x2f, 0x65, 0x73, 0x70, 0x2d, 0x69, 0x64, 0x66, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74
};
//without http response + 0.0.1
char dataWithoutHttpRespone0_0_1[] =
{
@ -80,7 +78,6 @@ char dataWithoutHttpRespone999_999_999[] =
};
//with http response + 999.999.999
char dataWithHttpRespone999_999_999[] =
{
@ -170,6 +167,5 @@ char dataWithHttpRespone999_99_999[] =
0x78, 0x5f, 0x75, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x0, 0x0, 0x0, 0x0, 0x70, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x0, 0x0, 0x74, 0x6c, 0x73, 0x20, 0x21, 0x3d, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x0, 0x2f,
0x68, 0x6f, 0x6d, 0x65, 0x2f, 0x68, 0x65, 0x6e, 0x64, 0x72, 0x69, 0x6b, 0x2f, 0x65, 0x73, 0x70, 0x2f, 0x65, 0x73, 0x70, 0x2d, 0x69, 0x64, 0x66, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
};
#endif /* H_TEST_IMAGE_HEX */

1
components/mesh_ota/test/test_mesh_ota.c

@ -2,7 +2,6 @@
#include "unity.h"
#include "mesh_ota.h"
#include "test_image_hex.h"
// ### ### ### distinguish newer image version ### ### ###

85
main/main.c

@ -13,7 +13,6 @@
#include "mesh_ota.h"
#define RX_SIZE (1234)
#define TX_SIZE (1234)
@ -491,9 +490,14 @@ static void test(void *pvParameters)
char buffer[1024U];
uint32_t u32BytesRead = 0;
char pcRemoteVersionNumber[12];
const esp_partition_t * currentPartition;
const esp_partition_t * otaPartition;
static esp_ota_handle_t otaHandle;
uint32_t u32StartOffset;
esp_app_desc_t otaPartitionDesc;
ESP_LOGI(MESH_TAG, "Hello World");
const esp_partition_t * currentPartition = esp_ota_get_boot_partition();
currentPartition = esp_ota_get_boot_partition();
ESP_LOGI(MESH_TAG, "Type: %d", (*currentPartition).subtype);
ESP_LOGI(MESH_TAG, "Start address: %d", (*currentPartition).address);
ESP_LOGI(MESH_TAG, "Size: %d", (*currentPartition).size);
@ -507,89 +511,49 @@ static void test(void *pvParameters)
ESP_LOGI(MESH_TAG, "currentPartition Timestamp: %s %s", (curPartitionDesc).date, (curPartitionDesc).time);
https_clientInitialize();
https_clientRetrieveData(buffer, &u32BufferLenght, &u32BytesRead);
ESP_LOGI(MESH_TAG, "Data received: %i", u32BytesRead);
err = errExtractVersionNumber(buffer, &u32BytesRead, pcRemoteVersionNumber);
if(err == ESP_OK)
{
if(bNewerVersion((curPartitionDesc).version, pcRemoteVersionNumber))
{
ESP_LOGI(MESH_TAG, "Newer Version available");
ESP_LOGI(MESH_TAG, "Newer Version available");
//write ota
const esp_partition_t * currentPartition = esp_ota_get_boot_partition();
const esp_partition_t * otaPartition = esp_ota_get_next_update_partition(currentPartition);
static esp_ota_handle_t otaHandle;
uint32_t u32StartOffset = 305; //TODO fix this
/*
//esp_err_t err = errFindImageStart(pu8Data, pu32DataLenght, &u32StartOffset);
esp_err_t err = errFindImageStart(buffer, &u32BufferLenght, &u32StartOffset);
if(err != ESP_OK)
{
ESP_LOGI(MESH_TAG, "errFindImageStart failed: %i", err);
}
*/
otaPartition= esp_ota_get_next_update_partition(currentPartition);
err = errFindImageStart(buffer, &u32BufferLenght, &u32StartOffset);
ESP_LOGI(MESH_TAG, "first byte offset: %i", u32StartOffset);
ESP_LOGI(MESH_TAG, "first byte: %x", buffer[u32StartOffset]);
err = esp_ota_begin(otaPartition, OTA_SIZE_UNKNOWN, &otaHandle);
ESP_ERROR_CHECK(err);
/*
bool stop = false;
while(stop == false)
{
ESP_ERROR_CHECK(err);
do
{
ESP_LOGI(MESH_TAG, "OTA-Data written: %i", u32BytesRead);
err = esp_ota_write(otaHandle, (const void*) buffer+u32StartOffset, (u32BytesRead-u32StartOffset));
u32StartOffset = 0U;
https_clientRetrieveData(buffer, &u32BufferLenght, &u32BytesRead);
ESP_LOGI(MESH_TAG, "OTA-Data written: %i", u32BytesRead);
if(u32BytesRead == 0)
{
stop = true;
}
}
ESP_LOGI(MESH_TAG, "END");
*/
do {
ESP_LOGI(MESH_TAG, "OTA-Data written: %i", u32BytesRead);
err = esp_ota_write(otaHandle, (const void*) buffer+u32StartOffset, (u32BytesRead-u32StartOffset));
u32StartOffset = 0U;
https_clientRetrieveData(buffer, &u32BufferLenght, &u32BytesRead);
} while (u32BytesRead > 0);
while (u32BytesRead > 0);
err = esp_ota_end(otaHandle);
ESP_ERROR_CHECK(err);
esp_app_desc_t otaPartitionDesc;
err = esp_ota_get_partition_description(otaPartition, &otaPartitionDesc);
ESP_ERROR_CHECK(err);
ESP_LOGI(MESH_TAG, "otaPartition project_name: %s", (otaPartitionDesc).project_name);
err = esp_ota_set_boot_partition(otaPartition);
ESP_ERROR_CHECK(err);
//esp_restart();
}
else
{
ESP_LOGI(MESH_TAG, "NO newer Version available");
}
}
else
{
@ -598,6 +562,7 @@ static void test(void *pvParameters)
https_clientDeinitialize();
ESP_LOGI(MESH_TAG, "\nend of task\n");
while(1)
{
vTaskDelay(1000 / portTICK_PERIOD_MS);
@ -607,7 +572,7 @@ static void test(void *pvParameters)
void app_main(void)
{
ESP_LOGI(MESH_TAG, "hardcoded: 0.0.1");
/*
err = nvs_flash_erase();
if(err != ESP_OK){
@ -682,16 +647,14 @@ void app_main(void)
esp_mesh_is_root_fixed() ? "root fixed" : "root not fixed",
esp_mesh_get_topology(), esp_mesh_get_topology() ? "(chain)":"(tree)", esp_mesh_is_ps_enabled());
for(;;) {
for(;;)
{
if(gpio_get_level(0) == 0){
break;
}
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
xTaskCreate(&test, "test_task", 8192, NULL, 5, NULL);
}

699
main/main.c.orig

@ -1,699 +0,0 @@
#include <string.h>
#include "esp_wifi.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mesh.h"
#include "esp_mesh_internal.h"
#include "nvs_flash.h"
#include "driver/gpio.h"
#include "esp_ota_ops.h"
#include "esp_partition.h"
#include "mesh_ota.h"
#define RX_SIZE (1234)
#define TX_SIZE (1234)
static const char *MESH_TAG = "mesh_main";
static const uint8_t MESH_ID[6] = { 0x77, 0x77, 0x77, 0x77, 0x77, 0x77};
static uint8_t tx_buf[TX_SIZE] = { 0, };
static uint8_t rx_buf[RX_SIZE] = { 0, };
static bool is_mesh_connected = false;
static mesh_addr_t mesh_parent_addr;
static uint8_t ownMAC[6];
static int mesh_layer = -1;
static esp_netif_t *netif_sta = NULL;
struct ota_mesh_packet
{
enum ota_mesh_packet_type
{
APP_Version_Request,
APP_Version_Response,
OTA_Data,
OTA_ACK,
OTA_Complete
} type;
uint8_t au8Payload[1024];
};
/*******************************************************
* Function Declarations
*******************************************************/
esp_err_t esp_mesh_send_packet(mesh_addr_t* dest, struct ota_mesh_packet* packet);
/*******************************************************
* Function Definitions
*******************************************************/
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 * currentPartition = esp_ota_get_boot_partition();
if((*currentPartition).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(currentPartition, (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", (*currentPartition).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 * currentPartition = esp_ota_get_boot_partition();
const esp_partition_t * otaPartition = esp_ota_get_next_update_partition(currentPartition);
if(u32index == 0)
{
//first run
err = esp_ota_begin(otaPartition, 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(otaPartition, &otaPartitionDesc);
ESP_ERROR_CHECK(err);
ESP_LOGI(MESH_TAG, "otaPartition project_name: %s", (otaPartitionDesc).project_name);
err = esp_ota_set_boot_partition(otaPartition);
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;
}
//returns true if MAC address is equal
bool esp_mesh_check_MAC_Equality(uint8_t* aMAC, uint8_t* bMAC)
{
for (uint8_t index = 0; index < 6; index++)
{
if(aMAC[index] != bMAC[index])
{
return false;
}
}
return true;
}
esp_err_t esp_mesh_get_Children(mesh_addr_t children[], uint16_t* pu16ChildrenSize)
{
*pu16ChildrenSize = 0;
mesh_addr_t route_table[CONFIG_MESH_ROUTE_TABLE_SIZE];
int route_table_size = 0;
esp_mesh_get_routing_table((mesh_addr_t *) &route_table, CONFIG_MESH_ROUTE_TABLE_SIZE * 6, &route_table_size);
for(uint16_t index = 0; index < esp_mesh_get_routing_table_size(); index++)
{
if(! (esp_mesh_check_MAC_Equality(ownMAC, route_table[index].addr)) )
{
//child node
// ESP_LOGI(MESH_TAG, "adding Node: \"0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\" ", route_table[index].addr[0], route_table[index].addr[1], route_table[index].addr[2], route_table[index].addr[3], route_table[index].addr[4], route_table[index].addr[5]);
children[*pu16ChildrenSize] = route_table[index];
*pu16ChildrenSize = (*pu16ChildrenSize)+1;
}
}
return ESP_OK;
}
esp_err_t esp_mesh_send_packet(mesh_addr_t* dest, struct ota_mesh_packet* packet)
{
esp_err_t err;
mesh_data_t data;
data.data = tx_buf;
data.size = sizeof(tx_buf);
data.proto = MESH_PROTO_BIN;
data.tos = MESH_TOS_P2P;
memcpy(tx_buf, (uint8_t *)packet, sizeof(struct ota_mesh_packet));
err = esp_mesh_send(dest, &data, MESH_DATA_P2P, NULL, 0);
return err;
}
void esp_mesh_p2p_rx_main(void *arg)
{
esp_err_t err;
mesh_addr_t from;
mesh_data_t data;
int flag = 0;
data.data = rx_buf;
data.size = RX_SIZE;
while (true)
{
data.size = RX_SIZE;
err = esp_mesh_recv(&from, &data, portMAX_DELAY, &flag, NULL, 0);
if (err != ESP_OK || !data.size)
{
ESP_LOGE(MESH_TAG, "err:0x%x, size:%d", err, data.size);
continue;
}
struct ota_mesh_packet packet;
memcpy(&packet, (uint8_t *)rx_buf, sizeof(struct ota_mesh_packet));
switch (packet.type)
{
case APP_Version_Request:
ESP_LOGI(MESH_TAG, "recv: APP_Version_Request");
packet.type=APP_Version_Response;
packet.au8Payload[0] = 42; //TODO get current running version
ESP_ERROR_CHECK (esp_mesh_send_packet(&from, &packet)); //send back to parent
break;
case APP_Version_Response:
ESP_LOGI(MESH_TAG, "recv: APP_Version_Response - App Version %i: ", packet.au8Payload[0]);
//check if node is out-dated
esp_mesh_ota_send(&from);
break;
case OTA_Data:
ESP_LOGI(MESH_TAG, "recv: OTA_Data");
esp_mesh_ota_receive(&from, &packet);
packet.type=OTA_ACK;
ESP_ERROR_CHECK (esp_mesh_send_packet(&from, &packet)); //send back to parent
break;
case OTA_ACK:
ESP_LOGI(MESH_TAG, "recv: OTA_ACK");
esp_mesh_ota_send(&from);
break;
case OTA_Complete:
ESP_LOGI(MESH_TAG, "recv: OTA_Complete");
break;
default:
ESP_LOGE(MESH_TAG, "recv: something");
break;
}
} //end while
vTaskDelete(NULL);
}
esp_err_t esp_mesh_comm_p2p_start(void)
{
static bool is_comm_p2p_started = false;
if (!is_comm_p2p_started)
{
is_comm_p2p_started = true;
xTaskCreate(esp_mesh_p2p_rx_main, "MPRX", 7000, NULL, 5, NULL);
}
return ESP_OK;
}
void mesh_event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
{
mesh_addr_t id = {0,};
static uint16_t last_layer = 0;
switch (event_id)
{
case MESH_EVENT_STARTED:
{
esp_mesh_get_id(&id);
ESP_LOGI(MESH_TAG, "<MESH_EVENT_MESH_STARTED>ID:"MACSTR"", MAC2STR(id.addr));
is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_STOPPED: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOPPED>");
is_mesh_connected = false;
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_CHILD_CONNECTED: {
mesh_event_child_connected_t *child_connected = (mesh_event_child_connected_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_CONNECTED>aid:%d, "MACSTR"",
child_connected->aid,
MAC2STR(child_connected->mac));
}
break;
case MESH_EVENT_CHILD_DISCONNECTED: {
mesh_event_child_disconnected_t *child_disconnected = (mesh_event_child_disconnected_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, "MACSTR"",
child_disconnected->aid,
MAC2STR(child_disconnected->mac));
}
break;
case MESH_EVENT_ROUTING_TABLE_ADD: {
mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d, layer:%d",
routing_table->rt_size_change,
routing_table->rt_size_new, mesh_layer);
}
break;
case MESH_EVENT_ROUTING_TABLE_REMOVE: {
mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
ESP_LOGW(MESH_TAG, "<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d, layer:%d",
routing_table->rt_size_change,
routing_table->rt_size_new, mesh_layer);
}
break;
case MESH_EVENT_NO_PARENT_FOUND: {
mesh_event_no_parent_found_t *no_parent = (mesh_event_no_parent_found_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_NO_PARENT_FOUND>scan times:%d",
no_parent->scan_times);
}
/* TODO handler for the failure */
break;
case MESH_EVENT_PARENT_CONNECTED: {
mesh_event_connected_t *connected = (mesh_event_connected_t *)event_data;
esp_mesh_get_id(&id);
mesh_layer = connected->self_layer;
memcpy(&mesh_parent_addr.addr, connected->connected.bssid, 6);
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:"MACSTR"%s, ID:"MACSTR", duty:%d",
last_layer, mesh_layer, MAC2STR(mesh_parent_addr.addr),
esp_mesh_is_root() ? "<ROOT>" :
(mesh_layer == 2) ? "<layer2>" : "", MAC2STR(id.addr), connected->duty);
last_layer = mesh_layer;
// mesh_connected_indicator(mesh_layer);
is_mesh_connected = true;
if (esp_mesh_is_root()) {
esp_netif_dhcpc_start(netif_sta);
}
esp_mesh_comm_p2p_start();//start receiving
}
break;
case MESH_EVENT_PARENT_DISCONNECTED: {
mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)event_data;
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_PARENT_DISCONNECTED>reason:%d",
disconnected->reason);
is_mesh_connected = false;
// mesh_disconnected_indicator();
mesh_layer = esp_mesh_get_layer();
}
break;
case MESH_EVENT_LAYER_CHANGE: {
mesh_event_layer_change_t *layer_change = (mesh_event_layer_change_t *)event_data;
mesh_layer = layer_change->new_layer;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s",
last_layer, mesh_layer,
esp_mesh_is_root() ? "<ROOT>" :
(mesh_layer == 2) ? "<layer2>" : "");
last_layer = mesh_layer;
// mesh_connected_indicator(mesh_layer);
}
break;
case MESH_EVENT_ROOT_ADDRESS: {
mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_ADDRESS>root address:"MACSTR"",
MAC2STR(root_addr->addr));
}
break;
case MESH_EVENT_VOTE_STARTED: {
mesh_event_vote_started_t *vote_started = (mesh_event_vote_started_t *)event_data;
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:"MACSTR"",
vote_started->attempts,
vote_started->reason,
MAC2STR(vote_started->rc_addr.addr));
}
break;
case MESH_EVENT_VOTE_STOPPED: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_VOTE_STOPPED>");
break;
}
case MESH_EVENT_ROOT_SWITCH_REQ: {
mesh_event_root_switch_req_t *switch_req = (mesh_event_root_switch_req_t *)event_data;
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:"MACSTR"",
switch_req->reason,
MAC2STR( switch_req->rc_addr.addr));
}
break;
case MESH_EVENT_ROOT_SWITCH_ACK: {
/* new root */
mesh_layer = esp_mesh_get_layer();
esp_mesh_get_parent_bssid(&mesh_parent_addr);
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:"MACSTR"", mesh_layer, MAC2STR(mesh_parent_addr.addr));
}
break;
case MESH_EVENT_TODS_STATE: {
mesh_event_toDS_state_t *toDs_state = (mesh_event_toDS_state_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_TODS_REACHABLE>state:%d", *toDs_state);
}
break;
case MESH_EVENT_ROOT_FIXED: {
mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROOT_FIXED>%s",
root_fixed->is_fixed ? "fixed" : "not fixed");
}
break;
case MESH_EVENT_ROOT_ASKED_YIELD: {
mesh_event_root_conflict_t *root_conflict = (mesh_event_root_conflict_t *)event_data;
ESP_LOGI(MESH_TAG,
"<MESH_EVENT_ROOT_ASKED_YIELD>"MACSTR", rssi:%d, capacity:%d",
MAC2STR(root_conflict->addr),
root_conflict->rssi,
root_conflict->capacity);
}
break;
case MESH_EVENT_CHANNEL_SWITCH: {
mesh_event_channel_switch_t *channel_switch = (mesh_event_channel_switch_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_CHANNEL_SWITCH>new channel:%d", channel_switch->channel);
}
break;
case MESH_EVENT_SCAN_DONE: {
mesh_event_scan_done_t *scan_done = (mesh_event_scan_done_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_SCAN_DONE>number:%d",
scan_done->number);
}
break;
case MESH_EVENT_NETWORK_STATE: {
mesh_event_network_state_t *network_state = (mesh_event_network_state_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_NETWORK_STATE>is_rootless:%d",
network_state->is_rootless);
}
break;
case MESH_EVENT_STOP_RECONNECTION: {
ESP_LOGI(MESH_TAG, "<MESH_EVENT_STOP_RECONNECTION>");
}
break;
case MESH_EVENT_FIND_NETWORK: {
mesh_event_find_network_t *find_network = (mesh_event_find_network_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_FIND_NETWORK>new channel:%d, router BSSID:"MACSTR"",
find_network->channel, MAC2STR(find_network->router_bssid));
}
break;
case MESH_EVENT_ROUTER_SWITCH: {
mesh_event_router_switch_t *router_switch = (mesh_event_router_switch_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_ROUTER_SWITCH>new router:%s, channel:%d, "MACSTR"",
router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid));
}
break;
case MESH_EVENT_PS_PARENT_DUTY: {
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_PS_PARENT_DUTY>duty:%d", ps_duty->duty);
}
break;
case MESH_EVENT_PS_CHILD_DUTY: {
mesh_event_ps_duty_t *ps_duty = (mesh_event_ps_duty_t *)event_data;
ESP_LOGI(MESH_TAG, "<MESH_EVENT_PS_CHILD_DUTY>cidx:%d, "MACSTR", duty:%d", ps_duty->child_connected.aid-1,
MAC2STR(ps_duty->child_connected.mac), ps_duty->duty);
}
break;
default:
ESP_LOGI(MESH_TAG, "unknown id:%d", event_id);
break;
}
}
void ip_event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
{
ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
ESP_LOGI(MESH_TAG, "<IP_EVENT_STA_GOT_IP>IP:" IPSTR, IP2STR(&event->ip_info.ip));
}
static void test(void *pvParameters)
{
esp_err_t err;
uint32_t u32BufferLenght = 1024U;
char buffer[1024U];
uint32_t u32BytesRead = 0;
char pcRemoteVersionNumber[12];
ESP_LOGI(MESH_TAG, "Hello World");
const esp_partition_t * currentPartition = esp_ota_get_boot_partition();
ESP_LOGI(MESH_TAG, "Type: %d", (*currentPartition).subtype);
ESP_LOGI(MESH_TAG, "Start address: %d", (*currentPartition).address);
ESP_LOGI(MESH_TAG, "Size: %d", (*currentPartition).size);
ESP_LOGI(MESH_TAG, "Encrypted: %d", (*currentPartition).encrypted);
esp_app_desc_t curPartitionDesc;
err = esp_ota_get_partition_description(currentPartition, &curPartitionDesc);
ESP_ERROR_CHECK(err);
ESP_LOGI(MESH_TAG, "currentPartition project_name: %s", (curPartitionDesc).project_name);
ESP_LOGI(MESH_TAG, "currentPartition version: %s", (curPartitionDesc).version);
ESP_LOGI(MESH_TAG, "currentPartition Timestamp: %s %s", (curPartitionDesc).date, (curPartitionDesc).time);
https_clientInitialize();
https_clientRetrieveData(buffer, &u32BufferLenght, &u32BytesRead);
ESP_LOGI(MESH_TAG, "Data received: %i", u32BytesRead);
err = errExtractVersionNumber(buffer, &u32BytesRead, pcRemoteVersionNumber);
if(err == ESP_OK)
{
if(bNewerVersion((curPartitionDesc).version, pcRemoteVersionNumber))
{
ESP_LOGI(MESH_TAG, "Newer Version available");
//write ota
const esp_partition_t * currentPartition = esp_ota_get_boot_partition();
const esp_partition_t * otaPartition = esp_ota_get_next_update_partition(currentPartition);
static esp_ota_handle_t otaHandle;
uint32_t u32StartOffset = 305; //TODO fix this
/*
//esp_err_t err = errFindImageStart(pu8Data, pu32DataLenght, &u32StartOffset);
esp_err_t err = errFindImageStart(buffer, &u32BufferLenght, &u32StartOffset);
if(err != ESP_OK)
{
ESP_LOGI(MESH_TAG, "errFindImageStart failed: %i", err);
}
*/
ESP_LOGI(MESH_TAG, "first byte offset: %i", u32StartOffset);
ESP_LOGI(MESH_TAG, "first byte: %x", buffer[u32StartOffset]);
err = esp_ota_begin(otaPartition, OTA_SIZE_UNKNOWN, &otaHandle);
ESP_ERROR_CHECK(err);
bool stop = false;
while(stop == false )
{
https_clientRetrieveData(buffer, &u32BufferLenght, &u32BytesRead);
ESP_LOGI(MESH_TAG, "OTA-Data written: %i", u32BytesRead);
if(u32BytesRead == 0)
{
stop = true;
}
}
ESP_LOGI(MESH_TAG, "END");
/*
do {
ESP_LOGI(MESH_TAG, "OTA-Data written: %i", u32BytesRead);
err = esp_ota_write(otaHandle, (const void*) buffer+u32StartOffset, (u32BytesRead-u32StartOffset));
u32StartOffset = 0U;
https_clientRetrieveData(buffer, &u32BufferLenght, &u32BytesRead);
} while (u32BytesRead > 0);
err = esp_ota_end(otaHandle);
ESP_ERROR_CHECK(err);
esp_app_desc_t otaPartitionDesc;
err = esp_ota_get_partition_description(otaPartition, &otaPartitionDesc);
ESP_ERROR_CHECK(err);
ESP_LOGI(MESH_TAG, "otaPartition project_name: %s", (otaPartitionDesc).project_name);
err = esp_ota_set_boot_partition(otaPartition);
ESP_ERROR_CHECK(err);
//esp_restart();
*/
}
else
{
ESP_LOGI(MESH_TAG, "NO newer Version available");
}
}
else
{
ESP_LOGI(MESH_TAG, "errExtractVersionNumber failed: %i", err);
}
https_clientDeinitialize();
while(1)
{
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}
void app_main(void)
{
/*
err = nvs_flash_erase();
if(err != ESP_OK){
ESP_LOGI(MESH_TAG, "Error: %x", err);
while(1){
}
}
*/
ESP_ERROR_CHECK(nvs_flash_init());
/* tcpip initialization */
ESP_ERROR_CHECK(esp_netif_init());
/* event initialization */
ESP_ERROR_CHECK(esp_event_loop_create_default());
/* create network interfaces for mesh (only station instance saved for further manipulation, soft AP instance ignored */
ESP_ERROR_CHECK(esp_netif_create_default_wifi_mesh_netifs(&netif_sta, NULL));
/* wifi initialization */
wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&config));
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &ip_event_handler, NULL));
ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH));
ESP_ERROR_CHECK(esp_wifi_start());
/* mesh initialization */
ESP_ERROR_CHECK(esp_mesh_init());
ESP_ERROR_CHECK(esp_event_handler_register(MESH_EVENT, ESP_EVENT_ANY_ID, &mesh_event_handler, NULL));
/* set mesh topology */
ESP_ERROR_CHECK(esp_mesh_set_topology(CONFIG_MESH_TOPOLOGY));
/* set mesh max layer according to the topology */
ESP_ERROR_CHECK(esp_mesh_set_max_layer(CONFIG_MESH_MAX_LAYER));
ESP_ERROR_CHECK(esp_mesh_set_vote_percentage(1));
ESP_ERROR_CHECK(esp_mesh_set_xon_qsize(128));
/* Disable mesh PS function */
ESP_ERROR_CHECK(esp_mesh_disable_ps());
ESP_ERROR_CHECK(esp_mesh_set_ap_assoc_expire(10));
mesh_cfg_t cfg = MESH_INIT_CONFIG_DEFAULT();
/* mesh ID */
memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);
/* router */
cfg.channel = CONFIG_MESH_CHANNEL;
cfg.router.ssid_len = strlen(CONFIG_MESH_ROUTER_SSID);
memcpy((uint8_t *) &cfg.router.ssid, CONFIG_MESH_ROUTER_SSID, cfg.router.ssid_len);
memcpy((uint8_t *) &cfg.router.password, CONFIG_MESH_ROUTER_PASSWD,
strlen(CONFIG_MESH_ROUTER_PASSWD));
/* mesh softAP */
ESP_ERROR_CHECK(esp_mesh_set_ap_authmode(CONFIG_MESH_AP_AUTHMODE));
cfg.mesh_ap.max_connection = CONFIG_MESH_AP_CONNECTIONS;
memcpy((uint8_t *) &cfg.mesh_ap.password, CONFIG_MESH_AP_PASSWD,
strlen(CONFIG_MESH_AP_PASSWD));
ESP_ERROR_CHECK(esp_mesh_set_config(&cfg));
ESP_ERROR_CHECK(esp_base_mac_addr_get(ownMAC));
ESP_LOGI(MESH_TAG, "Own MAC: \"0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\" ", ownMAC[0], ownMAC[1], ownMAC[2], ownMAC[3], ownMAC[4], ownMAC[5]);
/* mesh start */
ESP_ERROR_CHECK(esp_mesh_start());
ESP_LOGI(MESH_TAG, "mesh starts successfully, heap:%d, %s<%d>%s, ps:%d\n", esp_get_minimum_free_heap_size(),
esp_mesh_is_root_fixed() ? "root fixed" : "root not fixed",
esp_mesh_get_topology(), esp_mesh_get_topology() ? "(chain)":"(tree)", esp_mesh_is_ps_enabled());
for(;;) {
if(gpio_get_level(0) == 0){
break;
}
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
xTaskCreate(&test, "test_task", 8192, NULL, 5, NULL);
}

2
sdkconfig

@ -32,7 +32,7 @@ CONFIG_APP_COMPILE_TIME_DATE=y
# CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set
# CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set
CONFIG_APP_PROJECT_VER_FROM_CONFIG=y
CONFIG_APP_PROJECT_VER="0.0.0"
CONFIG_APP_PROJECT_VER="0.0.1"
CONFIG_APP_RETRIEVE_LEN_ELF_SHA=16
# end of Application manager

Loading…
Cancel
Save

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