ESP32 视觉分拣实验：先过自检，再接受一次有限动作

# ---- camera/main/idf_component.yml ----
dependencies:
  idf: "==5.5.5"
  espressif/esp-dl: "==3.3.8"
  espressif/dl_fft: "==0.8.0"
  espressif/esp32-camera: "==2.1.8"
  espressif/esp_jpeg: "==1.3.1"
  espressif/esp_new_jpeg: "==1.0.2"

// ---- shared/decision.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdint.h>
#include <stddef.h>
#include <math.h>
namespace v10 {
/* Uncalibrated logit margin, not a probability or camera accuracy claim. */
inline int decide(int a,int b,int exponent){if(a < -128||a>127||b < -128||b>127||exponent < -32||exponent>16)return -1;double gap=ldexp((double)(a>b?a-b:b-a),exponent);if(a==b||gap<2.0)return -1;return b>a?1:0;}
/* Central64x64 nearest-neighbour to16x16. No histogram/contrast correction. */
inline bool pixels(const uint8_t*src,size_t len,unsigned w,unsigned h,int8_t*out){if(!src||!out||w!=160||h!=120||len!=19200)return false;for(unsigned y=0;y<16;y++)for(unsigned x=0;x<16;x++){unsigned p=src[(28+y*4+2)*160+(48+x*4+2)];unsigned q=(p*128U+127U)/255U;out[y*16+x]=(int8_t)(q>127?127:q);}return true;}
}

// ---- actuator/main/main.cpp ----
/* SPDX-License-Identifier: MIT */
#include <cstdio>
#include "driver/gpio.h"
#include "driver/ledc.h"
#include "esp_timer.h"
#include "esp_random.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "actuator.h"
#include "transport.h"
static uint64_t nonce(){uint64_t n;do{n=((uint64_t)esp_random()<<32)|esp_random();}while(!n);return n;}
static esp_err_t apply(bool active,uint16_t pulse){if(!active)return ledc_stop(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0,0);esp_err_t e=ledc_set_duty(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0,v10::duty(pulse));return e==ESP_OK?ledc_update_duty(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0):e;}
extern "C" void app_main(){
 gpio_config_t in={};in.pin_bit_mask=1ULL<<GPIO_NUM_5;in.mode=GPIO_MODE_INPUT;ESP_ERROR_CHECK(gpio_config(&in));
 ledc_timer_config_t t={};t.speed_mode=LEDC_LOW_SPEED_MODE;t.duty_resolution=LEDC_TIMER_14_BIT;t.timer_num=LEDC_TIMER_0;t.freq_hz=50;t.clk_cfg=LEDC_USE_APB_CLK;ESP_ERROR_CHECK(ledc_timer_config(&t));
 ledc_channel_config_t c={};c.gpio_num=GPIO_NUM_6;c.speed_mode=LEDC_LOW_SPEED_MODE;c.channel=LEDC_CHANNEL_0;c.timer_sel=LEDC_TIMER_0;c.duty=0;c.hpoint=0;ESP_ERROR_CHECK(ledc_channel_config(&c));ESP_ERROR_CHECK(apply(false,1500));
 printf("V10 FS90 POSITION SERVO ONLY; external5V; signal is not power removal. No encoder/jam sensor. UART0 bridge115200.\n");
 if(v10::transport_init()!=ESP_OK)return;
 v10::Actuator s(nonce());v10::Lines lines;v10::Tx tx;bool was=false,fault_reported=false;uint16_t prior=0;uint64_t prior_session=0;
 for(;;){
  uint64_t now=(uint64_t)esp_timer_get_time();s.tick(gpio_get_level(GPIO_NUM_5)==0,now);
  if(lines.expire(now))s.revoke(10);
  char input[64];int n=v10::read_bytes(input,sizeof input);if(n<0)s.api_fault();
  for(int k=0;k<n;k++){v10::Msg m;int rc=lines.feed(input[k],m,(uint64_t)esp_timer_get_time());if(rc<0)s.revoke(10);else if(rc>0){
    /* Resample raw ARM and deadlines at every command, not a stale loop sample. */
    now=(uint64_t)esp_timer_get_time();s.tick(gpio_get_level(GPIO_NUM_5)==0,now);
    auto answer=s.receive(m,now,nonce());if(!tx.queue(answer))s.api_fault();
  }}
  /* Stop/heartbeat also checked after parsing. No other task owns this channel. */
  s.tick(gpio_get_level(GPIO_NUM_5)==0,(uint64_t)esp_timer_get_time());
  if(s.active!=was||(s.active&&s.pulse!=prior)){if(apply(s.active,s.pulse)!=ESP_OK){s.api_fault();(void)apply(false,1500);}was=s.active;prior=s.pulse;}
  /* Explicit STOP is already known to the bridge; no unsolicited echo may
     poison its next SESSION. Local timeout/parse/gap/API faults still report. */
  if((prior_session&&!s.session&&s.reason!=7)||(s.fault&&!fault_reported)){
   if(!tx.queue({v10::STOP,s.boot,0,0,0,(int)s.reason,0,0}))s.api_fault();
   fault_reported=s.fault;
  }
  prior_session=s.session;
  if(!tx.poll())s.api_fault();
  if(s.fault){(void)apply(false,1500); /* sticky RESET-only API fault */}
  vTaskDelay(pdMS_TO_TICKS(10));
 }
}

# ---- tools/analyze_run.py ----
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""All50 attempts remain denominator. Partial runs have no accuracy claims."""
import argparse,csv,json,math
FIELDS=['sample','truth','prediction','raw0','raw1','exponent','margin','command','observed_bin','jam','error','recovery','camera_boot','actuator_boot','session','physical_observer_note']
def analyze(path):
    with open(path,newline='')as f:
        reader=csv.DictReader(f)
        if reader.fieldnames!=FIELDS:raise ValueError('schema mismatch')
        rows=list(reader)
    if len(rows)>50:raise ValueError('at most50')
    for n,r in enumerate(rows,1):
        if r['sample']!=str(n):raise ValueError('continuous sample1..N required; no delete/reorder')
        if r['truth']!=('circle'if n%2 else 'square'):raise ValueError('preassigned odd circle/even square')
        if r['prediction']not in ['circle','square','reject','unavailable']or r['command']not in ['routeA','routeB','none','none_or_unconfirmed']:raise ValueError('result vocabulary')
        if r['observed_bin']not in ['A','B','review','unknown']or r['jam']not in ['yes','no']:raise ValueError('physical observation required')
        if any(not r[x]for x in ['recovery','physical_observer_note','camera_boot','actuator_boot','session']):raise ValueError('missing provenance/observation')
        if r['prediction']in ['circle','square','reject']:
            raw=[int(r[k])for k in ['raw0','raw1','exponent']]
            if any(str(v)!=r[k]for v,k in zip(raw,['raw0','raw1','exponent']))or not(-128<=raw[0]<=127 and -128<=raw[1]<=127 and -32<=raw[2]<=16):raise ValueError('score contract')
            gap=math.ldexp(abs(raw[0]-raw[1]),raw[2]);margin=float(r['margin'])
            pred='reject'if raw[0]==raw[1]or gap<2.0 else('square'if raw[1]>raw[0]else'circle')
            if not math.isfinite(margin)or margin!=gap or pred!=r['prediction']:raise ValueError('prediction/margin inconsistent with raw logits')
            command='none'if pred=='reject'else('routeA'if pred=='circle'else'routeB')
            if r['command']!=command:raise ValueError('command inconsistent with prediction')
        elif not r['error']:raise ValueError('unavailable needs recorded error')
    complete=len(rows)==50
    correct=sum(r['prediction']==r['truth']for r in rows)
    routed=sum(r['command']in ['routeA','routeB']for r in rows)
    end_to_end=sum(r['prediction']==r['truth']and r['command']==('routeA'if r['truth']=='circle'else'routeB')and r['observed_bin']==('A'if r['truth']=='circle'else'B')and r['jam']=='no'and not r['error']for r in rows)
    return {'attempts':len(rows),'qualified50':complete,'requestedRoutes':routed,'rejectedOrUnavailable':sum(r['prediction']in ['reject','unavailable']for r in rows),'jamRows':sum(r['jam']=='yes'for r in rows),'errorRows':sum(bool(r['error'])for r in rows),'predictionCorrectOver50':correct/50 if complete else None,'endToEndOver50':end_to_end/50 if complete else None,'scope':'Only supplied operator CSV; does not authenticate physical origin, infer confidence calibration or detect unreported jams.'}
def main():
    p=argparse.ArgumentParser(description=__doc__);p.add_argument('csv');a=p.parse_args()
    try:print(json.dumps(analyze(a.csv),indent=2))
    except (ValueError,OSError)as e:p.exit(2,str(e)+'\n')
if __name__=='__main__':main()