ESP32-S3拍第一张照片：从板级引脚到可解码JPEG

# ---- main/idf_component.yml ----
dependencies:
  idf: "==5.5.5"
  espressif/esp32-camera: "==2.1.8"

# ---- sdkconfig.defaults ----
CONFIG_IDF_TARGET="esp32s3"
CONFIG_ESPTOOLPY_FLASHSIZE_8MB=y
CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
CONFIG_SPIRAM=y
CONFIG_SPIRAM_MODE_OCT=y
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_SPIRAM_USE_MALLOC=y
# CONFIG_SPIRAM_IGNORE_NOTFOUND is not set
# CONFIG_CAMERA_PSRAM_DMA is not set
CONFIG_OV2640_SUPPORT=y
CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y
CONFIG_ESP_CONSOLE_SECONDARY_NONE=y
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"

# ---- partitions.csv ----
# Name,Type,SubType,Offset,Size,Flags
nvs,data,nvs,0x9000,0x6000,
phy_init,data,phy,0xf000,0x1000,
factory,app,factory,0x10000,0x400000,

// ---- main/camera_board.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdio.h>
#include "esp_camera.h"
#include "esp_psram.h"
/* Official ESP32-S3-EYE-MB_V2.2, onboard OV2640. Not generic S3 WROOM. */
static inline esp_err_t eye_camera_init(void){
 size_t psram=esp_psram_get_size();printf("PSRAM reported_bytes=%zu required=8388608; physical boot status only when actually run\n",psram);
 if(psram!=8388608)return ESP_ERR_INVALID_SIZE;
 camera_config_t c={.pin_pwdn=-1,.pin_reset=-1,.pin_xclk=15,.pin_sccb_sda=4,.pin_sccb_scl=5,
 .pin_d0=11,.pin_d1=9,.pin_d2=8,.pin_d3=10,.pin_d4=12,.pin_d5=18,.pin_d6=17,.pin_d7=16,
 .pin_vsync=6,.pin_href=7,.pin_pclk=13,.xclk_freq_hz=20000000,.ledc_timer=LEDC_TIMER_0,.ledc_channel=LEDC_CHANNEL_0,
 .pixel_format=PIXFORMAT_JPEG,.frame_size=FRAMESIZE_QVGA,.jpeg_quality=16,.fb_count=1,.fb_location=CAMERA_FB_IN_PSRAM,.grab_mode=CAMERA_GRAB_WHEN_EMPTY,.sccb_i2c_port=0,.jpeg_buffer_size=0};
 esp_err_t e=esp_camera_init(&c);if(e!=ESP_OK)return e;
 sensor_t *s=esp_camera_sensor_get();if(!s||s->id.PID!=OV2640_PID){printf("SENSOR_SCOPE_MISMATCH expectedOV2640; not a compatible sensor claim\n");(void)esp_camera_deinit();return ESP_ERR_NOT_SUPPORTED;}
 printf("SENSOR PID=0x%04x; no LCD/SD/microphone init; GPIO3 untouched\n",s->id.PID);return ESP_OK;
}

// ---- main/frame_policy.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <string.h>
#define FRAME_CAP 262144U
/* Marker/cap check only; this is NOT a JPEG decoder or image quality test. */
static inline bool frame_markers(const uint8_t *p,size_t n){return p&&n>=4&&n<=FRAME_CAP&&p[0]==0xff&&p[1]==0xd8&&p[n-2]==0xff&&p[n-1]==0xd9;}
static inline uint32_t frame_crc32(const uint8_t *p,size_t n){uint32_t c=0xffffffffU;for(size_t i=0;i<n;i++){c^=p[i];for(unsigned j=0;j<8;j++)c=(c>>1)^(0xedb88320U&(0U-(c&1U)));}return c^0xffffffffU;}
typedef struct {char text[32];size_t used;bool rejected;} CaptureLine;
static inline bool capture_feed(CaptureLine *s,unsigned char c){
 if(c=='\r'||c=='\n'){s->text[s->used]=0;bool yes=!s->rejected&&!strcmp(s->text,"CAPTURE");s->used=0;s->rejected=false;return yes;}
 if(c<32||c>126)s->rejected=true;
 if(!s->rejected){if(s->used<sizeof(s->text)-1)s->text[s->used++]=(char)c;else s->rejected=true;}
 return false;
}

// ---- main/main.c ----
/* SPDX-License-Identifier: MIT */
#include <stdio.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_timer.h"
#include "esp_heap_caps.h"
#include "mbedtls/base64.h"
#include "camera_board.h"
#include "frame_policy.h"
static uint32_t capture_id;
static void capture(void){
 /* Discard one pending frame, then request another. Not an exposure timestamp guarantee. */
 camera_fb_t *old=esp_camera_fb_get();if(!old){puts("V01_ERROR discard_get_null");return;}esp_camera_fb_return(old);
 int64_t started=esp_timer_get_time();camera_fb_t *fb=esp_camera_fb_get();int64_t elapsed=esp_timer_get_time()-started;
 if(!fb){puts("V01_ERROR frame_get_null");return;}
 if(fb->format!=PIXFORMAT_JPEG||fb->width!=320||fb->height!=240||!frame_markers(fb->buf,fb->len)){printf("V01_ERROR format_size_or_markers len=%zu width=%zu height=%zu\n",fb->len,fb->width,fb->height);esp_camera_fb_return(fb);return;}
 uint32_t id=++capture_id,crc=frame_crc32(fb->buf,fb->len);
 printf("V01_BEGIN id=%"PRIu32" len=%zu width=%zu height=%zu crc=%08"PRIx32" capture_us=%"PRId64"\n",id,fb->len,fb->width,fb->height,crc,elapsed);
 bool failed=false;unsigned sequence=0;
 for(size_t offset=0;offset<fb->len;offset+=180){size_t n=fb->len-offset;if(n>180)n=180;unsigned char text[244];size_t written=0;
  if(mbedtls_base64_encode(text,sizeof text,&written,fb->buf+offset,n)!=0){failed=true;break;}text[written]=0;
  if(printf("V01_DATA id=%"PRIu32" seq=%u %s\n",id,sequence++,(char*)text)<0){failed=true;break;}vTaskDelay(1);
 }
 if(!failed)printf("V01_END id=%"PRIu32"\n",id);else puts("V01_ERROR console_encode_or_write");
 esp_camera_fb_return(fb);fflush(stdout);
 printf("V01_STATUS free_internal=%zu largest_internal=%zu; USB console completion is not host receipt\n",heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT));
}
void app_main(void){
 esp_err_t e=eye_camera_init();if(e!=ESP_OK){printf("V01_INIT_FAILED %s; retain log, fix board/config/power then RESET\n",esp_err_to_name(e));return;}
 puts("V01_READY officialS3EYEMBv2.2 OV2640 JPEG320x240 quality16 onePSRAMfb; exact CAPTURE line. NativeUSBSerialJTAG19/20, no UART bridge.");
 CaptureLine line={0};for(;;){int c=getchar();if(c==EOF){clearerr(stdin);vTaskDelay(pdMS_TO_TICKS(20));continue;}if(capture_feed(&line,(unsigned char)c))capture();}
}

# ---- tools/capture.py ----
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Receive exact V01 framing, decode JPEG on host, never overwrite an output.
A valid payload is not authenticated camera origin or proof of exposure time.
"""
import argparse,base64,binascii,hashlib,io,json,pathlib,re,time,zlib
from PIL import Image
CAP=262144
class Capture:
 def __init__(self):self.meta=None;self.parts=bytearray();self.sequence=0;self.complete=False
 def feed(self,line):
  if len(line)>512:raise ValueError('line exceeds512 bytes')
  if b'SYNTHETIC' in line:return 'synthetic-marker'
  text=line.decode('ascii').rstrip('\r\n')
  if text.startswith('V01_ERROR') or text.startswith('V01_INIT_FAILED'):raise ValueError(text)
  if text.startswith('V01_BEGIN'):
   if self.meta is not None:raise ValueError('second BEGIN before END')
   m=re.fullmatch(r'V01_BEGIN id=(\d+) len=(\d+) width=(\d+) height=(\d+) crc=([0-9a-f]{8}) capture_us=(\d+)',text)
   if not m:raise ValueError('malformed BEGIN')
   ident,n,width,height,crc,elapsed=m.groups();ident,n,width,height,elapsed=map(int,[ident,n,width,height,elapsed]);
   if not 0<=ident<=0xffffffff or not 4<=n<=CAP or (width,height)!=(320,240) or elapsed>0x7fffffffffffffff:raise ValueError('BEGIN outside fixed V01 bounds')
   self.meta={'id':ident,'bytes':n,'width':width,'height':height,'crc32':crc,'captureReportedUs':elapsed};return None
  if text.startswith('V01_DATA'):
   if not self.meta or self.complete:raise ValueError('DATA without active BEGIN')
   m=re.fullmatch(r'V01_DATA id=(\d+) seq=(\d+) ([A-Za-z0-9+/]+={0,2})',text)
   if not m or int(m[1])!=self.meta['id'] or int(m[2])!=self.sequence:raise ValueError('DATA identity/sequence mismatch')
   block=base64.b64decode(m[3],validate=True)
   if not 1<=len(block)<=180 or len(self.parts)+len(block)>self.meta['bytes']:raise ValueError('payload exceeds declared limit')
   self.parts.extend(block);self.sequence+=1;return None
  if text.startswith('V01_END'):
   if not self.meta or self.complete or text!='V01_END id='+str(self.meta['id']):raise ValueError('END identity/state mismatch')
   data=bytes(self.parts)
   if len(data)!=self.meta['bytes'] or f'{zlib.crc32(data):08x}'!=self.meta['crc32']:raise ValueError('payload length/CRC mismatch')
   if data[:2]!=b'\xff\xd8' or data[-2:]!=b'\xff\xd9':raise ValueError('JPEG SOI/EOI missing')
   with Image.open(io.BytesIO(data)) as image:
    if image.format!='JPEG' or image.size!=(320,240):raise ValueError('decoded JPEG outside fixed scope')
    image.load() # Actual host decoder, not marker-only validation.
   self.complete=True;return data
  return None

def main():
 p=argparse.ArgumentParser();source=p.add_mutually_exclusive_group(required=True);source.add_argument('--port');source.add_argument('--trace',type=pathlib.Path);p.add_argument('--out',required=True,type=pathlib.Path);p.add_argument('--timeout',type=float,default=30);p.add_argument('--provenance',choices=['hardware','synthetic'],required=True);a=p.parse_args()
 if not 0<a.timeout<=300:p.error('timeout must be in(0,300] seconds')
 if a.out.exists():p.error('output exists; refusing overwrite')
 capture=Capture();deadline=time.monotonic()+a.timeout;serial=None;stream=None;payload=None;synthetic=False
 try:
  if a.trace:
   if a.trace.stat().st_size>2097152:raise ValueError('trace exceeds2MiB')
   if b'SYNTHETIC' in a.trace.read_bytes():
    synthetic=True
    if a.provenance!='synthetic':raise ValueError('SYNTHETIC trace cannot be labeled hardware')
   stream=a.trace.open('rb')
  else:
   import serial as serial_module
   serial=serial_module.Serial(a.port,115200,timeout=.25,write_timeout=2);serial.write(b'CAPTURE\n');serial.flush();stream=serial
  pending=b''
  while time.monotonic()<deadline:
   piece=stream.readline(513)
   line=pending+piece
   if not piece:
    if a.trace:break
    continue
   if len(line)>512:raise ValueError('line exceeds512 bytes')
   if not line.endswith(b'\n'):
    pending=line
    continue
   pending=b''
   result=capture.feed(line)
   if result=='synthetic-marker':
    synthetic=True
    if a.provenance!='synthetic':raise ValueError('SYNTHETIC trace cannot be labeled hardware')
   elif isinstance(result,bytes):payload=result;break
  if payload is None:raise ValueError('incomplete frame or deadline; no output written')
  if synthetic and a.provenance!='synthetic':raise ValueError('synthetic provenance mismatch')
  with a.out.open('xb') as f:f.write(payload)
  print(json.dumps({'provenanceProvidedByOperator':a.provenance,'containsSyntheticTraceMarker':synthetic,'scope':'Host JPEG decode and framing/CRC only; camera origin, USB electrical, image quality and exposure time are not authenticated.','reported':capture.meta,'sha256':hashlib.sha256(payload).hexdigest(),'output':str(a.out)},indent=2));return 0
 except (ValueError,OSError,UnicodeError,binascii.Error,Image.DecompressionBombError) as error:print(str(error));return 2
 finally:
  if stream:stream.close()
if __name__=='__main__':raise SystemExit(main())

clang -std=c11 -Wall -Wextra -Werror -g -fsanitize=address,undefined -I main host/policy_test.c -o /tmp/v01-policy
/tmp/v01-policy
python host/check_capture.py --out /tmp/v01-SYNTHETIC-check