两块ESP32不连路由器通信：先追踪第一条按钮命令

# 两块板分别使用不同 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 <stdio.h>
#include <assert.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.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 "pair_policy.h"
#ifdef CONFIG_W01_SENDER
#define SENDER true
#else
#define SENDER false
#endif
#define BUTTON GPIO_NUM_5
#define LED GPIO_NUM_6
static const char *TAG="W01";
typedef struct {bool tx;uint8_t mac[6],data[PAIR_BYTES];int size,status;} Event;
static QueueHandle_t events;
static portMUX_TYPE drop_mux=portMUX_INITIALIZER_UNLOCKED;
static uint32_t drops;
static void post(const Event *e){
 if(xQueueSend(events,e,0)!=pdTRUE){portENTER_CRITICAL(&drop_mux);drops++;portEXIT_CRITICAL(&drop_mux);}
}
static void recv_cb(const esp_now_recv_info_t *info,const uint8_t *data,int size){
 if(!info||!info->src_addr||!data||size!=PAIR_BYTES)return;
 Event e={.size=size};memcpy(e.mac,info->src_addr,6);memcpy(e.data,data,PAIR_BYTES);post(&e);
}
static void sent_cb(const esp_now_send_info_t *info,esp_now_send_status_t status){
 if(!info||!info->des_addr)return;
 Event e={.tx=true,.status=status};memcpy(e.mac,info->des_addr,6);post(&e);
}
void app_main(void){
 gpio_config_t out={.pin_bit_mask=1ULL<<LED,.mode=GPIO_MODE_OUTPUT};ESP_ERROR_CHECK(gpio_config(&out));ESP_ERROR_CHECK(gpio_set_level(LED,0));
 gpio_config_t in={.pin_bit_mask=1ULL<<BUTTON,.mode=GPIO_MODE_INPUT,.pull_up_en=GPIO_PULLUP_DISABLE,.pull_down_en=GPIO_PULLDOWN_DISABLE};ESP_ERROR_CHECK(gpio_config(&in));
 /* Do not silently erase unrelated NVS on an initialization failure. */
 ESP_ERROR_CHECK(nvs_flash_init());ESP_ERROR_CHECK(esp_netif_init());ESP_ERROR_CHECK(esp_event_loop_create_default());
 wifi_init_config_t cfg=WIFI_INIT_CONFIG_DEFAULT();ESP_ERROR_CHECK(esp_wifi_init(&cfg));ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));ESP_ERROR_CHECK(esp_wifi_start());ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
 ESP_ERROR_CHECK(esp_wifi_set_channel(CONFIG_W01_CHANNEL,WIFI_SECOND_CHAN_NONE));
 uint8_t own[6],peer[6];ESP_ERROR_CHECK(esp_wifi_get_mac(WIFI_IF_STA,own));
 ESP_LOGI(TAG,"STA=" MACSTR " role=%s channel=%d; USB UART0 115200",MAC2STR(own),SENDER?"sender":"receiver",CONFIG_W01_CHANNEL);
 if(!pair_mac(CONFIG_W01_PEER_MAC,peer)||!memcmp(own,peer,6)){
  ESP_LOGE(TAG,"CLOSED: set other board's actual STA MAC in menuconfig; LED stays OFF");return;
 }
 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));
 /* Unencrypted bench exercise: fixed source address is a filter, not authentication. */
 uint64_t boot;esp_fill_random(&boot,sizeof(boot));if(!boot)boot=1;
 uint32_t seq=0,last_drops=0;bool desired=false,inflight=false,radio_stalled=false;uint64_t send_at=0;
 PairButton button={.candidate=gpio_get_level(BUTTON)==0,.stable=true,.since=(uint64_t)esp_timer_get_time()};
 for(;;){
  uint64_t now=(uint64_t)esp_timer_get_time();Event e;
  while(xQueueReceive(events,&e,0)==pdTRUE){
   if(memcmp(e.mac,peer,6))continue;
   if(e.tx){inflight=false;ESP_LOGI(TAG,"MAC_CALLBACK status=%d; NOT application acknowledgement",e.status);continue;}
   uint64_t remote_boot;uint32_t remote_seq;bool on;
   if(!SENDER&&pair_decode(e.data,e.size,&remote_boot,&remote_seq,&on)){
    ESP_ERROR_CHECK(gpio_set_level(LED,on));ESP_LOGI(TAG,"GPIO_SET boot=%016" PRIx64 " seq=%" PRIu32 " level=%d; optical result unmeasured",remote_boot,remote_seq,on);
   }
  }
  bool pressed=pair_button(&button,gpio_get_level(BUTTON)==0,now);
  if(SENDER&&pressed){
   if(inflight||radio_stalled){ESP_LOGW(TAG,"BUTTON_IGNORED: one radio send pending/stalled");}
   else if(seq==UINT32_MAX){ESP_LOGE(TAG,"SEQ_EXHAUSTED: restart pair; no wrap reuse");}
   else{
    uint8_t bytes[PAIR_BYTES];desired=!desired;pair_encode(bytes,boot,++seq,desired);esp_err_t err=esp_now_send(peer,bytes,sizeof(bytes));
    ESP_LOGI(TAG,"SEND_API seq=%" PRIu32 " level=%d err=%s",seq,desired,esp_err_to_name(err));
    if(err==ESP_OK){inflight=true;send_at=now;}
   }
  }
  if(inflight&&now-send_at>2000000&&!radio_stalled){radio_stalled=true;ESP_LOGE(TAG,"SEND_CALLBACK_TIMEOUT: radio closed until restart; no unbounded sends");}
  portENTER_CRITICAL(&drop_mux);uint32_t count=drops;portEXIT_CRITICAL(&drop_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/Kconfig.projbuild ----
menu "W01 fixed ESP-NOW bench pair"
config W01_SENDER
    bool "Sender role (off=receiver)"
    default n
config W01_PEER_MAC
    string "Other board STA MAC; zero placeholder keeps radio application closed"
    default "00:00:00:00:00:00"
config W01_CHANNEL
    int "Common fixed 2.4 GHz channel (bench subset1..11)"
    range 1 11
    default 6
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