ESP-NOW发出去了为什么灯没亮：确认、重试和同会话去重

# 两块板分别使用不同 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 <fcntl.h>
#include <unistd.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 "reliable_policy.h"
#ifdef CONFIG_W02_SENDER
#define SENDER true
#else
#define SENDER false
#endif
#ifdef CONFIG_W02_DROP_FIRST_ACK
#define DROP_FIRST true
#else
#define DROP_FIRST false
#endif
static const char *TAG="W02";
typedef struct {bool tx;uint8_t mac[6],data[WIRE_BYTES];int size,status;} 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||!d||n!=WIRE_BYTES)return;Event e={.size=n};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 bytes[WIRE_BYTES];wire_encode(f,bytes);esp_err_t e=esp_now_send(peer,bytes,sizeof(bytes));
 ESP_LOGI(TAG,"SEND_API kind=%u seq=%"PRIu32" status=%u err=%s",f->kind,f->seq,f->status,esp_err_to_name(e));
 if(e==ESP_OK){busy=true;radio_at=now;}
}
void app_main(void){
 gpio_config_t output={.pin_bit_mask=1ULL<<GPIO_NUM_6,.mode=GPIO_MODE_OUTPUT};ESP_ERROR_CHECK(gpio_config(&output));ESP_ERROR_CHECK(gpio_set_level(GPIO_NUM_6,0));
 gpio_config_t input={.pin_bit_mask=1ULL<<GPIO_NUM_5,.mode=GPIO_MODE_INPUT};ESP_ERROR_CHECK(gpio_config(&input));
 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_W02_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",MAC2STR(own),SENDER?"sender":"receiver",CONFIG_W02_CHANNEL);
 if(!pair_mac(CONFIG_W02_PEER_MAC,peer)||!memcmp(own,peer,6)){ESP_LOGE(TAG,"CLOSED: replace peer with other board actual STA MAC");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));
 uint64_t boot;esp_fill_random(&boot,sizeof(boot));if(!boot)boot=1;Receiver rx={.own=boot};Sender tx={0};
 uint64_t remote_receiver=0,hello_seen=0,hello_at=0;uint32_t next_seq=0,last_drops=0;bool desired=false,drop_unused=DROP_FIRST,have_last=false;Frame last={0};
 int flags=fcntl(STDIN_FILENO,F_GETFL,0);bool serial_ready=flags>=0&&fcntl(STDIN_FILENO,F_SETFL,flags|O_NONBLOCK)>=0;
 if(!serial_ready)ESP_LOGW(TAG,"UART nonblocking setup unavailable: serial replay disabled; physical button remains usable");
 PairButton button={.candidate=gpio_get_level(GPIO_NUM_5)==0,.stable=true,.since=(uint64_t)esp_timer_get_time()};
 ESP_LOGI(TAG,"BOOT=%016"PRIx64"; receiver RAM session binds one sender boot; reset both after sender reboot. Unencrypted bench only.",boot);
 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){busy=false;ESP_LOGI(TAG,"MAC_CALLBACK status=%d; no application confirmation",e.status);continue;}
   Frame f;if(!wire_decode(e.data,e.size,&f))continue;
   if(SENDER&&f.kind==HELLO){
    if(remote_receiver&&remote_receiver!=f.receiver){if(tx.pending)ESP_LOGW(TAG,"RECEIVER_REBOOT: cancel pending, execution uncertain; never auto replay into new boot");tx.pending=false;have_last=false;}
    remote_receiver=f.receiver;hello_seen=(uint64_t)esp_timer_get_time();continue;
   }
   if(SENDER&&sender_match(&tx,&f)){
    ESP_LOGI(TAG,"APP_ACK seq=%"PRIu32" level=%u status=%u (%s); GPIO/API result, optical unmeasured",f.seq,f.on,f.status,f.status<=DUPLICATE?"CONFIRMED":"REJECTED");tx.pending=false;continue;
   }
   if(!SENDER&&f.kind==COMMAND){
    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 application_count=%"PRIu64,f.seq,status,rx.applications);
    if(status==APPLIED&&drop_unused){drop_unused=false;ESP_LOGW(TAG,"BENCH_DROP_FIRST_APP_ACK; retry must return duplicate without GPIO reapply");continue;}
    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 single radio send; peer retry may recover");
   }
  }
  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 reset; execution uncertain");}
  bool press=pair_button(&button,gpio_get_level(GPIO_NUM_5)==0,now);uint8_t key=0;bool replay=serial_ready&&read(STDIN_FILENO,&key,1)==1&&key=='d';
  if(SENDER&&(press||replay)){
   if(tx.pending||busy||stalled)ESP_LOGW(TAG,"INPUT_IGNORED: command/radio pending or stalled");
   else if(!remote_receiver||now<hello_seen||now-hello_seen>3000000)ESP_LOGW(TAG,"NO_RECENT_RECEIVER: no command started");
   else if(replay){if(have_last&&last.receiver==remote_receiver){sender_begin(&tx,last,now);ESP_LOGI(TAG,"BENCH_REPLAY same boot/seq/value");}else ESP_LOGW(TAG,"NO_COMMAND_TO_REPLAY");}
   else if(next_seq==UINT32_MAX)ESP_LOGE(TAG,"SEQ_EXHAUSTED: reset pair; no sequence wrap");
   else{desired=!desired;last=(Frame){.kind=COMMAND,.on=desired,.sender=boot,.receiver=remote_receiver,.seq=++next_seq};have_last=true;sender_begin(&tx,last,now);}
  }
  unsigned action=sender_action(&tx,now);
  if(SENDER&&action&&!busy&&!stalled){
   if(action==2){tx.pending=false;ESP_LOGE(TAG,"APP_ACK_TIMEOUT after4attempts: failed or executed-with-ACK-lost; seq=%"PRIu32,tx.command.seq);}
   else{sender_attempt(&tx,now);send_frame(peer,&tx.command,now);}
  }
  if(!SENDER&&now>=hello_at&&!busy&&!stalled){hello_at=now+1000000;Frame f={.kind=HELLO,.receiver=boot};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]='2';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]!='2'||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/Kconfig.projbuild ----
menu "W02 bounded ESP-NOW application ACK"
config W02_SENDER
    bool "Sender role (off=receiver)"
    default n
config W02_PEER_MAC
    string "Other board actual STA MAC, zero keeps application closed"
    default "00:00:00:00:00:00"
config W02_CHANNEL
    int "Fixed common channel1..11"
    range 1 11
    default 6
config W02_DROP_FIRST_ACK
    bool "Receiver bench fault: omit first newly applied command ACK once"
    default n
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