Streaming video con ESP32 Camera Pro Kit

In questo tutorial imparerai come trasmettere video dal ESP32 Camera Pro Kit tramite la tua rete Wi-Fi locale al browser web. In pratica, stiamo costruendo una telecamera di sorveglianza wireless che puoi monitorare dal tuo computer.

Componenti necessari

Per questo progetto ti serviranno l’ESP32 Camera Pro Kit di SunFounder e un cavo USB.

ESP32 Camera Pro Kit

Find at Amazon

Find at SunFounder

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

SunFounder ESP32 Camera Pro Kit

Il SunFounder ESP32 Camera Pro Kit offre una piattaforma compatta e ricca di funzionalità per sviluppare applicazioni di streaming video wireless e visione embedded.

Al centro c’è il modulo ESP32 WROOM-32E, un microcontrollore dual-core con connettività Wi-Fi e Bluetooth, abbinato a una fotocamera OV2640 capace di catturare immagini fino a una risoluzione di 1600 × 1200.

La scheda di espansione inclusa nel kit integra periferiche essenziali come uno slot per micro-SD, circuiteria per la ricarica della batteria, header di espansione GPIO e un’interfaccia camera a 24 pin, offrendo flessibilità e affidabilità per prototipazione e deployment.

Il kit supporta una singola batteria agli ioni di litio 18650, permettendo il funzionamento autonomo senza alimentazione esterna. La combinazione di memoria onboard, rete wireless e funzionalità camera lo rende ideale per scenari IoT come monitoraggio remoto, streaming in tempo reale e registrazione dati.

ESP32 Camera Pro Kit with Battery and Camera — ESP32 Camera Pro Kit con batteria e fotocamera

Specifiche tecniche

Componente / Caratteristica	Specifiche
Microcontrollore	ESP32 WROOM-32E, dual-core Xtensa® 32-bit LX6 fino a 240 MHz
Wireless	Wi-Fi 802.11 b/g/n, Bluetooth 4.2 (BR/EDR + BLE)
Modulo fotocamera	OV2640, sensore 2 MP, fino a 1600 × 1200 di risoluzione, ~68° FOV
Memoria onboard	Slot per micro-SD (supporta fino a 32 GB, FAT32)
Alimentazione	Batteria Li-ion 18650 da 3,7 V (ricaricabile via USB, gestione carica onboard)
Interfacce di espansione	Header GPIO femmina, morsettiera a vite a 14 pin (passo 3,5 mm)
Interfaccia fotocamera	Connettore FFC/FPC a 24 pin (dedicato a OV2640)
Indicatori	LED di stato alimentazione (PWR) e carica (CHG)
Interfacce di programmazione	Micro-USB (UART, alimentazione, ricarica)

Pinout di ESP32 WROOM-32E

Installazione del Core ESP32

Se è il tuo primo progetto con una scheda della serie ESP32, devi prima installare il core ESP32. Se le schede ESP32 sono già installate nel tuo Arduino IDE, puoi saltare questa sezione.

Inizia aprendo la finestra Preferenze selezionando “Preferences…” dal menu “File”. Si aprirà la finestra Preferenze mostrata qui sotto.

Nella scheda Settings troverai in fondo una casella di testo etichettata “Additional boards manager URLs“:

In questo campo incolla il seguente URL:

https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

Questo permetterà all’Arduino IDE di sapere dove trovare le librerie core ESP32. Successivamente installeremo le schede ESP32 tramite il Boards Manager.

Apri il Boards Manager tramite “Tools -> Boards -> Board Manager”. Vedrai il Boards Manager apparire nella barra laterale sinistra. Digita “ESP32” nel campo di ricerca in alto e vedrai due tipi di schede ESP32; le “Arduino ESP32 Boards” e le schede “esp32 di Espressif”. Noi vogliamo le librerie esp32 di Espressif. Clicca sul pulsante INSTALL e attendi che il download e l’installazione siano completati.

Install ESP32 Core libraries — Installa le librerie Core ESP32

Selezione della scheda

Infine dobbiamo selezionare una scheda ESP32. Nel caso dell’ESP32 Camera Pro Kit, scegliamo la scheda generica “AI Thinker ESP32-CAM”. Per farlo, clicca sul menu a tendina e poi su “Select other board and port…”:

Drop-down Menu for Board Selection — Menu a tendina per la selezione della scheda

Si aprirà una finestra dove puoi digitare “ai” nella barra di ricerca. Vedrai la scheda “AI Thinker ESP32-CAM” sotto Boards. Cliccaci sopra, seleziona la porta COM per attivarla e poi clicca OK:

Board Selection Dialog "AI Thinker ESP32-CAM" board — Finestra di selezione scheda “AI Thinker ESP32-CAM”

In alternativa, potresti selezionare la più recente “ESP32 Dev Module“, ma in questo caso devi abilitare PSRAM e Huge APP nel menu Tools.

Nota che devi collegare la scheda al computer tramite cavo USB prima di poter selezionare una porta COM.

Streaming video

In questo progetto implementiamo un server di streaming video che gira sull’ESP32, il microprocessore integrato nell’ESP32 Camera Pro Kit. La fotocamera cattura immagini e l’ESP32 le trasmette via Wi-Fi. Il router Wi-Fi poi invia queste immagini a un browser web, che le mostra come un flusso video. L’immagine sotto illustra la configurazione:

Nota che il flusso video non è criptato né sicuro, ma sarà visibile solo tramite un URL all’interno della tua rete Wi-Fi locale, ad esempio 192.168.2.39/stream. Solo chi ha accesso alla tua rete Wi-Fi potrà vedere il flusso video.

Codice per il server video

Il seguente codice Arduino implementa un server di streaming video che invia un flusso MJPEG continuo dall’ESP32 Camera Pro Kit a qualsiasi browser web connesso alla stessa rete Wi-Fi.

Useremo la libreria esp32cam, che semplifica la gestione della fotocamera. Puoi installarla tramite il Library Manager nell’Arduino IDE. Cerca “esp32cam” e premi INSTALL. L’immagine sotto mostra l’installazione completata:

esp32cam library installed via Library Manager — Libreria esp32cam installata tramite Library Manager

Qui sotto trovi il codice completo per il server di streaming video. Dagli una rapida occhiata e poi ne analizzeremo i dettagli:

#include "WebServer.h"
#include "WiFi.h"
#include "esp32cam.h"

const char* WIFI_SSID = "SSID";
const char* WIFI_PASS = "PASSWORD";
const char* URL = "/stream";
const auto RESOLUTION = esp32cam::Resolution::find(1024, 768);

WebServer server(80);

void handleStream() {
  static char head[128];
  WiFiClient client = server.client();

  server.sendContent("HTTP/1.1 200 OK\r\n"
                     "Content-Type: multipart/x-mixed-replace; "
                     "boundary=frame\r\n\r\n");

  while (client.connected()) {
    auto frame = esp32cam::capture();
    if (frame) {
      sprintf(head,
              "--frame\r\n"
              "Content-Type: image/jpeg\r\n"
              "Content-Length: %ul\r\n\r\n",
              frame->size());
      client.write(head, strlen(head));
      frame->writeTo(client);
      client.write("\r\n");
    }
  }
}

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::AiThinker);
  cfg.setResolution(RESOLUTION);
  cfg.setBufferCount(2);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

void initWifi() {
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
  Serial.printf("Stream at: http://%s%s\n",
                WiFi.localIP().toString().c_str(), URL);
}

void initServer() {
  server.on(URL, handleStream);
  server.begin();
}

void setup() {
  Serial.begin(115200);
  initWifi();
  initCamera();
  initServer();
}

void loop() {
  server.handleClient();
}

Inclusioni

Il codice inizia includendo le librerie necessarie:

#include "WebServer.h"
#include "WiFi.h"
#include "esp32cam.h"

Queste librerie abilitano la funzionalità di server HTTP (WebServer.h), la connettività Wi-Fi (WiFi.h) e il controllo della fotocamera (esp32cam.h).

Costanti

Successivamente definiamo alcune costanti:

const char* WIFI_SSID = "SSID";
const char* WIFI_PASS = "PASSWORD";
const char* URL = "/stream";
const auto RESOLUTION = esp32cam::Resolution::find(1024, 768);

Le variabili WIFI_SSID e WIFI_PASS contengono le credenziali della rete Wi-Fi. Dovrai sostituire SSID e PASSWORD con i dati reali della tua rete.

La URL è il percorso su cui verrà servito il flusso video. Puoi cambiarlo come preferisci. Ad esempio, “/video” o “/frontdoo“, assicurandoti però di mantenere la barra (‘/’) all’inizio.

La RESOLUTION imposta la risoluzione desiderata per la fotocamera usando la libreria esp32cam.

Ecco una lista dei valori possibili per la risoluzione della fotocamera, anche se a seconda della fotocamera usata non tutte potrebbero funzionare:

96×96
160×120
128×128
176×144
240×176
240×240
320×240
320×320
400×296
480×320
640×480
800×600
1024×768
1280×720
1280×1024
1600×1200

Puoi stampare la lista delle risoluzioni della fotocamera usando la seguente funzione:

void printResolutions() {
  Serial.println("Camera resolutions:");
  for (auto res : esp32cam::Camera.listResolutions()) {
    Serial.printf("%dx%d\n", res.getWidth(), res.getHeight());
  }
}

Nota che la risoluzione influisce sul frame rate massimo. Con una risoluzione 1600×1200 non otterrai più di circa 10 frame al secondo.

Oggetti

La riga seguente crea un oggetto server HTTP che ascolta sulla porta 80. Questo è il nostro server web che fornisce il flusso video.

WebServer server(80);

handleStream

La funzione handleStream() gestisce il flusso video ogni volta che un client accede al percorso /stream:

void handleStream() {
  static char head[128];
  WiFiClient client = server.client();

Questa riga ottiene il client attualmente connesso al server. La risposta viene quindi preparata:

server.sendContent("HTTP/1.1 200 OK\r\n"
                   "Content-Type: multipart/x-mixed-replace; "
                   "boundary=frame\r\n\r\n");

Questo header dice al browser che riceverà un flusso MJPEG multipart, dove ogni parte è separata da un boundary chiamato frame.

All’interno di un ciclo, la funzione cattura un frame dalla fotocamera:

  while (client.connected()) {
    auto frame = esp32cam::capture();

Se il frame viene catturato con successo, viene costruito un header che descrive l’immagine JPEG, poi inviato al client come JPEG:

    if (frame) {
      sprintf(head,
              "--frame\r\n"
              "Content-Type: image/jpeg\r\n"
              "Content-Length: %ul\r\n\r\n",
              frame->size());
      client.write(head, strlen(head));
      frame->writeTo(client);
      client.write("\r\n");
    }

initCamera

La funzione initCamera() configura e avvia l’hardware della fotocamera:

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::AiThinker);
  cfg.setResolution(RESOLUTION);
  cfg.setBufferCount(2);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

Qui viene creato un oggetto Config. La funzione setPins configura i pin della fotocamera basandosi sul layout della scheda AiThinker, che funziona anche per l’ESP32 Camera Pro Kit. setResolution definisce la risoluzione da usare, mentre setBufferCount determina quanti buffer di immagine sono usati internamente.

La funzione setJpeg imposta la qualità di compressione JPEG. 80 è un buon compromesso tra qualità e dimensione. 90 offre qualità migliore ma una riduzione minore della dimensione dell’immagine. Per uno streaming più veloce puoi ridurre la risoluzione e la compressione JPEG, ma ovviamente otterrai immagini più piccole e di qualità inferiore.

Infine, Camera.begin(cfg) inizializza la fotocamera con queste impostazioni.

initWifi

La funzione initWifi() connette l’ESP32 alla rete Wi-Fi specificata:

void initWifi() {
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
  Serial.printf("Stream at: http://%s%s\n",
                WiFi.localIP().toString().c_str(), URL);
}

WiFi.persistent(false) disabilita la scrittura delle credenziali sulla flash, velocizzando la riconnessione. Il dispositivo è impostato in modalità station (WIFI_STA), e tenta di connettersi al Wi-Fi usando le credenziali fornite.

Una volta connesso, l’indirizzo IP e il percorso dello stream vengono stampati sul monitor seriale. Dovrai copiare e incollare questo URL nel browser per vedere il flusso video. L’URL effettivo dipenderà dal tuo ESP32. Nel mio caso vedo il seguente URL sul Monitor Seriale:

Streaming URL printed to Serial Monitor — URL di streaming stampato sul Monitor Seriale

Quindi, copio “http://192.168.2.39/stream” nella barra degli indirizzi del mio browser Chrome per accedere al video.

initServer

La funzione initServer() collega il percorso di streaming al gestore e avvia il server:

void initServer() {
  server.on(URL, handleStream);
  server.begin();
}

Mappa qualsiasi richiesta a /stream alla funzione handleStream(), quindi avvia il server.

setup

La funzione setup() viene eseguita una volta all’avvio:

void setup() {
  Serial.begin(115200);
  initWifi();
  initCamera();
  initServer();
}

Avvia la comunicazione seriale, si connette al Wi-Fi, inizializza la fotocamera e configura il server web.

loop

Infine, la funzione loop() gestisce continuamente le richieste HTTP in arrivo:

void loop() {
  server.handleClient();
}

Questa riga permette all’ESP32 di rispondere alle richieste dei client invocando i gestori registrati come handleStream().

Per caricare questo codice sul tuo modulo ESP32, assicurati di selezionare la scheda AI Thinker ESP32-CAM:

Select AI Thinker ESP32-CAM as board — Seleziona AI Thinker ESP32-CAM come scheda

Conclusioni

In questo tutorial hai imparato come trasmettere video con l’ESP32 Camera Pro Kit tramite la tua rete Wi-Fi locale al browser web.

Con la batteria inclusa, il supporto alla ricarica e i morsetti a vite sulla scheda di espansione, è molto facile costruire un sistema di sorveglianza alimentato a batteria senza saldature. Ad esempio, potresti collegare una torcia e un allarme sonoro da attivare al rilevamento di movimento. Dai un’occhiata al nostro Motion Activated ESP32-CAM tutorial per maggiori informazioni.

Nota che la scheda di espansione dell’ESP32 Camera Pro Kit è relativamente grande. Se ti serve una scheda più piccola con fotocamera, potresti usare la XIAO-ESP32-S3-Sense. È molto piccola, però se vuoi collegare hardware aggiuntivo devi saper saldare.

Una volta che hai un flusso video, potresti anche iniziare a rilevare oggetti nel video. Vedi il nostro Object Detection with ESP32-CAM and YOLO tutorial. È scritto per l’ESP32-CAM ma richiede solo una minima modifica (cfg.setPins(pins::AiThinker)) per funzionare con l’ESP32 Camera Pro Kit.

Infine, dai un’occhiata a SunFounders Wiki for the ESP32 Camera Pro Kit. Troverai ulteriori informazioni e progetti.

Se hai domande, sentiti libero di lasciarle nella sezione commenti.

Buon divertimento con il tinkering 😉

Stefan Maetschke