Browse Source

first working firmware

pull/3/head
Hendrik Schutter 2 years ago
parent
commit
f00495a322
  1. 6
      CMakeLists.txt
  2. 8
      Makefile
  3. 2
      main/CMakeLists.txt
  4. 165
      main/Kconfig.projbuild
  5. 5
      main/component.mk
  6. 606
      main/mesh_main.c
  7. 8
      partitions.csv
  8. 1239
      sdkconfig
  9. 1114
      sdkconfig.old

6
CMakeLists.txt

@ -0,0 +1,6 @@
# The following five lines of boilerplate have to be in your project's
# CMakeLists in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(internal_communication)

8
Makefile

@ -0,0 +1,8 @@
#
# This is a project Makefile. It is assumed the directory this Makefile resides in is a
# project subdirectory.
#
PROJECT_NAME := internal_communication
include $(IDF_PATH)/make/project.mk

2
main/CMakeLists.txt

@ -0,0 +1,2 @@
idf_component_register(SRCS "mesh_main.c"
INCLUDE_DIRS ".")

165
main/Kconfig.projbuild

@ -0,0 +1,165 @@
menu "Example Configuration"
choice
bool "Mesh Topology"
default MESH_TOPO_TREE
help
Mesh Network Topology.
config MESH_TOPO_TREE
bool "MESH_TOPO_TREE"
config MESH_TOPO_CHAIN
bool "MESH_TOPO_CHAIN"
endchoice
config MESH_TOPOLOGY
int
default 0 if MESH_TOPO_TREE
default 1 if MESH_TOPO_CHAIN
help
Mesh Network Topology.
config MESH_ENABLE_PS
bool "Enable mesh PS (power save) function"
default y
help
Enable/Disable Power Save function.
choice
bool "Mesh PS device duty cycle type"
depends on MESH_ENABLE_PS
default MESH_PS_DEV_DUTY_TYPE_REQUEST
help
Mesh PS device duty cycle type.
config MESH_PS_DEV_DUTY_TYPE_REQUEST
bool "MESH_PS_DEV_DUTY_TYPE_REQUEST"
config MESH_PS_DEV_DUTY_TYPE_DEMAND
bool "MESH_PS_DEV_DUTY_TYPE_DEMAND"
endchoice
config MESH_PS_DEV_DUTY_TYPE
int
depends on MESH_ENABLE_PS
default 1 if MESH_PS_DEV_DUTY_TYPE_REQUEST
default 4 if MESH_PS_DEV_DUTY_TYPE_DEMAND
help
Mesh PS device duty cycle type.
config MESH_PS_DEV_DUTY
int "Mesh PS device duty cycle"
depends on MESH_ENABLE_PS
range 1 100
default 12
help
Mesh PS device duty cycle.
config MESH_PS_NWK_DUTY
int "Mesh PS network duty cycle"
depends on MESH_ENABLE_PS
range 1 100
default 12
help
Mesh PS network duty cycle.
config MESH_PS_NWK_DUTY_DURATION
int "Mesh PS network duty cycle duration (unit: minutes)"
depends on MESH_ENABLE_PS
range -1 100
default -1
help
Mesh PS network duty cycle duration.
choice
bool "Mesh PS network duty cycle rule"
depends on MESH_ENABLE_PS
default MESH_PS_NETWORK_DUTY_APPLIED_ENTIRE
help
Mesh PS network duty cycle rule.
config MESH_PS_NETWORK_DUTY_APPLIED_ENTIRE
bool "MESH_PS_NETWORK_DUTY_APPLIED_ENTIRE"
config MESH_PS_NETWORK_DUTY_APPLIED_UPLINK
bool "MESH_PS_NETWORK_DUTY_APPLIED_UPLINK"
endchoice
config MESH_PS_NWK_DUTY_RULE
int
depends on MESH_ENABLE_PS
default 0 if MESH_PS_NETWORK_DUTY_APPLIED_ENTIRE
default 1 if MESH_PS_NETWORK_DUTY_APPLIED_UPLINK
help
Mesh PS network duty cycle rule.
config MESH_MAX_LAYER
int "Mesh Max Layer"
range 1 25 if MESH_TOPO_TREE
range 1 1000 if MESH_TOPO_CHAIN
default 6
help
Max layer allowed in mesh network.
config MESH_CHANNEL
int "channel"
range 0 14
default 0
help
mesh network channel.
config MESH_ROUTER_SSID
string "Router SSID"
default "ROUTER_SSID"
help
Router SSID.
config MESH_ROUTER_PASSWD
string "Router password"
default "ROUTER_PASSWD"
help
Router password.
choice
bool "Mesh AP Authentication Mode"
default WIFI_AUTH_WPA2_PSK
help
Authentication mode.
config WIFI_AUTH_OPEN
bool "WIFI_AUTH_OPEN"
config WIFI_AUTH_WPA_PSK
bool "WIFI_AUTH_WPA_PSK"
config WIFI_AUTH_WPA2_PSK
bool "WIFI_AUTH_WPA2_PSK"
config WIFI_AUTH_WPA_WPA2_PSK
bool "WIFI_AUTH_WPA_WPA2_PSK"
endchoice
config MESH_AP_AUTHMODE
int
default 0 if WIFI_AUTH_OPEN
default 2 if WIFI_AUTH_WPA_PSK
default 3 if WIFI_AUTH_WPA2_PSK
default 4 if WIFI_AUTH_WPA_WPA2_PSK
help
Mesh AP authentication mode.
config MESH_AP_PASSWD
string "Mesh AP Password"
default "MAP_PASSWD"
help
Mesh AP password.
config MESH_AP_CONNECTIONS
int "Mesh AP Connections"
range 1 10
default 6
help
The number of stations allowed to connect in.
config MESH_ROUTE_TABLE_SIZE
int "Mesh Routing Table Size"
range 1 300
default 50
help
The number of devices over the network(max: 300).
endmenu

5
main/component.mk

@ -0,0 +1,5 @@
#
# "main" pseudo-component makefile.
#
# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

606
main/mesh_main.c

@ -0,0 +1,606 @@
#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"
#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));
}
void app_main(void)
{
/*
esp_err_t err;
err = nvs_flash_erase();
if(err != ESP_OK){
ESP_LOGI(MESH_TAG, "Error: %x", err);
while(1){
}
}
*/
ESP_ERROR_CHECK(nvs_flash_init());
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); //passt
ESP_LOGI(MESH_TAG, "Encrypted: %d", (*currentPartition).encrypted);
/* 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());
/* START OTA MESH */
//if (esp_mesh_is_root()) {
ESP_LOGI(MESH_TAG, "ROOT NODE");
//https ota
// while(1){
for(;;) {
if(gpio_get_level(0) == 0){
break;
}
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
mesh_addr_t children[CONFIG_MESH_ROUTE_TABLE_SIZE];
uint16_t u16ChildrenSize;
esp_mesh_get_Children(children, &u16ChildrenSize);
ESP_LOGI(MESH_TAG, "ChildrenSize: %i", u16ChildrenSize);
struct ota_mesh_packet packet;
packet.type=APP_Version_Request;
//packet.au8Payload[0] = 42;
for (uint16_t i = 0; i < u16ChildrenSize; i++)
{
ESP_ERROR_CHECK (esp_mesh_send_packet(&children[i], &packet));
}
// }//end while 1
//} // end root node
}

8
partitions.csv

@ -0,0 +1,8 @@
# Name, Type, SubType, Offset, Size, Flags
# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
nvs, data, nvs, , 0x4000,
otadata, data, ota, , 0x2000,
phy_init, data, phy, , 0x1000,
factory, app, factory, , 1M,
ota_0, app, ota_0, , 1M,
ota_1, app, ota_1, , 1M,
1 # Name, Type, SubType, Offset, Size, Flags
2 # Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
3 nvs, data, nvs, , 0x4000,
4 otadata, data, ota, , 0x2000,
5 phy_init, data, phy, , 0x1000,
6 factory, app, factory, , 1M,
7 ota_0, app, ota_0, , 1M,
8 ota_1, app, ota_1, , 1M,

1239
sdkconfig

File diff suppressed because it is too large Load Diff

1114
sdkconfig.old

File diff suppressed because it is too large Load Diff
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