Assistentes de IA de Bancada — Visão: ESP32-S3 CAM como sensor do assistente (captura, detecção leve e o que roda on-device)

(a) Conceito e Arquitetura

Câmera em um assistente de bancada não é “tirar foto”: é medir presença, atenção e movimento. Este post trata o módulo ESP32-S3 CAM como um sensor do sistema — quem entra no campo de visão, se há uma pessoa olhando para o dispositivo, se algo mudou no ambiente — e não como um stream de vídeo para a nuvem. Todo o processamento fica no próprio chip.

O pipeline é curto e vale conhecê-lo em detalhe: o sensor (OV2640 ou OV5640) entrega pixels crus via barramento DVP; o periférico de câmera do ESP32-S3 despeja os dados em DMA direto na PSRAM; o encoder JPEG do sensor comprime o quadro (tipicamente 10 a 40 KB em VGA); o resultado é um buffer que o firmware pode enviar pela rede, gravar no cartão SD ou analisar localmente com a biblioteca ESP-DL. Duas operações nunca acontecem no mesmo buffer ao mesmo tempo, e é por isso que a escolha de fb_count e do modo de captura define o comportamento do sistema.

Há dois modos de operação que se excluem na prática. O modo streaming maximiza quadros por segundo: buffers duplos, JPEG, prioridade para entregar imagem. O modo inferência na borda troca taxa de quadros por decisão: um modelo quantizado em int8 roda sobre o quadro e devolve uma caixa, um contador ou um booleano. O truque usado em quase todos os projetos que funcionam é desacoplar os dois — capturar a 15–25 fps e rodar detecção a cada N quadros, mantendo o número de quadros capturados estável enquanto a inferência roda a 3–8 fps.

Por que ESP32-S3 e não o ESP32 clássico: o S3 tem vetorização de instruções (PIE) que acelera modelos convolucionais, suporta PSRAM octal a 80 MHz e tem mais largura de banda de DMA. É a diferença entre detecção facial a 10–20 fps em QVGA e detecção engasgada em 3 fps.

(b) BOM — Lista de Materiais

(c) Wiring & Pinagem

A câmera consome 15 pinos de dados e controle, mais dois de SCCB (o I2C do sensor). O mapeamento varia por placa: use sempre a tabela do fabricante. O exemplo abaixo é o padrão de fato em módulos ESP32-S3 CAM de 24 pinos.

Dois cuidados evitam metade dos problemas. Corrente: o módulo de câmera puxa picos de ~200 mA além do consumo do S3 e do rádio; a linha de 3,3 V precisa de capacitor de 100 µF + 100 nF junto ao módulo, e o LDO deve ter folga. FPC: o cabo flat de 24 pinos é frágil e sensível a dobra; fixe-o com fita e evite movimentá-lo com o sistema ligado — mau contato no FPC se manifesta como erro de inicialização, não como imagem ruim.

(d) Código — captura, medição de FPS e inferência desacoplada

A API é a própria do componente esp32-camera da Espressif. A configuração abaixo é para VGA/JPEG com dois buffers na PSRAM.

#include "esp_camera.h"
#include "esp_timer.h"

static camera_config_t cfg = {
  .pin_pwdn = -1, .pin_reset = -1,
  .pin_xclk = 15,
  .pin_sccb_sda = 4, .pin_sccb_scl = 5,
  .pin_d7 = 16, .pin_d6 = 17, .pin_d5 = 18, .pin_d4 = 12,
  .pin_d3 = 10, .pin_d2 = 8,  .pin_d1 = 9,  .pin_d0 = 11,
  .pin_vsync = 6, .pin_href = 7, .pin_pclk = 13,
  .xclk_freq_hz = 20000000,           // 20 MHz
  .ledc_timer   = LEDC_TIMER_0,
  .ledc_channel = LEDC_CHANNEL_0,
  .pixel_format = PIXFORMAT_JPEG,
  .frame_size   = FRAMESIZE_VGA,      // 640x480
  .jpeg_quality = 12,                 // 0..63 — menor = melhor
  .fb_count     = 2,                  // dois buffers na PSRAM
  .fb_location  = CAMERA_FB_IN_PSRAM,
  .grab_mode    = CAMERA_GRAB_LATEST, // sempre o quadro mais novo
};

void setup() {
  Serial.begin(115200);
  if (esp_camera_init(&cfg) != ESP_OK) {
    Serial.println("Falha ao iniciar a camera");
    return;
  }
}

void loop() {
  static uint32_t frames = 0;
  static int64_t t0 = esp_timer_get_time();

  camera_fb_t *fb = esp_camera_fb_get();   // bloqueia ate haver buffer
  if (!fb) return;

  // aqui vai a inferencia: rode a cada N frames, nao a cada frame
  // ex.: if ((frames % 4) == 0) detecta_pessoa(fb);

  frames++;
  int64_t agora = esp_timer_get_time();
  if (agora - t0 > 2000000) {              // janela de 2 s
    Serial.printf("VGA/JPEG %.1f fps  %u bytes/frame\n",
                  frames * 1e6 / (double)(agora - t0), fb->len);
    frames = 0; t0 = agora;
  }
  esp_camera_fb_return(fb);                // devolve o buffer ao pool
}

Três parâmetros governam tudo. fb_count: com 1 buffer, esp_camera_fb_get() só retorna quando o quadro está completo e você perde captura durante o processamento; com 2, o driver mantém um quadro em escrita e outro pronto, e CAMERA_GRAB_LATEST garante baixa latência em vez de fila. jpeg_quality: a escala é invertida — 12 é qualidade alta e arquivo maior, 30 é qualidade baixa e mais quadros por segundo. frame_size: cada passo de resolução custa banda de PSRAM e tempo de encode.

Taxas realistas em S3 a 240 MHz, PSRAM octal, JPEG, fb_count=2 (valores de ordem de grandeza; variam com clock, barramento e qualidade):

Para presença e contagem, QVGA é o ponto ótimo: o modelo roda em int8 com entrada 320×240, a imagem inteira já é JPEG pequeno e o S3 sobra para o Wi-Fi. Para leitura de display ou medidor, suba a resolução e aceite 2–5 fps — ninguém precisa de um medidor a 30 fps.

(e) Troubleshooting

(f) Aplicações reais — o que roda on-device

Com ESP-DL, tudo abaixo roda sem nuvem: detecção facial (caixa e landmarks), detecção de pessoa, classificação de presença e comparação de similaridade simples entre os embeddings faciais (útil para “é o mesmo usuário que chegou”). O que não roda bem é reconhecimento de texto genérico, detecção de dezenas de classes e qualquer modelo acima de poucos MB — isso fica para um host na rede.

As aplicações que amadureceram em produção são prosaicas: contador de pessoas em porta ou bancada, gatilho de presença para acordar o assistente sem manter o microfone sempre ativo, monitoramento de bancada com snapshot por evento, leitura de medidores e displays analógicos (o projeto AI-on-the-edge-device faz exatamente isso em um ESP32 com um modelo convivendo em flash e PSRAM) e o rastreamento do gimbal — o centroide da caixa facial virando comando de pan/tilt, fechando o loop com o hardware do post anterior.

Vale o registro de engenharia: privacidade aqui não é marketing, é consequência da arquitetura. Se a imagem nunca sai do chip, não há stream para vazar. Publique apenas eventos — “1 pessoa detectada às 14:32” — em vez de quadros, e o assistente de bancada passa a ser um sensor de ambiente, não uma câmera de vigilância.