ESP32-C5 双频 Wi-Fi 怎么比较：配网、覆盖和重连实验方法

idf.py -B build-2g -DSDKCONFIG="$PWD/build-2g/sdkconfig" -DW08_BAND=2 build
idf.py -B build-2g -DSDKCONFIG="$PWD/build-2g/sdkconfig" -DW08_BAND=2 -p YOUR_C5_UART_PORT flash monitor
# 另填5GHz SSID后：
idf.py -B build-5g -DSDKCONFIG="$PWD/build-5g/sdkconfig" -DW08_BAND=5 build
idf.py -B build-5g -DSDKCONFIG="$PWD/build-5g/sdkconfig" -DW08_BAND=5 -p YOUR_C5_UART_PORT flash monitor

// ---- main/config.h ----
// SPDX-License-Identifier: MIT
#pragma once
extern const char w08_ssid[],w08_password[],w08_country[],w08_echo_ip[];

// ---- main/config.c ----
// SPDX-License-Identifier: MIT
#include "config.h"
// Set locally. Do not commit credentials. Each band has its own AP SSID; use the same AP hardware/security/channel width.
const char w08_ssid[]="";
const char w08_password[]="";
// Your actual operating country ISO code, for example CN only when operating in China. Empty disables the experiment.
const char w08_country[]="";
// IPv4 of the wired computer running tools/echo_server.py on the same LAN; no DNS dependency.
const char w08_echo_ip[]="";

// ---- main/w08_link.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdbool.h>
#include <stdint.h>
typedef struct {bool online,disconnected,lost_ip;uint64_t generation;} W08Link;
static inline void w08_got_ip(W08Link *s){s->online=true;s->generation++;}
static inline void w08_disconnected(W08Link *s){s->online=false;s->disconnected=true;}
static inline void w08_lost_ip(W08Link *s){s->online=false;s->lost_ip=true;}
// Caller holds the same critical section used for updates; consuming flags cannot erase a concurrent update.
static inline W08Link w08_snapshot(W08Link *s){W08Link r=*s;s->disconnected=false;s->lost_ip=false;return r;}

// ---- main/w08_wire.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#define W08_SIZE 24
static inline void w08_data(uint8_t p[W08_SIZE],uint64_t boot,uint32_t seq,uint64_t sent_us){
    memcpy(p,"W08D",4);
    for(unsigned i=0;i<8;i++){p[4+i]=(uint8_t)(boot>>(56-i*8));p[16+i]=(uint8_t)(sent_us>>(56-i*8));}
    for(unsigned i=0;i<4;i++)p[12+i]=(uint8_t)(seq>>(24-i*8));
}
static inline int w08_ack(uint8_t *out,const uint8_t *in,size_t n){
    if(n!=W08_SIZE || memcmp(in,"W08D",4))return 0;
    memcpy(out,in,W08_SIZE);out[3]='A';return 1;
}
static inline int w08_match(const uint8_t *ack,size_t n,const uint8_t expected[W08_SIZE]){
    return n==W08_SIZE && !memcmp(ack,"W08A",4) && !memcmp(ack+4,expected+4,W08_SIZE-4);
}

// ---- main/main.c ----
// SPDX-License-Identifier: MIT
#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/select.h>
#include "lwip/inet.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_timer.h"
#include "esp_random.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#include "config.h"
#include "w08_wire.h"
#include "w08_link.h"
#ifndef W08_BAND
#define W08_BAND 2
#endif
static W08Link link_state;
static portMUX_TYPE link_mux=portMUX_INITIALIZER_UNLOCKED;
static const char *TAG="W08";
static uint64_t mono(void){return (uint64_t)esp_timer_get_time();}
static void event(void *arg,esp_event_base_t base,int32_t id,void *data){
    (void)arg;
    if(base==WIFI_EVENT && id==WIFI_EVENT_STA_DISCONNECTED){
        const wifi_event_sta_disconnected_t *d=data;
        portENTER_CRITICAL(&link_mux);w08_disconnected(&link_state);portEXIT_CRITICAL(&link_mux);
        ESP_LOGW(TAG,"DISCONNECT mono_us=%" PRIu64 " reason=%u",mono(),d->reason);
    }else if(base==IP_EVENT && id==IP_EVENT_STA_GOT_IP){
        portENTER_CRITICAL(&link_mux);w08_got_ip(&link_state);portEXIT_CRITICAL(&link_mux);
        ESP_LOGI(TAG,"GOT_IP mono_us=%" PRIu64,mono());
    }else if(base==IP_EVENT && id==IP_EVENT_STA_LOST_IP){
        portENTER_CRITICAL(&link_mux);w08_lost_ip(&link_state);portEXIT_CRITICAL(&link_mux);
    }
}
static void ap_record(void){
    wifi_ap_record_t a={0};wifi_country_t c={0};wifi_band_mode_t mode;
    const esp_err_t ret=esp_wifi_sta_get_ap_info(&a);
    if(ret!=ESP_OK){ESP_LOGW(TAG,"AP_RECORD_UNAVAILABLE ret=%s (connection may have changed)",esp_err_to_name(ret));return;}
    ESP_ERROR_CHECK(esp_wifi_get_country(&c));ESP_ERROR_CHECK(esp_wifi_get_band_mode(&mode));
    ESP_LOGI(TAG,"AP mono_us=%" PRIu64 " selected=%dG mode=%d channel=%u rssi_dbm=%d phy_11ax=%u country=%.3s policy=%d bssid=%02x:%02x:%02x:%02x:%02x:%02x",mono(),W08_BAND,mode,a.primary,a.rssi,a.phy_11ax,c.cc,c.policy,a.bssid[0],a.bssid[1],a.bssid[2],a.bssid[3],a.bssid[4],a.bssid[5]);
}
static void probe(int sock,const struct sockaddr_in *peer,uint64_t boot,uint32_t seq){
    uint8_t tx[W08_SIZE],rx[128];const uint64_t started=mono();
    w08_data(tx,boot,seq,started);
    const int sent=sendto(sock,tx,sizeof tx,0,(const struct sockaddr*)peer,sizeof *peer);
    bool ack=false;
    while(sent==(int)sizeof tx && mono()-started<500000){
        fd_set fds;FD_ZERO(&fds);FD_SET(sock,&fds);struct timeval tv={.tv_sec=0,.tv_usec=50000};
        if(select(sock+1,&fds,NULL,NULL,&tv)<=0)continue;
        struct sockaddr_in from={0};socklen_t len=sizeof from;
        const int n=recvfrom(sock,rx,sizeof rx,0,(struct sockaddr*)&from,&len);
        if(n<0)break;
        if(from.sin_addr.s_addr!=peer->sin_addr.s_addr || from.sin_port!=peer->sin_port)continue;
        if(w08_match(rx,(size_t)n,tx)){ack=true;break;}
    }
    ESP_LOGI(TAG,"PROBE mono_us=%" PRIu64 " boot=%016" PRIx64 " seq=%" PRIu32 " ack=%d elapsed_us=%" PRIu64 " send_errno=%d",mono(),boot,seq,ack,mono()-started,sent<0?errno:0);
}
void app_main(void){
    struct sockaddr_in peer={.sin_family=AF_INET,.sin_port=htons(45680)};
    if(!w08_ssid[0] || !w08_password[0] || strlen(w08_country)!=2 || inet_pton(AF_INET,w08_echo_ip,&peer.sin_addr)!=1){
        ESP_LOGW(TAG,"CONFIG_DISABLED: set actual SSID/password/country/echo IPv4 in main/config.c; no Wi-Fi initialized");return;
    }
    if(strlen(w08_ssid)>32 || strlen(w08_password)<8 || strlen(w08_password)>63){ESP_LOGE(TAG,"CONFIG_INVALID: WPA2/WPA3 personal passphrase, SSID <=32 bytes");return;}
    ESP_ERROR_CHECK(nvs_flash_init());ESP_ERROR_CHECK(esp_netif_init());ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT,ESP_EVENT_ANY_ID,event,NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT,ESP_EVENT_ANY_ID,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));
    ESP_ERROR_CHECK(esp_wifi_set_country_code(w08_country,true));
    wifi_config_t cfg={0};memcpy(cfg.sta.ssid,w08_ssid,strlen(w08_ssid));memcpy(cfg.sta.password,w08_password,strlen(w08_password));
    cfg.sta.threshold.authmode=WIFI_AUTH_WPA2_PSK;cfg.sta.pmf_cfg.capable=true;
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA,&cfg));ESP_ERROR_CHECK(esp_wifi_start());
    // set_band_mode requires started Wi-Fi. STA_START handler intentionally never calls connect.
    ESP_ERROR_CHECK(esp_wifi_set_band_mode(W08_BAND==5?WIFI_BAND_MODE_5G_ONLY:WIFI_BAND_MODE_2G_ONLY));
    ESP_ERROR_CHECK(esp_wifi_set_bandwidth(WIFI_IF_STA,WIFI_BW_HT20));ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
    const uint64_t boot=((uint64_t)esp_random()<<32)|esp_random();
    int sock=-1;uint64_t socket_generation=0;
    bool attempting=false,was_online=false;uint64_t deadline=0,next_try=0,next_probe=0;uint32_t backoff_ms=1000,seq=0;
    for(;;){
        portENTER_CRITICAL(&link_mux);const W08Link bits=w08_snapshot(&link_state);portEXIT_CRITICAL(&link_mux);
        if(bits.disconnected || bits.lost_ip){
            if(sock>=0){close(sock);sock=-1;}
            attempting=false;next_try=mono()+(uint64_t)backoff_ms*1000;
            // A later GOT_IP in this snapshot supersedes the earlier LOST_IP.
            if(bits.lost_ip && !bits.online)(void)esp_wifi_disconnect();
            if(backoff_ms<16000)backoff_ms*=2;
        }
        const uint64_t now=mono();const bool online=bits.online;
        if(online){
            attempting=false;backoff_ms=1000;
            if(!was_online || bits.generation!=socket_generation){
                if(sock>=0){close(sock);sock=-1;}
                socket_generation=bits.generation;ap_record();next_probe=now;
            }
            if(now>=next_probe){
                if(sock<0)sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
                if(sock>=0)probe(sock,&peer,boot,++seq);
                else ESP_LOGE(TAG,"SOCKET_FAILED errno=%d; resource failure is not an RF coverage result",errno);
                next_probe=mono()+2000000;
            }
        }else{
            if(was_online){attempting=false;next_try=now;backoff_ms=1000;}
            if(attempting && now>=deadline){attempting=false;(void)esp_wifi_disconnect();next_try=now+(uint64_t)backoff_ms*1000;ESP_LOGW(TAG,"CONNECT_TIMEOUT");}
            if(!attempting && now>=next_try){
                const esp_err_t ret=esp_wifi_connect();attempting=ret==ESP_OK;deadline=now+15000000;
                if(!attempting){next_try=now+(uint64_t)backoff_ms*1000;if(backoff_ms<16000)backoff_ms*=2;}
                ESP_LOGI(TAG,"CONNECT_TRY mono_us=%" PRIu64 " ret=%s",now,esp_err_to_name(ret));
            }
        }
        was_online=online;vTaskDelay(pdMS_TO_TICKS(20));
    }
}

# ---- tools/echo_server.py ----
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""LAN UDP echo endpoint, not evidence that a board connected. Bind an explicit local IPv4."""
import argparse,socket,struct,time

def ack(data):
    return b"W08A"+data[4:] if len(data)==24 and data[:4]==b"W08D" else None

def main():
    p=argparse.ArgumentParser();p.add_argument("--bind",required=True);p.add_argument("--port",type=int,default=45680);a=p.parse_args()
    with socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as s:
        s.bind((a.bind,a.port));print("LISTEN",s.getsockname(),flush=True)
        while True:
            data,peer=s.recvfrom(2048);reply=ack(data)
            if reply is None:print("REJECT",peer,len(data),flush=True);continue
            s.sendto(reply,peer)
            boot,seq,mono=struct.unpack("!QIQ",data[4:])
            print("ACK",time.monotonic_ns(),peer,f"{boot:016x}",seq,mono,flush=True)
if __name__=="__main__":main()

# ---- tools/compare.py ----
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Analyze operator records. No generated observations; headers-only input is an error."""
import argparse,csv,json,math,re,statistics

def number(s,low,high):
    v=float(s)
    if not math.isfinite(v) or not low<=v<=high:raise ValueError("nonfinite/out-of-range number")
    return v

def analyze(path):
    groups={};seen=set()
    with open(path,newline="",encoding="utf-8") as f:
        for row in csv.DictReader(f):
            band=row['band']
            if band not in ('2','5'):raise ValueError('band must be 2 or 5')
            trial,point,ap=row['trial'],row['point'],row['ap_id']
            if not all((trial,point,ap,row['obstacle'])):raise ValueError('record environment identifiers')
            if not re.fullmatch('[0-9a-f]{64}',row['firmware_sha256']):raise ValueError('firmware SHA256')
            if not re.fullmatch('[0-9a-f]{16}',row['boot']):raise ValueError('boot 16 lowercase hex')
            if row['width_mhz']!='20':raise ValueError('this comparison fixes 20 MHz')
            ch=int(row['channel'])
            if not (1<=ch<=14 if band=='2' else 32<=ch<=177):raise ValueError('channel/band mismatch; this does not certify regional legality')
            distance=number(row['distance_m'],0,100000)
            seq=int(row['seq'])
            if not 1<=seq<=0xffffffff:raise ValueError('seq range')
            key=(trial,point,band,seq)
            if key in seen:raise ValueError('duplicate record')
            seen.add(key)
            if row['ack'] not in ('0','1'):raise ValueError('ack binary')
            ack=row['ack']=='1'
            rtt=number(row['rtt_ms'],0,float('inf')) if ack else None
            if not ack and row['rtt_ms']:raise ValueError('failed probe must not invent RTT')
            rssi=number(row['rssi_dbm'],-127,0)
            reconnect=number(row['reconnect_ms'],0,86400000) if row['reconnect_ms'] else None
            k=(trial,point,band)
            g=groups.setdefault(k,{'environment':(ap,distance,row['obstacle']),'firmware':row['firmware_sha256'],'boot':row['boot'],'rows':[]})
            if g['environment']!=(ap,distance,row['obstacle']) or g['firmware']!=row['firmware_sha256'] or g['boot']!=row['boot']:raise ValueError('mixed environment/firmware inside group')
            g['rows'].append((seq,ack,rtt,rssi,reconnect))
    if not groups:raise ValueError('no observations; blank template is not a result')
    out=[]
    for trial,point in sorted({(t,p) for t,p,b in groups}):
        a,b=groups.get((trial,point,'2')),groups.get((trial,point,'5'))
        if a is None or b is None:raise ValueError('pair both bands at every trial/point')
        if a['environment']!=b['environment'] or len(a['rows'])!=len(b['rows']):raise ValueError('unequal environment/probe count')
        for band,g in [('2',a),('5',b)]:
            seqs=sorted(x[0] for x in g['rows'])
            if seqs!=list(range(seqs[0],seqs[0]+len(seqs))):raise ValueError('missing probe rows')
            good=[x[2] for x in g['rows'] if x[1]]
            out.append({'trial':trial,'point':point,'band':band,'attempts':len(seqs),'acked':len(good),'success_fraction':len(good)/len(seqs),'median_rtt_ms':statistics.median(good) if good else None,'median_rssi_dbm':statistics.median(x[3] for x in g['rows']),'reconnect_ms':[x[4] for x in g['rows'] if x[4] is not None]})
    return out
if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('csv');a=p.parse_args()
    print(json.dumps(analyze(a.csv),ensure_ascii=False,indent=2,allow_nan=False))