localhorst
/
ESP32-Mesh-OTA
1
0
Fork 0
Code Issues Pull Requests Releases Activity

cleanup

This commit is contained in:
Hendrik Schutter 2021-01-09 17:41:40 +01:00
parent f1fb982e21
commit 0f38c893d9
9 changed files with 62 additions and 833 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
components/mesh_ota/https_client.c
View File

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

1
components/mesh_ota/include/https_client.h
View File

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

1
components/mesh_ota/include/mesh_ota.h
View File

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

83
components/mesh_ota/mesh_ota.c
View File

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

6
components/mesh_ota/test/test_image_hex.h
View File

@ -1,7 +1,6 @@
#ifndef H_TEST_IMAGE_HEX #ifndef H_TEST_IMAGE_HEX
#define H_TEST_IMAGE_HEX #define H_TEST_IMAGE_HEX
//with http response + 0.0.1 //with http response + 0.0.1
char dataWithHttpRespone0_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 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 //without http response + 0.0.1
char dataWithoutHttpRespone0_0_1[] = char dataWithoutHttpRespone0_0_1[] =
{ {
@ -80,7 +78,6 @@ char dataWithoutHttpRespone999_999_999[] =
}; };
//with http response + 999.999.999 //with http response + 999.999.999
char dataWithHttpRespone999_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, 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, 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 */ #endif /* H_TEST_IMAGE_HEX */

1
components/mesh_ota/test/test_mesh_ota.c
View File

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

87
main/main.c
View File

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

699
main/main.c.orig
View File

@ -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
View File

@ -32,7 +32,7 @@ CONFIG_APP_COMPILE_TIME_DATE=y
# CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set # CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set
# CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set # CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set
CONFIG_APP_PROJECT_VER_FROM_CONFIG=y 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 CONFIG_APP_RETRIEVE_LEN_ELF_SHA=16
# end of Application manager # end of Application manager