ESP32 Forum

Code: Select all

#include <Arduino.h>
#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 "esp_netif.h"

static bool is_mesh_connected = false;
static mesh_addr_t mesh_parent_addr;
static int mesh_layer = -1;
static esp_netif_t *netif_sta = NULL;
#define CONFIG_MESH_ROUTE_TABLE_SIZE 50
uint8_t g_meshAddr[6] = {0};
uint8_t g_deviceId[6] = {0};
#define CONFIG_MESH_TOPOLOGY MESH_TOPO_TREE /* MESH_TOPO_TREE / MESH_TOPO_CHAIN */

#define CONFIG_MESH_PS_DEV_DUTY 10 /* 1 - 100 */
#define CONFIG_MESH_PS_DEV_DUTY_TYPE  MESH_PS_DEVICE_DUTY_REQUEST /* MESH_PS_DEVICE_DUTY_REQUEST / MESH_PS_DEVICE_DUTY_DEMAND */
#define CONFIG_MESH_PS_NWK_DUTY 10
#define CONFIG_MESH_PS_NWK_DUTY_DURATION  -1
#define CONFIG_MESH_PS_NWK_DUTY_RULE  MESH_PS_NETWORK_DUTY_APPLIED_ENTIRE

//#define CONFIG_MESH_ENABLE_PS

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 uint8_t last_layer = 0;

    switch(event_id) 
  {
      case MESH_EVENT_STARTED: 
    {
          esp_mesh_get_id(&id);
          Serial.printf("<MESH_EVENT_MESH_STARTED>ID:%02x:%02x:%02x:%02x:%02x:%02x\n", MAC2STR(id.addr));
          is_mesh_connected = false;
          mesh_layer = esp_mesh_get_layer();
      }
      break;
      case MESH_EVENT_STOPPED: 
    {
          Serial.printf("<MESH_EVENT_STOPPED>\n");
          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;
          Serial.printf("<MESH_EVENT_CHILD_CONNECTED>aid:%d, %02x:%02x:%02x:%02x:%02x:%02x\n",
                   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;
          Serial.printf("<MESH_EVENT_CHILD_DISCONNECTED>aid:%d, %02x:%02x:%02x:%02x:%02x:%02x\n",
                   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;
          Serial.printf("<MESH_EVENT_ROUTING_TABLE_ADD>add %d, new:%d\n",
                   routing_table->rt_size_change,
                   routing_table->rt_size_new);
      }
      break;
      case MESH_EVENT_ROUTING_TABLE_REMOVE: 
    {
          mesh_event_routing_table_change_t *routing_table = (mesh_event_routing_table_change_t *)event_data;
          Serial.printf("<MESH_EVENT_ROUTING_TABLE_REMOVE>remove %d, new:%d\n",
                   routing_table->rt_size_change,
                   routing_table->rt_size_new);
      }
      break;
      case MESH_EVENT_NO_PARENT_FOUND:
    {
          mesh_event_no_parent_found_t *no_parent = (mesh_event_no_parent_found_t *)event_data;
          Serial.printf("<MESH_EVENT_NO_PARENT_FOUND>scan times:%d\n",
                   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);
          Serial.printf(
                   "<MESH_EVENT_PARENT_CONNECTED>layer:%d-->%d, parent:%02x:%02x:%02x:%02x:%02x:%02x%s, ID:%02x:%02x:%02x:%02x:%02x:%02x\n",
                   last_layer, mesh_layer, MAC2STR(mesh_parent_addr.addr),
                   esp_mesh_is_root() ? "<ROOT>" :
                   (mesh_layer == 2) ? "<layer2>" : "", MAC2STR(id.addr));
          last_layer = mesh_layer;
          is_mesh_connected = true;
          if(esp_mesh_is_root()) 
      {
        // 根节点需要在这里开启DHCP获取IP
              esp_netif_dhcpc_start(netif_sta);
          }
      else
      {
      }
      // 开启2个任务
          // -> esp_mesh_comm_p2p_start();
         
      }
      break;
      case MESH_EVENT_PARENT_DISCONNECTED:
    {
          mesh_event_disconnected_t *disconnected = (mesh_event_disconnected_t *)event_data;
          Serial.printf(
                   "<MESH_EVENT_PARENT_DISCONNECTED>reason:%d\n",
                   disconnected->reason);
          is_mesh_connected = false;
          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;
          Serial.printf("<MESH_EVENT_LAYER_CHANGE>layer:%d-->%d%s\n",
                   last_layer, mesh_layer,
                   esp_mesh_is_root() ? "<ROOT>" :
                   (mesh_layer == 2) ? "<layer2>" : "");
          last_layer = mesh_layer;

      if(mesh_layer == 1)
      {
        // 这里1是根节点，意味着节点此时变化为根节点
        // 此处可以添加节点切换的用户自定义功能 
      }
      else
      {
      }
      }
      break;
      case MESH_EVENT_ROOT_ADDRESS: 
    {
          mesh_event_root_address_t *root_addr = (mesh_event_root_address_t *)event_data;
      
      esp_mesh_get_id(&id);
      
          Serial.printf("<MESH_EVENT_ROOT_ADDRESS>root address:%02x:%02x:%02x:%02x:%02x:%02x, ID:%02x:%02x:%02x:%02x:%02x:%02x\n",
                   MAC2STR(root_addr->addr), MAC2STR(id.addr));

      // 此处登记自身在路由表中的地址
      int route_table_size = 0;
      mesh_addr_t route_table[CONFIG_MESH_ROUTE_TABLE_SIZE];
      esp_mesh_get_routing_table((mesh_addr_t *) &route_table, CONFIG_MESH_ROUTE_TABLE_SIZE * 6, &route_table_size);
      
      memcpy(g_meshAddr, route_table[0].addr, 6);

      Serial.printf("<MESH_EVENT_ROOT_ADDRESS>meshAddr:%02x:%02x:%02x:%02x:%02x:%02x\n", MAC2STR(g_meshAddr));

      // 此处设置默认设备ID
      memcpy(g_deviceId, g_meshAddr, 6);
      }
      break;
      case MESH_EVENT_VOTE_STARTED: 
    {
          mesh_event_vote_started_t *vote_started = (mesh_event_vote_started_t *)event_data;
          Serial.printf(
                   "<MESH_EVENT_VOTE_STARTED>attempts:%d, reason:%d, rc_addr:%02x:%02x:%02x:%02x:%02x:%02x\n",
                   vote_started->attempts,
                   vote_started->reason,
                   MAC2STR(vote_started->rc_addr.addr));
      }
      break;
      case MESH_EVENT_VOTE_STOPPED: 
    {
          Serial.printf("<MESH_EVENT_VOTE_STOPPED>\n");
          break;
      }
      case MESH_EVENT_ROOT_SWITCH_REQ: 
    {
          mesh_event_root_switch_req_t *switch_req = (mesh_event_root_switch_req_t *)event_data;
          Serial.printf(
                   "<MESH_EVENT_ROOT_SWITCH_REQ>reason:%d, rc_addr:%02x:%02x:%02x:%02x:%02x:%02x\n",
                   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);
          Serial.printf("<MESH_EVENT_ROOT_SWITCH_ACK>layer:%d, parent:%02x:%02x:%02x:%02x:%02x:%02x\n", 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;
          Serial.printf("<MESH_EVENT_TODS_REACHABLE>state:%d\n", *toDs_state);
      }
      break;
      case MESH_EVENT_ROOT_FIXED: 
    {
          mesh_event_root_fixed_t *root_fixed = (mesh_event_root_fixed_t *)event_data;
          Serial.printf("<MESH_EVENT_ROOT_FIXED>%s\n",
                   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;
          Serial.printf(
                   "<MESH_EVENT_ROOT_ASKED_YIELD>%02x:%02x:%02x:%02x:%02x:%02x, rssi:%d, capacity:%d\n",
                   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;
          Serial.printf("<MESH_EVENT_CHANNEL_SWITCH>new channel:%d\n", channel_switch->channel);
      }
      break;
      case MESH_EVENT_SCAN_DONE: 
    {
          mesh_event_scan_done_t *scan_done = (mesh_event_scan_done_t *)event_data;
          Serial.printf("<MESH_EVENT_SCAN_DONE>number:%d\n",
                   scan_done->number);
      }
      break;
      case MESH_EVENT_NETWORK_STATE: 
    {
          mesh_event_network_state_t *network_state = (mesh_event_network_state_t *)event_data;
          Serial.printf("<MESH_EVENT_NETWORK_STATE>is_rootless:%d\n",
                   network_state->is_rootless);
      }
      break;
      case MESH_EVENT_STOP_RECONNECTION: 
    {
          Serial.printf("<MESH_EVENT_STOP_RECONNECTION>\n");
      }
      break;
      case MESH_EVENT_FIND_NETWORK: 
    {
          mesh_event_find_network_t *find_network = (mesh_event_find_network_t *)event_data;
          Serial.printf("<MESH_EVENT_FIND_NETWORK>new channel:%d, router BSSID:%02x:%02x:%02x:%02x:%02x:%02x\n",
                   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;
          Serial.printf("<MESH_EVENT_ROUTER_SWITCH>new router:%s, channel:%d, %02x:%02x:%02x:%02x:%02x:%02x\n",
                   router_switch->ssid, router_switch->channel, MAC2STR(router_switch->bssid));
      }
      break;
      default:
          Serial.printf("unknown id:%d\n", 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;
    Serial.printf("<IP_EVENT_STA_GOT_IP>IP: %d.%d.%d.%d\n", IP2STR(&event->ip_info.ip));
}


#define DEFAULT_MESH_SSID           "aaaaaaaaaa" /* Max=30+1 Min=8+1(Base64编码6字节MAC有8位)*/
#define DEFAULT_MESH_PASSWORD       "bbbbbbbbbb" /* Max=60+1 */
#define DEFAULT_MESH_CHANNEL        6
#define DEFAULT_MESH_MAX_PLAYER     6
#define DEFAULT_MESH_AP_PASSWD      "MESH_AP_PASSWORD"
#define DEFAULT_MESH_AP_CONNECTIONS 6
static const uint8_t MESH_ID[6] = { 0x77, 0x77, 0x77, 0x77, 0x77, 0x77};
//static const uint8_t MESH_ID[6] = { 0x88, 0x88, 0x88, 0x88, 0x88, 0x88};


void setup() {
  // put your setup code here, to run once:
    Serial.begin(115200);
    /* 初始化NVS */
    nvs_flash_init();
    /* 初始化底层TCP/IP堆栈        */
    esp_netif_init();
  
    /* 事件初始化*/
    esp_event_loop_create_default();
  /* 为 Mesh 创建STA和AP模式网络接口（仅保存STA接口供进一步处理），并关闭DHCP服务器和客户端（DHCP客户端只有设备升根节点才启用） */
  esp_netif_create_default_wifi_mesh_netifs(&netif_sta, NULL);
  
    /* Wi-Fi 初始化 */
    wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&config);
  /* 注册 IP 事件处理程序 */
    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &ip_event_handler, NULL);
    esp_wifi_set_storage(WIFI_STORAGE_FLASH);
    esp_wifi_start();
  
    /* Mesh 初始化 */
    esp_mesh_init();
  /* 注册 Mesh 事件处理程序 */
    esp_event_handler_register(MESH_EVENT, ESP_EVENT_ANY_ID, &mesh_event_handler, NULL);
  /*  set mesh topology */
    esp_mesh_set_topology(CONFIG_MESH_TOPOLOGY);
  /* 设置 Mesh 最大层 */
    esp_mesh_set_max_layer(DEFAULT_MESH_MAX_PLAYER);
  /* 设置 Mesh 根节点推举百分比（只有达到此阈值才可成为根） */
    esp_mesh_set_vote_percentage(1);
  // ???
    esp_mesh_set_xon_qsize(128);
    
#ifdef CONFIG_MESH_ENABLE_PS
    /* Enable mesh PS function */
    esp_mesh_enable_ps();
    /* 设置 Mesh AP模式关联过期时间（在AP模式下此时间内未收到某个子节点的任何数据，Mesh将子节点置为不活跃的并分离它） */
    esp_mesh_set_ap_assoc_expire(60);
    /* better to increase the announce interval to avoid too much management traffic, if a small duty cycle is set. */
    esp_mesh_set_announce_interval(600, 3300);
#else
    /* Disable mesh PS function */
    esp_mesh_disable_ps();
    esp_mesh_set_ap_assoc_expire(10);
#endif


  /* Mesh 配置 */
  /* 默认启用 Mesh IE 加密 */
    mesh_cfg_t cfg;
    cfg.crypto_funcs = &g_wifi_default_mesh_crypto_funcs;
    /* Mesh ID */
    memcpy((uint8_t *) &cfg.mesh_id, MESH_ID, 6);
  
    /* 路由器 */
  /* 信道（需与路由器信道匹配）*/
    cfg.channel = DEFAULT_MESH_CHANNEL;
    // 这里为了方便直接填写了要接入WIFI的SSID和密码
    cfg.router.ssid_len = strlen(DEFAULT_MESH_SSID);
    strcpy((char*)cfg.router.ssid, DEFAULT_MESH_SSID);
    strcpy((char*)cfg.router.password, DEFAULT_MESH_PASSWORD);
    /* Mesh softAP */
    esp_mesh_set_ap_authmode(WIFI_AUTH_WPA2_PSK);
    cfg.mesh_ap.max_connection = DEFAULT_MESH_AP_CONNECTIONS;
    strcpy((char*)cfg.mesh_ap.password, DEFAULT_MESH_AP_PASSWD);
    esp_mesh_set_config(&cfg);
  
    /* Mesh 启动 */
    esp_mesh_start();
  
#ifdef CONFIG_MESH_ENABLE_PS
    /* set the device active duty cycle. (default:10, MESH_PS_DEVICE_DUTY_REQUEST) */
    esp_mesh_set_active_duty_cycle(CONFIG_MESH_PS_DEV_DUTY, CONFIG_MESH_PS_DEV_DUTY_TYPE);
    /* set the network active duty cycle. (default:10, -1, MESH_PS_NETWORK_DUTY_APPLIED_ENTIRE) */
    esp_mesh_set_network_duty_cycle(CONFIG_MESH_PS_NWK_DUTY, CONFIG_MESH_PS_NWK_DUTY_DURATION, CONFIG_MESH_PS_NWK_DUTY_RULE);
#endif

    Serial.printf("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());
             
}

void loop() {
  // put your main code here, to run repeatedly:
  //delay(10);
  Serial.println(esp_mesh_get_type());
  delay(1000);
}