ESP-NOW一接Wi-Fi就失联：节点跟随网关的实际信道

# 两块板分别使用不同 build-* 目录；<PORT>换成本机串口
idf.py -B build-local -D SDKCONFIG=build-local/sdkconfig set-target esp32s3
idf.py -B build-local -D SDKCONFIG=build-local/sdkconfig menuconfig
idf.py -B build-local -D SDKCONFIG=build-local/sdkconfig build
idf.py -B build-local -D SDKCONFIG=build-local/sdkconfig -p <PORT> flash monitor

cc -std=c11 -Wall -Wextra -Werror -fsanitize=address,undefined -fno-omit-frame-pointer -I main host_check.c -o /tmp/espnow-host-check
/tmp/espnow-host-check

// ---- main/main.c ----
/* SPDX-License-Identifier: MIT */
#include <assert.h>
#include <stdio.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/event_groups.h"
#include "driver/gpio.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_netif.h"
#include "esp_now.h"
#include "esp_random.h"
#include "esp_timer.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#include "channel_policy.h"
#ifdef CONFIG_W03_GATEWAY
#define GATEWAY true
#else
#define GATEWAY false
#endif
static const char *TAG="W03";
static EventGroupHandle_t network;static esp_timer_handle_t retry_timer;
static void reconnect(void *arg){(void)arg;if(!(xEventGroupGetBits(network)&BIT0)){esp_err_t e=esp_wifi_connect();ESP_LOGI(TAG,"CONNECT_REQUEST=%s",esp_err_to_name(e));}}
static void wifi_event(void *arg,esp_event_base_t base,int32_t id,void *data){
 (void)arg;
 if(base==WIFI_EVENT&&id==WIFI_EVENT_STA_START)reconnect(NULL);
 else if(base==WIFI_EVENT&&id==WIFI_EVENT_STA_DISCONNECTED){wifi_event_sta_disconnected_t *e=data;xEventGroupClearBits(network,BIT0);xEventGroupSetBits(network,BIT1);ESP_LOGW(TAG,"AP_DISCONNECTED reason=%u; no qualified beacon/command",e->reason);esp_timer_stop(retry_timer);ESP_ERROR_CHECK(esp_timer_start_once(retry_timer,2000000));}
 else if(base==IP_EVENT&&id==IP_EVENT_STA_LOST_IP){xEventGroupClearBits(network,BIT0);xEventGroupSetBits(network,BIT1);ESP_LOGW(TAG,"IP_LOST: qualified gateway beacons/commands disabled until fresh GOT_IP");}
 else if(base==IP_EVENT&&id==IP_EVENT_STA_GOT_IP){ip_event_got_ip_t *e=data;xEventGroupSetBits(network,BIT0|BIT1);ESP_LOGI(TAG,"GOT_IP="IPSTR,IP2STR(&e->ip_info.ip));}
}
static bool gateway_online(void){return network&&(xEventGroupGetBits(network)&BIT0);}
static bool credentials_ready(void){size_t s=strlen(CONFIG_W03_SSID),p=strlen(CONFIG_W03_PASSWORD);return s>0&&s<=32&&p>=8&&p<=63&&strcmp(CONFIG_W03_SSID,"REPLACE_WITH_2G4_SSID")&&strcmp(CONFIG_W03_PASSWORD,"REPLACE_WITH_PASSWORD");}
static void start_wifi(void){
 ESP_ERROR_CHECK(nvs_flash_init());ESP_ERROR_CHECK(esp_netif_init());ESP_ERROR_CHECK(esp_event_loop_create_default());
 if(GATEWAY){assert(esp_netif_create_default_wifi_sta());network=xEventGroupCreate();assert(network);esp_timer_create_args_t t={.callback=reconnect,.name="ap_retry"};ESP_ERROR_CHECK(esp_timer_create(&t,&retry_timer));ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT,ESP_EVENT_ANY_ID,wifi_event,NULL));ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT,ESP_EVENT_ANY_ID,wifi_event,NULL));}
 wifi_init_config_t init=WIFI_INIT_CONFIG_DEFAULT();ESP_ERROR_CHECK(esp_wifi_init(&init));ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
 if(GATEWAY){wifi_config_t c={0};memcpy(c.sta.ssid,CONFIG_W03_SSID,strlen(CONFIG_W03_SSID));memcpy(c.sta.password,CONFIG_W03_PASSWORD,strlen(CONFIG_W03_PASSWORD));c.sta.threshold.authmode=WIFI_AUTH_WPA2_PSK;ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA,&c));}
 ESP_ERROR_CHECK(esp_wifi_start());ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
}
typedef struct {bool tx;uint8_t mac[6],data[WIRE_BYTES],channel;int size,status;uint64_t received_at;} Event;
static QueueHandle_t events;static portMUX_TYPE mux=portMUX_INITIALIZER_UNLOCKED;static uint32_t drops;
static bool busy,stalled;static uint64_t radio_at;
static void post(const Event *e){if(xQueueSend(events,e,0)!=pdTRUE){portENTER_CRITICAL(&mux);drops++;portEXIT_CRITICAL(&mux);}}
static void recv_cb(const esp_now_recv_info_t *i,const uint8_t *d,int n){if(!i||!i->src_addr||!i->rx_ctrl||!d||n!=WIRE_BYTES)return;Event e={.size=n,.channel=i->rx_ctrl->channel,.received_at=(uint64_t)esp_timer_get_time()};memcpy(e.mac,i->src_addr,6);memcpy(e.data,d,WIRE_BYTES);post(&e);}
static void sent_cb(const esp_now_send_info_t *i,esp_now_send_status_t s){if(!i||!i->des_addr)return;Event e={.tx=true,.status=s};memcpy(e.mac,i->des_addr,6);post(&e);}
static void send_frame(const uint8_t peer[6],const Frame *f,uint64_t now){uint8_t b[WIRE_BYTES];wire_encode(f,b);esp_err_t e=esp_now_send(peer,b,sizeof(b));ESP_LOGI(TAG,"SEND_API kind=%u seq=%"PRIu32" err=%s",f->kind,f->seq,esp_err_to_name(e));if(e==ESP_OK){busy=true;radio_at=now;}}
static uint64_t nonce(void){uint64_t x;esp_fill_random(&x,sizeof(x));return x?x:1;}
void app_main(void){
 gpio_config_t out={.pin_bit_mask=1ULL<<GPIO_NUM_6,.mode=GPIO_MODE_OUTPUT};ESP_ERROR_CHECK(gpio_config(&out));ESP_ERROR_CHECK(gpio_set_level(GPIO_NUM_6,0));gpio_config_t in={.pin_bit_mask=1ULL<<GPIO_NUM_5,.mode=GPIO_MODE_INPUT};ESP_ERROR_CHECK(gpio_config(&in));
 uint8_t own[6],peer[6];ESP_ERROR_CHECK(esp_read_mac(own,ESP_MAC_WIFI_STA));ESP_LOGI(TAG,"STA="MACSTR" role=%s",MAC2STR(own),GATEWAY?"gateway":"node");
 if(!pair_mac(CONFIG_W03_PEER_MAC,peer)||!memcmp(own,peer,6)||(GATEWAY&&!credentials_ready())){ESP_LOGE(TAG,"CLOSED: actual peer STA MAC and gateway AP credentials required; no radio application started");return;}
 start_wifi();ChannelScan scan={0};
 if(!GATEWAY){wifi_country_t country;ESP_ERROR_CHECK(esp_wifi_get_country(&country));assert(channel_scan_init(&scan,country.schan,country.nchan,(uint64_t)esp_timer_get_time()));ESP_ERROR_CHECK(esp_wifi_set_channel(scan.current,WIFI_SECOND_CHAN_NONE));ESP_LOGI(TAG,"SCAN permitted subset=%u..%u,350ms/channel; no AP scan/connect on node",scan.low,scan.high);}
 events=xQueueCreate(16,sizeof(Event));assert(events);ESP_ERROR_CHECK(esp_now_init());ESP_ERROR_CHECK(esp_now_register_recv_cb(recv_cb));ESP_ERROR_CHECK(esp_now_register_send_cb(sent_cb));esp_now_peer_info_t p={.channel=0,.ifidx=WIFI_IF_STA,.encrypt=false};memcpy(p.peer_addr,peer,6);ESP_ERROR_CHECK(esp_now_add_peer(&p));
 uint64_t sender_boot=nonce(),poll_at=0,hello_at=0;ESP_LOGI(TAG,"NODE_BOOT=%016"PRIx64"; no automatic old-command replay across AP epoch",sender_boot);uint32_t sequence=0,last_drops=0;bool desired=false,gw_ready=false;uint8_t gw_channel=0;Receiver rx={0};Sender tx={0};PairButton button={.candidate=gpio_get_level(GPIO_NUM_5)==0,.stable=true,.since=(uint64_t)esp_timer_get_time()};
 for(;;){
  uint64_t now=(uint64_t)esp_timer_get_time();
  bool network_changed=GATEWAY&&network&&(xEventGroupClearBits(network,BIT1)&BIT1);
  if(GATEWAY&&(network_changed||now>=poll_at||(!gateway_online()&&gw_ready))){
   poll_at=now+500000;wifi_ap_record_t ap={0};uint8_t primary=0;wifi_second_chan_t second;bool ready=gateway_online()&&esp_wifi_sta_get_ap_info(&ap)==ESP_OK&&esp_wifi_get_channel(&primary,&second)==ESP_OK&&primary>=1&&primary<=11;
   if(gateway_new_epoch(gw_ready,gw_channel,ready,primary,network_changed)){
    rx=(Receiver){.own=ready?nonce():0};ESP_ERROR_CHECK(gpio_set_level(GPIO_NUM_6,0));hello_at=now;ESP_LOGI(TAG,"GATEWAY_EPOCH ready=%u actual_channel=%u nonce=%016"PRIx64"; LED command resetOFF",ready,primary,rx.own);
   }
   gw_ready=ready;gw_channel=primary;
  }
  Event e;
  while(xQueueReceive(events,&e,0)==pdTRUE){
   if(memcmp(e.mac,peer,6))continue;
   if(e.tx){busy=false;ESP_LOGI(TAG,"MAC_CALLBACK status=%d; not application ACK",e.status);continue;}
   Frame f;if(!wire_decode(e.data,e.size,&f))continue;
   if(!GATEWAY&&f.kind==HELLO){
    uint64_t previous=scan.receiver;
    if(channel_beacon(&scan,e.channel,f.receiver,e.received_at,(uint64_t)esp_timer_get_time())){
     if(previous!=scan.receiver){if(tx.pending)ESP_LOGW(TAG,"NEW_GATEWAY_EPOCH: cancel pending, execution uncertain");tx.pending=false;ESP_LOGI(TAG,"LOCK actual_rx_channel=%u gateway_nonce=%016"PRIx64,scan.current,scan.receiver);}
    }
   }else if(!GATEWAY&&sender_match(&tx,&f)){
    tx.pending=false;ESP_LOGI(TAG,"APP_ACK seq=%"PRIu32" status=%u on_channel=%u; GPIO/API result only",f.seq,f.status,scan.current);
    if(f.status>1)channel_invalidate(&scan,(uint64_t)esp_timer_get_time());
   }else if(GATEWAY&&f.kind==COMMAND&&gw_ready&&gateway_online()&&e.channel==gw_channel){
    uint8_t status=receive_decide(&rx,&f);if(status==APPLIED){ESP_ERROR_CHECK(gpio_set_level(GPIO_NUM_6,f.on));receive_commit(&rx,&f);}ESP_LOGI(TAG,"RX_COMMAND seq=%"PRIu32" status=%u epoch_apply_count=%"PRIu64,f.seq,status,rx.applications);
    if(!busy&&!stalled){f.kind=ACK;f.status=status;send_frame(peer,&f,(uint64_t)esp_timer_get_time());}else ESP_LOGW(TAG,"ACK_NOT_QUEUED; bounded radio send; peer may retry");
   }
  }
  now=(uint64_t)esp_timer_get_time();
  if(busy&&now-radio_at>2000000&&!stalled){stalled=true;tx.pending=false;ESP_LOGE(TAG,"MAC_CALLBACK_TIMEOUT: stop radio until manual reset; uncertain execution");}
  if(!GATEWAY){
   if(channel_expire(&scan,now)){if(tx.pending)ESP_LOGW(TAG,"BEACON_TIMEOUT: pending execution uncertain");tx.pending=false;ESP_LOGW(TAG,"DISCOVERY_RESTART; no automatic replay into new gateway epoch");}
   bool press=pair_button(&button,gpio_get_level(GPIO_NUM_5)==0,now);
   if(press){if(!scan.locked||tx.pending||busy||stalled)ESP_LOGW(TAG,"BUTTON_IGNORED: require locked channel/no pending radio");else if(sequence==UINT32_MAX)ESP_LOGE(TAG,"SEQ_EXHAUSTED: reset pair");else{desired=!desired;Frame f={.kind=COMMAND,.sender=sender_boot,.receiver=scan.receiver,.seq=++sequence,.on=desired};sender_begin(&tx,f,now);}}
   unsigned action=sender_action(&tx,now);
   if(action&&!busy&&!stalled){if(action==2){tx.pending=false;channel_invalidate(&scan,now);ESP_LOGW(TAG,"APP_ACK_TIMEOUT after4attempts; execution uncertain, rediscover");}else{sender_attempt(&tx,now);send_frame(peer,&tx.command,now);}}
   uint8_t next=channel_step(&scan,now,busy||stalled);if(next){ESP_ERROR_CHECK(esp_wifi_set_channel(next,WIFI_SECOND_CHAN_NONE));ESP_LOGI(TAG,"SCAN_CHANNEL=%u",next);}
  }else if(gw_ready&&gateway_online()&&now>=hello_at&&!busy&&!stalled){hello_at=now+200000;Frame f={.kind=HELLO,.receiver=rx.own};send_frame(peer,&f,now);}
  portENTER_CRITICAL(&mux);uint32_t count=drops;portEXIT_CRITICAL(&mux);if(count!=last_drops){last_drops=count;ESP_LOGW(TAG,"CALLBACK_QUEUE_DROPS=%"PRIu32,count);}
  vTaskDelay(pdMS_TO_TICKS(10));
 }
}

// ---- main/pair_policy.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
/* Version1, explicit big-endian bytes; no native packed struct on wire. */
#define PAIR_BYTES 16
static inline void pair_encode(uint8_t b[PAIR_BYTES],uint64_t boot,uint32_t seq,bool on){
 b[0]='W';b[1]='1';b[2]=1;b[3]=on?1:0;
 for(unsigned i=0;i<8;i++)b[4+i]=(uint8_t)(boot>>(56-8*i));
 for(unsigned i=0;i<4;i++)b[12+i]=(uint8_t)(seq>>(24-8*i));
}
static inline bool pair_decode(const uint8_t *b,size_t n,uint64_t *boot,uint32_t *seq,bool *on){
 if(!b||!boot||!seq||!on||n!=PAIR_BYTES||b[0]!='W'||b[1]!='1'||b[2]!=1||b[3]>1)return false;
 uint64_t x=0;uint32_t y=0;
 for(unsigned i=0;i<8;i++)x=(x<<8)|b[4+i];
 for(unsigned i=0;i<4;i++)y=(y<<8)|b[12+i];
 if(!x||!y)return false;
 *boot=x;*seq=y;*on=b[3]!=0;return true;
}
static inline int pair_hex(char c){if(c>='0'&&c<='9')return c-'0';if(c>='a'&&c<='f')return c-'a'+10;if(c>='A'&&c<='F')return c-'A'+10;return -1;}
static inline bool pair_mac(const char *s,uint8_t out[6]){
 if(!s||strlen(s)!=17)return false;
 uint8_t m[6];unsigned sum=0;
 for(unsigned i=0;i<6;i++){
  int a=pair_hex(s[3*i]),b=pair_hex(s[3*i+1]);if(a<0||b<0||(i<5&&s[3*i+2]!=':'))return false;
  m[i]=(uint8_t)((a<<4)|b);sum|=m[i];
 }
 if(!sum||(m[0]&1))return false;
 memcpy(out,m,6);return true;
}
/* Startup press is not an event; stable released level must first arm. */
typedef struct {bool candidate,stable,armed;uint64_t since;} PairButton;
static inline bool pair_button(PairButton *b,bool pressed,uint64_t now){
 if(pressed!=b->candidate){b->candidate=pressed;b->since=now;}
 if(now-b->since<50000)return false;
 if(!pressed)b->armed=true;
 if(pressed==b->stable)return false;
 b->stable=pressed;
 if(pressed&&b->armed){b->armed=false;return true;}
 return false;
}

// ---- main/reliable_policy.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include "pair_policy.h"
#define WIRE_BYTES 32
#define HELLO 1
#define COMMAND 2
#define ACK 3
#define APPLIED 0
#define DUPLICATE 1
#define SESSION_REJECTED 2
#define STALE_REJECTED 3
#define CONFLICT_REJECTED 4
typedef struct {uint8_t kind,status;bool on;uint64_t sender,receiver;uint32_t seq;} Frame;
static inline uint32_t wire_crc(const uint8_t *p,size_t n){uint32_t c=UINT32_MAX;for(size_t i=0;i<n;i++){c^=p[i];for(unsigned k=0;k<8;k++)c=(c>>1)^((c&1)?UINT32_C(0xedb88320):0);}return ~c;}
static inline void put_be(uint8_t *p,uint64_t v,unsigned n){for(unsigned i=0;i<n;i++)p[i]=(uint8_t)(v>>(8*(n-i-1)));}
static inline uint64_t get_be(const uint8_t *p,unsigned n){uint64_t v=0;for(unsigned i=0;i<n;i++)v=(v<<8)|p[i];return v;}
static inline void wire_encode(const Frame *f,uint8_t b[WIRE_BYTES]){memset(b,0,WIRE_BYTES);b[0]='W';b[1]='3';b[2]=1;b[3]=f->kind;b[4]=f->on;b[5]=f->status;put_be(b+8,f->sender,8);put_be(b+16,f->receiver,8);put_be(b+24,f->seq,4);put_be(b+28,wire_crc(b,28),4);}
static inline bool wire_decode(const uint8_t *b,size_t n,Frame *f){
 if(!b||!f||n!=WIRE_BYTES||b[0]!='W'||b[1]!='3'||b[2]!=1||b[4]>1||b[6]||b[7]||get_be(b+28,4)!=wire_crc(b,28))return false;
 Frame x={.kind=b[3],.status=b[5],.on=b[4],.sender=get_be(b+8,8),.receiver=get_be(b+16,8),.seq=(uint32_t)get_be(b+24,4)};
 if(!x.receiver)return false;
 if(x.kind==HELLO){if(x.sender||x.seq||x.status||x.on)return false;}
 else if(x.kind==COMMAND){if(!x.sender||!x.seq||x.status)return false;}
 else if(x.kind==ACK){if(!x.sender||!x.seq||x.status>CONFLICT_REJECTED)return false;}
 else return false;
 *f=x;return true;
}
typedef struct {uint64_t own,bound_sender;uint32_t last;bool level;uint64_t applications;} Receiver;
/* Bind one sender boot until receiver resets. Explicit reset-pair recovery,
   rather than silently accepting delayed commands from another boot. */
static inline uint8_t receive_decide(const Receiver *r,const Frame *f){
 if(f->kind!=COMMAND||f->receiver!=r->own||(r->bound_sender&&f->sender!=r->bound_sender))return SESSION_REJECTED;
 if(f->seq<r->last)return STALE_REJECTED;
 if(f->seq==r->last)return f->on==r->level?DUPLICATE:CONFLICT_REJECTED;
 return APPLIED;
}
/* Call only after gpio_set_level successfully returns. */
static inline void receive_commit(Receiver *r,const Frame *f){r->bound_sender=f->sender;r->last=f->seq;r->level=f->on;r->applications++;}
typedef struct {bool pending;uint8_t attempts;uint64_t next_at;Frame command;} Sender;
static inline void sender_begin(Sender *s,Frame f,uint64_t now){s->pending=true;s->attempts=0;s->next_at=now;s->command=f;}
static inline bool sender_due(const Sender *s,uint64_t now){return s->pending&&now>=s->next_at;}
static inline void sender_attempt(Sender *s,uint64_t now){s->attempts++;s->next_at=now+300000;}
static inline bool sender_match(const Sender *s,const Frame *f){return s->pending&&f->kind==ACK&&f->sender==s->command.sender&&f->receiver==s->command.receiver&&f->seq==s->command.seq&&f->on==s->command.on;}

/* 0=wait,1=attempt,2=finish without ACK. Shared with firmware and fixture. */
static inline unsigned sender_action(const Sender *s,uint64_t now){return !sender_due(s,now)?0:s->attempts<4?1:2;}

// ---- main/channel_policy.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include "reliable_policy.h"
typedef struct {uint8_t low,high,current;bool locked;uint64_t receiver,seen,next;} ChannelScan;
static inline bool channel_scan_init(ChannelScan *s,unsigned first,unsigned count,uint64_t now){
 if(first<1||first>14||!count||count>14||first+count-1>14)return false;
 unsigned last=count?first+count-1:0,low=first<1?1:first,high=last>11?11:last;
 if(!count||low>high)return false;
 *s=(ChannelScan){.low=(uint8_t)low,.high=(uint8_t)high,.current=(uint8_t)low,.next=now+350000};return true;
}
/* Callback metadata is copied while valid; a queued old-channel beacon cannot
   lock a new channel or reset age to the later processing timestamp. */
static inline bool channel_beacon(ChannelScan *s,uint8_t received_channel,uint64_t receiver,uint64_t received_at,uint64_t now){
 if(!receiver||received_channel!=s->current||received_channel<s->low||received_channel>s->high||now<received_at||now-received_at>250000)return false;
 s->locked=true;s->receiver=receiver;s->seen=received_at;return true;
}
static inline bool channel_expire(ChannelScan *s,uint64_t now){
 if(!s->locked||(now>=s->seen&&now-s->seen<=3000000))return false;
 s->locked=false;s->receiver=0;s->next=now;return true;
}
static inline void channel_invalidate(ChannelScan *s,uint64_t now){s->locked=false;s->receiver=0;s->next=now;}
static inline uint8_t channel_step(ChannelScan *s,uint64_t now,bool radio_busy){
 if(s->locked||radio_busy||now<s->next)return 0;
 s->current=s->current>=s->high?s->low:s->current+1;s->next=now+350000;return s->current;
}
static inline bool gateway_new_epoch(bool old_ready,uint8_t old_channel,bool ready,uint8_t channel,bool network_changed){return network_changed||old_ready!=ready||(ready&&old_channel!=channel);}

# ---- main/Kconfig.projbuild ----
menu "W03 fixed-peer AP and ESP-NOW coexistence"
config W03_GATEWAY
    bool "Gateway joins the controlled AP (off=node scans)"
    default n
config W03_PEER_MAC
    string "Other board actual STA MAC (zero keeps application closed)"
    default "00:00:00:00:00:00"
config W03_SSID
    string "Gateway2.4GHz controlled AP SSID"
    default "REPLACE_WITH_2G4_SSID"
config W03_PASSWORD
    string "Gateway AP password8..63 bytes, local sdkconfig only"
    default "REPLACE_WITH_PASSWORD"
endmenu

# ---- sdkconfig.defaults ----
CONFIG_IDF_TARGET="esp32s3"
CONFIG_ESPTOOLPY_FLASHSIZE_8MB=y
CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
CONFIG_SPIRAM=y
CONFIG_SPIRAM_MODE_OCT=y
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_ESP_CONSOLE_UART_DEFAULT=y
CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200
CONFIG_FREERTOS_HZ=1000