2020-12-01 23:21:18 +01:00
# 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"
2021-01-02 00:30:13 +01:00
# include "mesh_ota.h"
2020-12-01 23:21:18 +01:00
# 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 ;
2021-01-06 18:10:12 +01:00
struct ota_mesh_packet
{
enum ota_mesh_packet_type
{
2020-12-01 23:21:18 +01:00
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 ( ) ;
2021-01-06 18:10:12 +01:00
if ( ( * currentPartition ) . subtype = = 0 )
2021-01-08 20:12:03 +01:00
{
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
int data_read = 0 ;
2021-01-06 18:10:12 +01:00
2021-01-08 20:12:03 +01:00
struct ota_mesh_packet packet ;
packet . type = OTA_Data ;
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
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 ) ;
2020-12-01 23:21:18 +01:00
ESP_ERROR_CHECK ( err ) ;
2021-01-08 20:12:03 +01:00
data_read = 1024 ;
u32index + + ;
2020-12-01 23:21:18 +01:00
}
2021-01-08 20:12:03 +01:00
if ( data_read > 0 )
2020-12-01 23:21:18 +01:00
{
2021-01-08 20:12:03 +01:00
//send ota fragemnt to node
esp_mesh_send_packet ( dest , & packet ) ;
2020-12-01 23:21:18 +01:00
}
2021-01-08 20:12:03 +01:00
ESP_ERROR_CHECK ( err ) ;
}
else
{
ESP_LOGI ( MESH_TAG , " Subtype: %d " , ( * currentPartition ) . subtype ) ;
}
2020-12-01 23:21:18 +01:00
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 )
2021-01-08 20:12:03 +01:00
{
//first run
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
err = esp_ota_begin ( otaPartition , OTA_SIZE_UNKNOWN , & otaHandle ) ;
ESP_ERROR_CHECK ( err ) ;
}
2020-12-01 23:21:18 +01:00
ESP_LOGI ( MESH_TAG , " OTA-Data write: %i " , u32index ) ;
err = esp_ota_write ( otaHandle , packet - > au8Payload , 1024 ) ;
if ( err ! = ESP_OK )
2021-01-08 20:12:03 +01:00
{
ESP_LOGE ( MESH_TAG , " OTA-Data write error: %i at %i " , err , u32index ) ;
}
2020-12-01 23:21:18 +01:00
ESP_ERROR_CHECK ( err ) ;
if ( u32index > = 1023 )
2021-01-08 20:12:03 +01:00
{
//ota update complete
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
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 ) ;
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
err = esp_ota_set_boot_partition ( otaPartition ) ;
ESP_ERROR_CHECK ( err ) ;
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
struct ota_mesh_packet retPacket ;
retPacket . type = OTA_Complete ;
ESP_ERROR_CHECK ( esp_mesh_send_packet ( dest , & retPacket ) ) ; //send back to parent
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
//check if this node has children --> Update them
2020-12-01 23:21:18 +01:00
2021-01-08 20:12:03 +01:00
esp_restart ( ) ;
}
2020-12-01 23:21:18 +01:00
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 + + )
2021-01-08 20:12:03 +01:00
{
if ( aMAC [ index ] ! = bMAC [ index ] )
2021-01-06 18:10:12 +01:00
{
2021-01-08 20:12:03 +01:00
return false ;
2020-12-01 23:21:18 +01:00
}
2021-01-08 20:12:03 +01:00
}
2020-12-01 23:21:18 +01:00
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 + + )
2021-01-08 20:12:03 +01:00
{
if ( ! ( esp_mesh_check_MAC_Equality ( ownMAC , route_table [ index ] . addr ) ) )
2020-12-01 23:21:18 +01:00
{
2021-01-08 20:12:03 +01:00
//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 ;
2020-12-01 23:21:18 +01:00
}
2021-01-08 20:12:03 +01:00
}
2020-12-01 23:21:18 +01:00
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 ;
2021-01-06 18:10:12 +01:00
while ( true )
2021-01-08 20:12:03 +01:00
{
data . size = RX_SIZE ;
err = esp_mesh_recv ( & from , & data , portMAX_DELAY , & flag , NULL , 0 ) ;
if ( err ! = ESP_OK | | ! data . size )
2020-12-01 23:21:18 +01:00
{
2021-01-08 20:12:03 +01:00
ESP_LOGE ( MESH_TAG , " err:0x%x, size:%d " , err , data . size ) ;
continue ;
}
2021-01-06 18:10:12 +01:00
2021-01-08 20:12:03 +01:00
struct ota_mesh_packet packet ;
memcpy ( & packet , ( uint8_t * ) rx_buf , sizeof ( struct ota_mesh_packet ) ) ;
2021-01-06 18:10:12 +01:00
2021-01-08 20:12:03 +01:00
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 ;
}
2021-01-06 18:10:12 +01:00
2021-01-08 20:12:03 +01:00
} //end while
2020-12-01 23:21:18 +01:00
vTaskDelete ( NULL ) ;
}
esp_err_t esp_mesh_comm_p2p_start ( void )
{
static bool is_comm_p2p_started = false ;
2021-01-06 18:10:12 +01:00
if ( ! is_comm_p2p_started )
2021-01-08 20:12:03 +01:00
{
is_comm_p2p_started = true ;
xTaskCreate ( esp_mesh_p2p_rx_main , " MPRX " , 7000 , NULL , 5 , NULL ) ;
}
2020-12-01 23:21:18 +01:00
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 ;
2021-01-06 18:10:12 +01:00
switch ( event_id )
2021-01-08 20:12:03 +01:00
{
case MESH_EVENT_STARTED :
{
esp_mesh_get_id ( & id ) ;
ESP_LOGI ( MESH_TAG , " <MESH_EVENT_MESH_STARTED>ID: " MACSTR " " , MAC2STR ( id . addr ) ) ;
2020-12-01 23:21:18 +01:00
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 ) ) ;
}
2021-01-01 01:25:40 +01:00
2021-01-05 12:15:26 +01:00
static void test ( void * pvParameters )
2020-12-01 23:21:18 +01:00
{
2021-01-05 12:15:26 +01:00
esp_err_t err ;
2021-01-06 18:10:12 +01:00
uint32_t u32BufferLenght = 1024U ;
2021-01-07 23:10:36 +01:00
char buffer [ 1024U ] ;
2021-01-06 18:10:12 +01:00
uint32_t u32BytesRead = 0 ;
char pcRemoteVersionNumber [ 12 ] ;
2021-01-09 17:41:40 +01:00
const esp_partition_t * currentPartition ;
const esp_partition_t * otaPartition ;
static esp_ota_handle_t otaHandle ;
uint32_t u32StartOffset ;
esp_app_desc_t otaPartitionDesc ;
2021-01-06 18:10:12 +01:00
2020-12-01 23:21:18 +01:00
ESP_LOGI ( MESH_TAG , " Hello World " ) ;
2021-01-09 17:41:40 +01:00
currentPartition = esp_ota_get_boot_partition ( ) ;
2020-12-01 23:21:18 +01:00
ESP_LOGI ( MESH_TAG , " Type: %d " , ( * currentPartition ) . subtype ) ;
ESP_LOGI ( MESH_TAG , " Start address: %d " , ( * currentPartition ) . address ) ;
2021-01-05 12:15:26 +01:00
ESP_LOGI ( MESH_TAG , " Size: %d " , ( * currentPartition ) . size ) ;
2020-12-01 23:21:18 +01:00
ESP_LOGI ( MESH_TAG , " Encrypted: %d " , ( * currentPartition ) . encrypted ) ;
2021-01-05 12:15:26 +01:00
2021-01-01 01:25:40 +01:00
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 ) ;
2020-12-01 23:21:18 +01:00
2021-01-05 12:15:26 +01:00
https_clientInitialize ( ) ;
2021-01-08 23:08:07 +01:00
https_clientRetrieveData ( buffer , & u32BufferLenght , & u32BytesRead ) ;
ESP_LOGI ( MESH_TAG , " Data received: %i " , u32BytesRead ) ;
err = errExtractVersionNumber ( buffer , & u32BytesRead , pcRemoteVersionNumber ) ;
2021-01-05 12:15:26 +01:00
2021-01-06 18:10:12 +01:00
if ( err = = ESP_OK )
{
2021-01-08 23:08:07 +01:00
if ( bNewerVersion ( ( curPartitionDesc ) . version , pcRemoteVersionNumber ) )
{
2021-01-09 17:41:40 +01:00
ESP_LOGI ( MESH_TAG , " Newer Version available " ) ;
2021-01-06 18:10:12 +01:00
//write ota
2021-01-09 17:41:40 +01:00
otaPartition = esp_ota_get_next_update_partition ( currentPartition ) ;
err = errFindImageStart ( buffer , & u32BufferLenght , & u32StartOffset ) ;
2021-01-08 23:08:07 +01:00
ESP_LOGI ( MESH_TAG , " first byte offset: %i " , u32StartOffset ) ;
ESP_LOGI ( MESH_TAG , " first byte: %x " , buffer [ u32StartOffset ] ) ;
2021-01-09 17:41:40 +01:00
2021-01-08 23:08:07 +01:00
err = esp_ota_begin ( otaPartition , OTA_SIZE_UNKNOWN , & otaHandle ) ;
2021-01-09 17:41:40 +01:00
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 ;
2021-01-08 20:12:03 +01:00
https_clientRetrieveData ( buffer , & u32BufferLenght , & u32BytesRead ) ;
}
2021-01-09 17:41:40 +01:00
while ( u32BytesRead > 0 ) ;
2021-01-08 20:12:03 +01:00
err = esp_ota_end ( otaHandle ) ;
ESP_ERROR_CHECK ( err ) ;
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 " ) ;
2021-01-06 18:10:12 +01:00
}
2021-01-08 20:12:03 +01:00
}
else
{
ESP_LOGI ( MESH_TAG , " errExtractVersionNumber failed: %i " , err ) ;
2021-01-01 01:25:40 +01:00
}
2021-01-05 12:15:26 +01:00
2021-01-06 18:10:12 +01:00
https_clientDeinitialize ( ) ;
2021-01-09 17:41:40 +01:00
ESP_LOGI ( MESH_TAG , " \n end of task \n " ) ;
2021-01-05 12:15:26 +01:00
while ( 1 )
{
2021-01-08 20:12:03 +01:00
vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;
2021-01-05 12:15:26 +01:00
}
}
void app_main ( void )
{
2021-01-09 17:41:40 +01:00
ESP_LOGI ( MESH_TAG , " hardcoded: 0.0.1 " ) ;
2021-01-05 12:15:26 +01:00
/*
err = nvs_flash_erase ( ) ;
if ( err ! = ESP_OK ) {
ESP_LOGI ( MESH_TAG , " Error: %x " , err ) ;
while ( 1 ) {
}
}
*/
ESP_ERROR_CHECK ( nvs_flash_init ( ) ) ;
2020-12-01 23:21:18 +01:00
/* 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 ( ) ) ;
2021-01-09 17:41:40 +01:00
for ( ; ; )
{
2021-01-05 12:15:26 +01:00
if ( gpio_get_level ( 0 ) = = 0 ) {
break ;
}
vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;
}
xTaskCreate ( & test , " test_task " , 8192 , NULL , 5 , NULL ) ;
2020-12-01 23:21:18 +01:00
}
2021-01-02 00:30:13 +01:00