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

La scheda ESP32-CAM con fotocamera OV5640 da 5 MP è una scheda di sviluppo ESP32 completa, con microcontrollore, fotocamera, slot per schede microSD e antenna sulla stessa scheda. È pensata per progetti di streaming video, sorveglianza, fotografia attivata da eventi e altre applicazioni IoT che hanno bisogno di un'immagine inviata via WiFi a uno smartphone, a un computer o a un server locale.

Trattandosi di una scheda ESP32, il tutorial usa direttamente la scheda ESP32-CAM, programmata in Arduino IDE come "AI Thinker ESP32-CAM", insieme al modulo programmatore CH340G incluso nel kit. Non serve nessun'altra scheda di sviluppo.

Come funziona:

La fotocamera OV5640 invia l'immagine all'ESP32 tramite un bus parallelo a 8 bit (pin D0-D7), accompagnato dai segnali di sincronizzazione PCLK, VSYNC e HREF e dal bus SCCB compatibile I2C (SIOD/SIOC), attraverso cui il microcontrollore configura la risoluzione, l'esposizione e il bilanciamento del bianco del sensore. L'ESP32 acquisisce i frame nella memoria PSRAM esterna da 4 MB, li comprime in formato JPEG usando l'encoder hardware integrato e li rende disponibili tramite un server HTTP avviato sul WiFi, all'indirizzo IP ricevuto dal router.

La risoluzione scelta nel codice, per esempio SVGA (800x600) o VGA (640x480), determina la dimensione di ogni frame JPEG e quindi la velocità di trasmissione via WiFi. Per questo, per un flusso video continuo si usa una risoluzione più bassa, mentre la risoluzione massima del sensore OV5640, 2592x1944 (5 MP), si usa solo per le foto singole.

Collegamento:

La scheda ESP32-CAM si alimenta separatamente a 5 V, mentre la programmazione avviene tramite il modulo programmatore CH340G, che collega i pin seriali della scheda alla porta USB del computer.

Tutta l'elettronica della scheda lavora a 3.3 V e il modulo programmatore con CH340G rispetta lo stesso livello logico sui pin seriali, quindi non serve un convertitore di livello tra le due schede. Il pin VCC della scheda ESP32-CAM è un'uscita a 3.3 V o 5 V e non deve essere usato per alimentare la scheda. L'alimentazione a 5 V, minimo 2 A, è obbligatoria per il funzionamento stabile della fotocamera OV5640. Una porta USB di un computer spesso non basta per il funzionamento normale, anche se può essere usata temporaneamente solo per la programmazione.

Scheda e librerie:

Selezionate la scheda "AI Thinker ESP32-CAM" dal menu Tools > Board, dopo aver installato il pacchetto "esp32 by Espressif Systems" da Tools > Board > Boards Manager. Se il pacchetto non compare nell'elenco, aggiungete l'indirizzo https://dl.espressif.com/dl/package_esp32_index.json in File > Preferences, alla voce Additional Boards Manager URLs.

Non è necessario installare nessuna libreria aggiuntiva da Library Manager. Le librerie esp_camera.h, WiFi.h e WebServer.h fanno parte del pacchetto esp32 installato sopra.

Il codice:

Il codice inizializza la fotocamera con la mappatura dei pin del modello AI Thinker, si connette alla rete WiFi e avvia un semplice server HTTP con una pagina principale e un indirizzo da cui è possibile scaricare una foto in formato JPEG.

/*
  ESP32-CAM OV5640 5MP - simple snapshot web server
  Board: AI Thinker ESP32-CAM (install package "esp32 by Espressif Systems" from Boards Manager,
  Additional Boards Manager URL: https://dl.espressif.com/dl/package_esp32_index.json)
  Libraries: none to install separately, esp_camera.h, WiFi.h and WebServer.h are part of the esp32 board package
  Wiring: camera and microSD pins are fixed on board, programming uses U0R, U0T, IO0 and GND
  through the included ESP32-CAM-MB CH340G programmer, power is supplied on the 5V/GND pins
*/
#include "esp_camera.h"
#include <WiFi.h>
#include <WebServer.h>
// Camera pin map for the AI Thinker ESP32-CAM board
#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
#define FLASH_LED_GPIO_NUM 4
// WiFi credentials, replace with your own network
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
WebServer server(80);
// Serve a simple HTML page with a link to the snapshot
void handleRoot() {
  String html = "<html><body><h1>ESP32-CAM OV5640</h1>";
  html += "<p><a href=\"/capture\">Get snapshot</a></p></body></html>";
  server.send(200, "text/html", html);
}
// Capture one JPEG frame and send it to the browser
void handleCapture() {
  camera_fb_t *fb = esp_camera_fb_get();
  if (!fb) {
    Serial.println("Camera capture failed");
    server.send(503, "text/plain", "Camera capture failed");
    return;
  }
  server.sendHeader("Content-Disposition", "inline; filename=capture.jpg");
  server.send_P(200, "image/jpeg", (const char *)fb->buf, fb->len);
  esp_camera_fb_return(fb);
  Serial.printf("Snapshot sent, size %u bytes\n", fb->len);
}
void setup() {
  Serial.begin(115200);
  Serial.println();
  // Flash LED pin kept off at startup
  pinMode(FLASH_LED_GPIO_NUM, OUTPUT);
  digitalWrite(FLASH_LED_GPIO_NUM, LOW);
  // Camera configuration structure
  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_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;
  config.pixel_format = PIXFORMAT_JPEG;
  // Use a larger frame and double buffering when PSRAM is available
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_VGA;
    config.jpeg_quality = 15;
    config.fb_count = 1;
  }
  // Initialize the camera
  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");
  // Connect to WiFi
  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());
  // Register HTTP routes and start the server
  server.on("/", handleRoot);
  server.on("/capture", handleCapture);
  server.begin();
  Serial.println("HTTP server started");
  Serial.println("Open the IP address above in a browser, then click Get snapshot");
}
void loop() {
  server.handleClient();
}

Come funziona il codice:

All'inizio del file sono definite le costanti dei pin della fotocamera, PWDN_GPIO_NUM, RESET_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, con i valori fissi usati sulla scheda AI Thinker, più FLASH_LED_GPIO_NUM per il LED su GPIO4. Le variabili ssid e password devono essere compilate con i dati della rete WiFi, mentre l'oggetto server, di tipo WebServer, viene creato sulla porta 80.

Nella funzione setup, dopo l'avvio della comunicazione seriale, la struttura camera_config_t viene compilata con i pin della fotocamera, il formato immagine PIXFORMAT_JPEG e, in base al risultato di psramFound, la risoluzione FRAMESIZE_SVGA con due buffer di frame quando la scheda ha la PSRAM, oppure FRAMESIZE_VGA con un solo buffer in caso contrario. La funzione esp_camera_init avvia la fotocamera e, in caso di errore, il messaggio viene mostrato su Serial. Segue la connessione al WiFi con WiFi.begin, un'attesa in un ciclo finché WiFi.status restituisce WL_CONNECTED, e la registrazione delle due rotte, handleRoot per la pagina principale e handleCapture per la foto, prima di avviare server.begin.

La funzione handleCapture richiede un nuovo frame con esp_camera_fb_get, lo invia al browser con server.send_P usando il tipo image/jpeg, quindi libera la memoria del frame con esp_camera_fb_return. Nella funzione loop, server.handleClient viene chiamata continuamente per rispondere alle richieste ricevute via HTTP.

Risultato:

Sul Monitor Seriale, a 115200 baud, si vede la connessione alla rete WiFi e l'indirizzo IP ricevuto dalla scheda, poi la conferma dell'avvio del server HTTP. Accedendo con un browser all'indirizzo IP mostrato, seguito da /capture, si scarica una foto scattata in quel momento dalla fotocamera OV5640.

Camera initialized
Connecting to WiFi.......
WiFi connected, IP address: 192.168.0.115
HTTP server started
Open the IP address above in a browser, then click Get snapshot
Snapshot sent, size 48213 bytes
Snapshot sent, size 51042 bytes

Problemi frequenti:

Non compare nulla sul Monitor Seriale: verificate che la velocità selezionata nel Monitor Seriale sia 115200 baud e che il modulo programmatore sia collegato correttamente, con U0R e U0T non invertiti.

Il caricamento del codice fallisce con un messaggio di connessione o di sincronizzazione: tenete premuto il pulsante Download oppure collegate GPIO0 a GND prima di iniziare il caricamento, e verificate che sia selezionato Flash Mode DIO da Tools > Flash Mode.

La fotocamera non si avvia e su Serial compare un errore di inizializzazione: controllate l'alimentazione a 5 V, minimo 2 A, perché un alimentatore debole provoca reset (brownout) al momento dell'inizializzazione della fotocamera.

L'immagine è bianca, scura o ha delle strisce: lasciate alla fotocamera qualche secondo per regolare automaticamente l'esposizione e il bilanciamento del bianco, e verificate che il flat FPC della fotocamera sia inserito correttamente nel connettore.

La scheda si resetta da sola durante lo streaming: riducete la risoluzione e la qualità JPEG nel codice e controllate di nuovo l'alimentatore, perché un consumo di picco superiore a 300 mA con un alimentatore debole provoca reset ripetuti.

La fotocamera diventa molto calda al tatto: è un comportamento normale del sensore OV5640, ma montate obbligatoriamente un dissipatore sul retro ed evitate lo streaming continuo per lunghi periodi.

Limiti e consigli:

La risoluzione massima di 5 MP del sensore OV5640 è utile per le foto, non per lo streaming continuo, dove la velocità di trasmissione via WiFi e la memoria PSRAM limitano di fatto la risoluzione a SVGA o HD. Il modulo non è consigliato per il funzionamento ininterrotto 24/7, e per i progetti con scatti periodici è opportuno spegnere la fotocamera tra una foto e l'altra, usando GPIO32, per ridurre il riscaldamento e il consumo. Partendo da questo codice, la scheda può essere ampliata con il salvataggio su scheda microSD, il rilevamento del movimento con un sensore PIR esterno su uno dei pin liberi, oppure l'integrazione in un sistema di sorveglianza più grande con più fotocamere ESP32-CAM.