Scheda di sviluppo ESP32-CAM con CH340G, WiFi, Bluetooth, OV5640 5MP

La scheda ESP32-CAM con fotocamera OV5640 da 5 MP è un modulo ESP32 con fotocamera integrata, usato per acquisire e trasmettere immagini via WiFi senza altri componenti aggiuntivi. Si utilizza in progetti di sorveglianza, monitoraggio a distanza, fotografia automatica e riconoscimento di immagini.

Il tutorial usa proprio la scheda ESP32-CAM AI-Thinker come piattaforma, programmata dall'Arduino IDE. La scheda non ha porta USB, quindi il caricamento del programma avviene tramite un adattatore USB-seriale FT232RL, mentre l'alimentazione è separata, da un alimentatore da 5 VDC con minimo 2 A. Il programma avvia la fotocamera e serve un flusso video tramite un semplice server web.

Come funziona:

Il sensore OV5640 acquisisce l'immagine e la invia all'ESP32 su 8 linee dati parallele (D0 - D7), sincronizzate dai segnali XCLK (il clock fornito al sensore), PCLK (il clock dei pixel), VSYNC (inizio fotogramma) e HREF (linea valida). La configurazione del sensore, cioè risoluzione, esposizione e bilanciamento del bianco, avviene tramite un bus I2C / SCCB sulle linee SIOD (GPIO26) e SIOC (GPIO27). Il pin PWDN (GPIO32) può spegnere il sensore quando non è in uso.

Il calcolo qui sotto mostra perché l'immagine viene compressa in JPEG direttamente nel sensore. La risoluzione massima è 2592 x 1944 = 5 038 848 pixel. Con 2 byte per pixel (formato RGB565), un fotogramma occuperebbe poco più di 10 MB (10 077 696 byte), più dei 4 MB di PSRAM della scheda. In JPEG, un fotogramma occupa molto meno e si adatta facilmente alla memoria.

Alla risoluzione SVGA (800 x 600 = 480 000 pixel), un fotogramma JPEG ha, a seconda della scena e della qualità scelta nel codice, circa 10 - 40 KB. Nei nostri test, con qualità 12, la media è stata di circa 13 KB per fotogramma. Se la rete WiFi offre in pratica 400 KB/s e un fotogramma ha 40 KB, risultano 400 / 40 = 10 fotogrammi al secondo. Oltre la risoluzione HD, il sensore fornisce solo 4 - 6 fotogrammi al secondo con il clock XCLK di 20 MHz. La risoluzione massima resta quindi riservata alle fotografie singole, mentre per il flusso video si scelgono SVGA o HD. La libreria esp32-camera offre come risoluzione massima QSXGA di 2560 x 1920 pixel, leggermente sotto i 2592 x 1944 pixel del sensore.

Collegamento:

La scheda si alimenta da un alimentatore separato da 5 VDC con minimo 2 A, sul pin 5V. Non alimentatela dall'adattatore USB-seriale, perché l'adattatore e la porta USB non garantiscono la corrente di picco richiesta dalla fotocamera OV5640 insieme al WiFi, e l'uscita da 3.3 V dell'adattatore non è adatta a questa scheda. Il pin VCC dell'adattatore FT232RL resta non collegato, mentre il jumper dell'adattatore va impostato su 3.3 V, affinché i segnali TXD e RXD abbiano il livello logico di 3.3 V dei GPIO dell'ESP32. Le linee seriali si incrociano: TXD dell'adattatore va a U0R, e RXD dell'adattatore a U0T. Il ponticello tra IO0 e GND va messo solo durante il caricamento del programma.

L'immagine qui sotto mostra il collegamento della scheda al programmatore FT232.

Pulsanti, regolazioni e indicatori:

Per il caricamento, collegate IO0 a GND, premete RESET e caricate il programma. La scheda è entrata nella modalità corretta se l'Arduino IDE avvia il caricamento senza l'errore di connessione.

Dopo il caricamento, rimuovete il ponticello tra IO0 e GND e premete RESET. La scheda esegue ora il programma e nel Serial Monitor compaiono i messaggi di avvio.

Il LED bianco resta spento nel programma. Se volete un'illuminazione supplementare, comandate GPIO4 dal codice, tenendo presente che il LED acceso alla luminosità massima aggiunge circa 130 mA al consumo. Nei nostri test, la scheda con fotocamera OV5640 ha consumato circa 340 - 360 mA a 5 V, con la fotocamera attiva e il LED spento.

Scheda e librerie:

Nell'Arduino IDE, andate su File - Preferences e aggiungete nel campo Additional Boards Manager URLs l'indirizzo https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Aprite poi Tools - Board - Boards Manager, cercate esp32 e installate il pacchetto esp32 by Espressif Systems, in una versione recente (2.0.x o successiva).

Dopo l'installazione, selezionate la scheda AI Thinker ESP32-CAM da Tools - Board - esp32. Le schermate qui sotto illustrano i passaggi di configurazione nell'Arduino IDE.

Non è necessario installare alcuna libreria dal Library Manager, perché esp_camera.h e WiFi.h sono inclusi nel pacchetto esp32 by Espressif Systems.

Il codice:

Il programma inizializza la fotocamera con la mappatura dei pin della scheda AI-Thinker, si connette alla rete WiFi e invia il flusso video JPEG a un client connesso sulla porta 80. Sostituite il nome e la password della rete prima del caricamento.

/*
  ESP32-CAM (AI-Thinker) with OV5640 5MP camera - WiFi MJPEG video stream
  Board selected in Arduino IDE: "AI Thinker ESP32-CAM" (Tools > Board > esp32)
  Board package: esp32 by Espressif Systems (installed from Boards Manager)
  Boards Manager URL (File > Preferences): https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  Libraries: none to install, esp_camera.h and WiFi.h come with the esp32 package
  Upload wiring: FT232 TXD -> U0R, FT232 RXD -> U0T, FT232 GND -> GND,
                 5V supply (min 2 A) on the 5V pin, IO0 bridged to GND only during upload
*/
#include "esp_camera.h"
#include <WiFi.h>
// ---- Wi-Fi credentials (replace with your own) ----
const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_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
// White flash LED on GPIO4 (also SD card DATA1)
#define FLASH_LED_GPIO_NUM 4
WiFiServer server(80);
// Configure and start the camera
bool startCamera() {
  camera_config_t config = {};          // start from a zeroed structure
  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_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;        // 20 MHz clock for the sensor
  config.pixel_format = PIXFORMAT_JPEG;  // the sensor compresses the image itself
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;  // 800x600, a good balance for streaming
    config.jpeg_quality = 12;            // lower number = better quality, bigger file
    config.fb_count = 2;                 // two frame buffers for smoother streaming
    config.fb_location = CAMERA_FB_IN_PSRAM;
    config.grab_mode = CAMERA_GRAB_LATEST;  // always send the newest frame
    Serial.println("PSRAM found, using SVGA with 2 frame buffers");
  } else {
    config.frame_size = FRAMESIZE_CIF;
    config.jpeg_quality = 15;
    config.fb_count = 1;
    config.fb_location = CAMERA_FB_IN_DRAM;
    config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
    Serial.println("No PSRAM, using CIF with 1 frame buffer");
  }
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return false;
  }
  // Read the sensor ID to confirm which camera is attached
  sensor_t *s = esp_camera_sensor_get();
  Serial.printf("Camera init OK, sensor PID: 0x%04X\n", s->id.PID);
  if (s->id.PID != OV5640_PID) {
    Serial.println("Warning: the attached sensor is not an OV5640");
  }
  return true;
}
// Read and ignore the HTTP request header sent by the browser
void skipRequest(WiFiClient &client) {
  unsigned long start = millis();
  while (client.connected() && millis() - start < 1000) {
    if (client.available()) {
      String line = client.readStringUntil('\n');
      if (line.length() <= 1) break;  // blank line ends the header
    }
  }
}
// Send frames to the client until it disconnects
void streamTo(WiFiClient &client) {
  client.print("HTTP/1.1 200 OK\r\n");
  client.print("Content-Type: multipart/x-mixed-replace; boundary=frame\r\n\r\n");
  Serial.println("Streaming started");
  uint32_t frames = 0;
  while (client.connected()) {
    camera_fb_t *fb = esp_camera_fb_get();  // get one JPEG frame
    if (!fb) {
      Serial.println("Frame capture failed");
      break;
    }
    size_t len = fb->len;
    client.print("--frame\r\n");
    client.print("Content-Type: image/jpeg\r\n");
    client.printf("Content-Length: %u\r\n\r\n", (unsigned)len);
    size_t sent = client.write(fb->buf, len);
    client.print("\r\n");
    esp_camera_fb_return(fb);               // give the buffer back to the driver
    if (sent != len) break;                 // client is gone
    frames++;
  }
  Serial.printf("Client disconnected after %u frames\n", (unsigned)frames);
}
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println();
  Serial.println("ESP32-CAM OV5640 stream example");
  // Keep the white flash LED off
  pinMode(FLASH_LED_GPIO_NUM, OUTPUT);
  digitalWrite(FLASH_LED_GPIO_NUM, LOW);
  if (!startCamera()) {
    return;  // stop here if the camera did not start
  }
  // Connect to Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  WiFi.setSleep(false);  // no Wi-Fi power saving, better for streaming
  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.print("Open http://");
  Serial.print(WiFi.localIP());
  Serial.println("/ in a browser to see the stream");
  server.begin();
}
void loop() {
  WiFiClient client = server.available();  // wait for a browser
  if (client) {
    Serial.println("Client connected");
    skipRequest(client);
    streamTo(client);
    client.stop();
  }
}

Come funziona il codice:

La prima parte contiene le definizioni. Le costanti WIFI_SSID e WIFI_PASSWORD memorizzano i dati della rete, mentre le righe con PWDN_GPIO_NUM, XCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM e PCLK_GPIO_NUM descrivono i pin tra l'ESP32 e il connettore della fotocamera, gli stessi della tabella della descrizione. FLASH_LED_GPIO_NUM è GPIO4, e l'oggetto server resta in ascolto sulla porta 80.

La funzione startCamera() riempie la struttura camera_config_t con i pin della fotocamera, con il clock XCLK di 20 MHz e con il formato PIXFORMAT_JPEG. La struttura viene inizializzata vuota (= {}), in modo che i campi non impostati non contengano valori casuali. Se psramFound() restituisce vero, si sceglie FRAMESIZE_SVGA con due buffer di fotogrammi in PSRAM (fb_count = 2) e la modalità CAMERA_GRAB_LATEST, che invia sempre il fotogramma più recente. Altrimenti si sceglie FRAMESIZE_CIF con un solo buffer nella memoria interna. Dopo esp_camera_init() la funzione legge il sensore con esp_camera_sensor_get(), stampa l'identificativo PID, che per l'OV5640 è 0x5640, e avvisa se il sensore collegato è un altro.

La funzione skipRequest() legge e ignora l'intestazione della richiesta HTTP inviata dal browser, fino alla prima riga vuota. La funzione streamTo() invia l'intestazione multipart/x-mixed-replace, poi ripete in ciclo: acquisisce un fotogramma con esp_camera_fb_get(), invia il separatore, il tipo e la lunghezza, scrive i dati JPEG con client.write() e libera il buffer con esp_camera_fb_return(). Il ciclo si interrompe quando il client si disconnette.

In setup() si avvia Serial a 115200 baud, si mantiene spento il LED bianco, si richiama startCamera(), si connette la scheda al WiFi con WiFi.begin() e si visualizza l'indirizzo IP ricevuto. In loop() il programma attende un client con server.available() e, quando ne arriva uno, gli serve il flusso tramite streamTo().

Risultato:

Aprite il Serial Monitor a 115200 baud. Dopo l'avvio deve comparire la conferma dell'inizializzazione della fotocamera con PID 0x5640, poi l'indirizzo IP della scheda. Inserite l'indirizzo nel browser e comparirà l'immagine in tempo reale.

ESP32-CAM OV5640 stream example
PSRAM found, using SVGA with 2 frame buffers
Camera init OK, sensor PID: 0x5640
Connecting to WiFi......
WiFi connected, IP address: 192.168.1.57
Open http://192.168.1.57/ in a browser to see the stream
Client connected
Streaming started
Client disconnected after 412 frames

Problemi frequenti:

Il caricamento si interrompe con un errore di connessione. La causa comune è la modalità di avvio sbagliata. Verificate che IO0 sia collegato a GND, premete RESET prima del caricamento e verificate che TXD vada a U0R e RXD a U0T, non direttamente.

Dopo il caricamento non succede nulla e nel Serial Monitor compare un messaggio che attende il caricamento del programma. Il ponticello tra IO0 e GND è rimasto inserito. Rimuovetelo e premete RESET.

La scheda si riavvia continuamente oppure compare il messaggio Brownout detector was triggered. L'alimentazione è insufficiente, di solito perché la scheda è alimentata dal USB o da un alimentatore debole. Usate un alimentatore stabile da 5 VDC con minimo 2 A, con cavi corti.

Compare il messaggio Camera init failed con un codice di errore. Il cavo flat della fotocamera non è inserito completamente oppure la clip del connettore FPC non è chiusa. Scollegate l'alimentazione, reinserite il cavo con i contatti nella posizione corretta e chiudete la clip.

L'immagine presenta rumore o una tonalità violacea dopo un certo tempo di funzionamento. Il sensore OV5640 si è surriscaldato troppo. Montate un dissipatore sul retro della fotocamera, assicurate la ventilazione e riducete la risoluzione a SVGA o HD.

La scheda si collega al WiFi, ma l'immagine si blocca o ha pochi fotogrammi al secondo. Il segnale WiFi è debole oppure la risoluzione è troppo alta. Avvicinate la scheda al router e riducete la risoluzione nel codice.

Limitazioni e consigli:

Il modulo non è consigliato per lo streaming continuo 24 ore su 24, perché la fotocamera OV5640 si riscalda molto su questa scheda. Il motivo è che la scheda è stata progettata per la fotocamera OV2640 e alimenta il connettore della fotocamera con 3.3 V, 2.8 V e 1.2 V, mentre l'OV5640 alimenta il proprio nucleo da un regolatore interno da 1.5 V alimentato da 3.3 V. La differenza di tensione si trasforma in calore direttamente nel sensore, e oltre circa 50 gradi C possono comparire rumore e una tonalità violacea nell'immagine.

Senza modifiche hardware, usate un dissipatore sulla fotocamera, risoluzioni di al massimo SVGA o HD nello streaming, e mettete il sensore in standby tra un'acquisizione e l'altra tramite il registro 0x3008 (valore 0x42 per lo standby e 0x02 per l'attivo). Nei nostri test, il consumo della scheda è sceso da circa 338 mA a 163 mA con il sensore in standby. La risoluzione massima offerta dalla libreria, 2560 x 1920 pixel, è adatta alle fotografie.

Gli utenti con esperienza nella saldatura di componenti SMD possono ridurre il riscaldamento sostituendo il regolatore da 1.2 V vicino al connettore della fotocamera con uno da 1.5 V (ad esempio XC6206P152MR o ME6206A15XG) e disattivando via software il regolatore interno del sensore, tramite il bit 3 del registro 0x3031 (valore 0x08), subito dopo esp_camera_init(). Dopo questa modifica, il dissipatore della fotocamera è rimasto visibilmente più freddo nei nostri test.

// Only on a board where the DVDD regulator was replaced with a 1.5 V one
sensor_t *s = esp_camera_sensor_get();
if (s->id.PID == OV5640_PID) {
  s->set_reg(s, 0x3031, 0x08, 0x08);  // bypass the internal 1.5 V core regulator
}

Non disattivate il regolatore interno su una scheda non modificata, perché il nucleo del sensore funzionerebbe sotto la tensione minima, con rischio di immagini corrotte e blocchi. Una scheda modificata non è più adatta alla fotocamera OV2640 e va contrassegnata in modo appropriato.

Partendo da questo tutorial potete costruire una telecamera di sorveglianza con accesso dal browser, un sistema di fotografia periodica con salvataggio su scheda microSD, oppure un progetto di riconoscimento di oggetti, usando i GPIO liberi per sensori di movimento o altri moduli.