Scheda di sviluppo ESP32-CAM, Wi-Fi, Bluetooth, OV5640 5MP

La scheda ESP32-CAM con telecamera OV5640 da 5MP è un modulo di sviluppo ESP32 con telecamera integrata, utilizzato per acquisire e trasmettere immagini via WiFi senza bisogno di altri componenti aggiuntivi. Questo tutorial usa proprio la scheda ESP32-CAM AI-Thinker come piattaforma, insieme ad Arduino IDE, per caricare un programma che avvia la telecamera e offre un semplice flusso video tramite un server web interno.

Poiché la scheda non ha una porta USB propria, per caricare il programma serve un adattatore USB-seriale esterno, di tipo FT232, collegato ai pin seriali della scheda.

Come funziona:

Il sensore OV5640 acquisisce l'immagine sulle 8 linee dati parallele D0-D7, sincronizzate dai segnali XCLK, PCLK, VSYNC e HREF, mentre la configurazione del sensore (risoluzione, esposizione, bilanciamento del bianco) avviene tramite un collegamento I2C/SCCB sulle linee SIOD e SIOC. Il sensore comprime l'immagine in formato JPEG prima che l'ESP32 la prelevi, riducendo molto il volume di dati rispetto a un'immagine raw.

Alla risoluzione SVGA (800 x 600 pixel), un fotogramma JPEG pesa, a seconda della scena e del livello di qualità scelto nel codice, circa 20 - 50 KB. Dividendo una tipica larghezza di banda WiFi locale di alcune centinaia di KB/s per questa dimensione di fotogramma si ottiene un flusso di alcuni fotogrammi al secondo, sufficiente per la videosorveglianza, ma ben al di sotto della capacità massima del sensore di 2592 x 1944 pixel, riservata alle foto singole.

Collegamento:

La programmazione della scheda avviene tramite un adattatore FT232 collegato ai pin seriali dell'ESP32-CAM, con il jumper di tensione dell'adattatore su 5V, mentre il pin IO0 va collegato temporaneamente a GND solo durante il caricamento del codice.

Scheda e librerie:

In Arduino IDE andate su File - Preferences e aggiungete nel campo Additional Boards Manager URLs l'indirizzo https://dl.espressif.com/dl/package_esp32_index.json, poi aprite Tools - Board - Boards Manager, cercate esp32 e installate il pacchetto esp32 by Espressif Systems.

Dopo l'installazione, selezionate la scheda AI Thinker ESP32-CAM da Tools - Board - ESP32 Arduino.

Non è necessario installare alcuna libreria aggiuntiva, perché esp_camera.h e WiFi.h sono incluse automaticamente con il pacchetto esp32 by Espressif Systems.

Il codice:

Il codice qui sotto inizializza la telecamera con la mappatura dei pin della scheda AI-Thinker, si collega alla rete WiFi e invia il flusso video a qualsiasi client connesso sulla porta 80.

/*
  ESP32-CAM (AI-Thinker) with OV5640 5MP camera - WiFi video stream example
  Board: "AI Thinker ESP32-CAM" (Tools > Board > ESP32 Arduino)
  Board package: esp32 by Espressif Systems, installed from Boards Manager
  Boards Manager URL: https://dl.espressif.com/dl/package_esp32_index.json
  Libraries: esp_camera.h and WiFi.h, both included with the esp32 package, no extra library required
  Upload wiring: FT232 VCC->5V, FT232 GND->GND, FT232 TXD->U0R, FT232 RXD->U0T, IO0 bridged to GND only during upload
*/
#include "esp_camera.h"
#include <WiFi.h>
// ---- Wi-Fi credentials ----
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
// ---- AI-Thinker camera pin map ----
#define PWDN_GPIO_NUM   32
#define RESET_GPIO_NUM  -1
#define XCLK_GPIO_NUM    0
#define SIOD_GPIO_NUM   26
#define SIOC_GPIO_NUM   27
#define Y9_GPIO_NUM     35
#define Y8_GPIO_NUM     34
#define Y7_GPIO_NUM     39
#define Y6_GPIO_NUM     36
#define Y5_GPIO_NUM     21
#define Y4_GPIO_NUM     19
#define Y3_GPIO_NUM     18
#define Y2_GPIO_NUM      5
#define VSYNC_GPIO_NUM  25
#define HREF_GPIO_NUM   23
#define PCLK_GPIO_NUM   22
WiFiServer server(80);
void startCamera() {
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;   // 800x600, good balance for streaming
    config.jpeg_quality = 12;             // lower number = higher quality, bigger file
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_CIF;
    config.jpeg_quality = 15;
    config.fb_count = 1;
  }
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return;
  }
  Serial.println("Camera initialized");
}
void sendStreamToClient(WiFiClient &client) {
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: multipart/x-mixed-replace; boundary=frame");
  client.println();
  while (client.connected()) {
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Frame capture failed");
      break;
    }
    client.println("--frame");
    client.println("Content-Type: image/jpeg");
    client.printf("Content-Length: %u\n\n", fb->len);
    client.write(fb->buf, fb->len);
    client.println();
    esp_camera_fb_return(fb);
    if (!client.connected()) break;
  }
}
void setup() {
  Serial.begin(115200);
  Serial.println();
  startCamera();
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("WiFi connected, IP address: ");
  Serial.println(WiFi.localIP());
  Serial.println("Open this address in a browser to view the live stream");
  server.begin();
}
void loop() {
  WiFiClient client = server.available();
  if (client) {
    Serial.println("New client connected");
    sendStreamToClient(client);
    client.stop();
    Serial.println("Client disconnected");
  }
}

Come funziona il codice:

All'inizio del file sono definiti i dati della rete WiFi (ssid, password) e i pin della telecamera secondo la scheda AI-Thinker (PWDN_GPIO_NUM, XCLK_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM, PCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM).

La funzione startCamera compila la struttura camera_config_t con questi pin, sceglie la risoluzione FRAMESIZE_SVGA e due buffer di fotogrammi quando la scheda dispone di PSRAM, quindi chiama esp_camera_init e mostra sul Serial se l'inizializzazione è riuscita.

La funzione sendStreamToClient invia al client connesso un'intestazione HTTP di tipo multipart/x-mixed-replace, poi, finché il client resta connesso, preleva un fotogramma JPEG alla volta con esp_camera_fb_get, lo invia sulla connessione e lo rilascia con esp_camera_fb_return.

Nella funzione setup si inizializza la porta seriale, si avvia la telecamera, si attende la connessione alla rete WiFi e si mostra l'indirizzo IP ricevuto, poi si avvia il server WiFiServer sulla porta 80. Nella funzione loop, la scheda attende un nuovo client e gli invia il flusso video tramite sendStreamToClient.

Risultato:

Aprite il Serial Monitor a 115200 baud. Dopo l'inizializzazione della telecamera e la connessione alla rete verrà mostrato l'indirizzo IP della scheda, e accedendo a questo indirizzo da un browser apparirà il flusso video live della telecamera.

Camera initialized
Connecting to WiFi.....
WiFi connected, IP address: 192.168.0.114
Open this address in a browser to view the live stream
New client connected
Client disconnected
New client connected
Client disconnected

Problemi frequenti:

Se il Serial Monitor non mostra nulla, verificate che la velocità selezionata sia 115200 baud e di aver rimosso il collegamento tra IO0 e GND prima di premere RESET dopo il caricamento.

Se all'avvio compare il messaggio di errore di inizializzazione della telecamera (camera init failed), verificate che il flat della telecamera sia ben inserito nel connettore FPC e che non si sia spostato durante il montaggio del dissipatore.

Se la scheda si riavvia da sola o compaiono messaggi di brownout nel Serial Monitor, l'alimentatore è troppo debole: sostituitelo con uno da 5V e almeno 2A collegato direttamente al pin 5V.

Se la scheda non si collega alla rete WiFi, verificate di aver inserito correttamente il nome della rete e la password e che il segnale WiFi sia abbastanza forte nel punto in cui è montata la scheda.

Se l'immagine è molto scura o piena di rumore, assicurate una fonte di luce migliore nella scena, perché la telecamera non ha un'illuminazione propria oltre al LED flash.

Se il caricamento del codice fallisce con messaggi di connessione non riuscita alla scheda, rifate il ponticello IO0-GND e premete di nuovo RESET esattamente nel momento in cui Arduino IDE inizia il caricamento.

Limitazioni e consigli:

La telecamera OV5640 raggiunge la risoluzione massima di 5MP solo per le foto singole, mentre per lo streaming continuo si consigliano risoluzioni inferiori come SVGA o HD, per mantenere un numero ragionevole di fotogrammi al secondo.

La scheda non ha una porta USB propria, quindi la programmazione richiede sempre un adattatore USB-seriale esterno, e senza la versione con autofocus la telecamera lavora a fuoco fisso.

Il sensore si riscalda sensibilmente durante il funzionamento, perciò la scheda non è consigliata per lo streaming video continuo 24/7, ma per il monitoraggio e le acquisizioni intermittenti, con dissipatore montato e ventilazione adeguata.

Con questo montaggio si possono realizzare progetti come telecamere di sorveglianza WiFi, stazioni di monitoraggio con salvataggio delle immagini sulla scheda microSD o semplici sistemi di riconoscimento degli oggetti che usano l'elaborazione delle immagini su un server esterno.