Stream Video con ESP32-WROVER CAM

In questo tutorial ti mostrerò come trasmettere video da una scheda Freenove ESP32-WROVER CAM sulla tua rete Wi-Fi locale al tuo browser web. Questo significa che puoi facilmente costruire il tuo sistema di videosorveglianza wireless da monitorare dal tuo computer.

Se non hai mai usato questa scheda prima, ti consiglio di leggere il Programming the ESP32-WROVER CAM tutorial prima, che ti introduce all’uso della scheda.

Overview

Componenti necessari

Per seguire questo tutorial ti servirà una scheda Freenove ESP32-WROVER CAM. Di solito la scheda viene fornita con accessori come una scheda SD, un lettore di schede SD e un cavo USB-C, ma nel caso mancassero, li ho linkati qui sotto.

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.

Streaming video

In questo progetto implementeremo un server di streaming video che gira sull’ESP32-WROVER. La fotocamera dell’ESP32-WROVER cattura immagini e le trasmette via Wi-Fi. Il router Wi-Fi trasporta queste immagini al browser web sul tuo PC, che le mostra come un flusso video. L’immagine sotto illustra l’architettura del sistema:

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.40/stream. Solo chi ha accesso alla tua rete Wi-Fi potrà vedere il flusso video.

Codice semplice per un server di streaming video

Il core per l’ESP32-WROVER CAM include un codice di esempio per un CameraWebServer che trasmette video; vedi il Programming the ESP32-WROVER CAM tutorial per i dettagli. Ma quel codice è complesso e l’interfaccia web ha molte opzioni.

È ottimo per sperimentare, ma se vuoi solo il flusso video semplice (ad esempio per Home Assistant) e un codice facile da integrare con altre funzioni, come uno streaming video attivato dal movimento, allora il codice seguente è più semplice da usare.

La semplificazione è dovuta in gran parte alla libreria esp32cam, che puoi installare tramite il Library Manager nell’Arduino IDE. Basta cercare “esp32cam” e premere INSTALLA. 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, che usa la libreria esp32cam. Dai un’occhiata veloce 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(800, 600);

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::FreeNove);
  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();
}

Librerie

Lo sketch 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 usando la libreria esp32cam.

Costanti

Successivamente definiamo le costanti per le impostazioni Wi-Fi e della fotocamera:

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

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

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

La RESOLUTION imposta la risoluzione desiderata per la fotocamera. Qui sotto trovi una lista dei valori possibili per la risoluzione, anche se a seconda della fotocamera 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

Oggetti

La riga seguente crea l’oggetto server HTTP che ascolta sulla porta 80. Questo è il nostro web server 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. Poi si prepara la risposta:

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 confine chiamato frame.

Nel ciclo, la funzione prima cattura un frame dalla fotocamera:

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

Se il frame viene catturato con successo, si costruisce un header che descrive l’immagine JPEG e lo si invia al client:

    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 la fotocamera ESP32-WROVER:

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

Prima viene creato un oggetto Config. La funzione setPins configura i pin della fotocamera basandosi sulla scheda FreeNove. L’ESP32-WROVER CAM è di FreeNove ed è quello che devi impostare qui. Puoi trovare il pin configurations of other supported boards here.

setResolution definisce la risoluzione da usare, mentre setBufferCount determina quanti buffer di immagine vengono usati internamente, cosa che può aiutare ad avere frame rate più veloci.

La funzione setJpeg imposta la qualità di compressione JPEG tra 0 e 100. 80 è un buon compromesso tra qualità e dimensione. 90 offre qualità migliore ma una riduzione minore della dimensione dell’immagine. Per video più veloci 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 la scheda ESP32-WROVER 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à dalla tua scheda ESP32-WROVER, ma puoi cambiare il suffisso “stream”. Per la mia scheda, 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.40/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();
}

Questo mappa ogni richiesta a /stream alla funzione handleStream(), poi avvia il server.

setup

La funzione setup() avvia la comunicazione seriale, si connette al Wi-Fi, inizializza la fotocamera e configura il web server:

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

loop

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

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

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

Nel complesso, questo codice crea un server di streaming MJPEG semplice ma efficace, accessibile da qualsiasi browser web nella stessa rete, fornendo un feed video live dalla ESP32-WROVER CAM.

Per caricare questo codice sulla tua ESP32-WROVER CAM, seleziona la scheda ESP32 Wrover Module e premi il pulsante di download.

Select ESP32 Wrover Module as board — Seleziona ESP32 Wrover Module come scheda

Se hai bisogno di aiuto, dai un’occhiata al nostro Programming the ESP32-WROVER CAM tutorial.

Conclusioni

In questo tutorial hai imparato come trasmettere video da un ESP32-WROVER CAM sulla tua rete Wi-Fi locale al browser web.

L’ESP32-WROVER CAM funziona molto bene ma è una scheda piuttosto grande. Se ti serve una scheda con un ingombro più piccolo, ti consiglio la XIAO-ESP32-S3-Sense, che è piccolissima – un cubo di circa 20mm.

Per il rilevamento oggetti dai anche un’occhiata al Object Detection with ESP32-CAM and YOLO tutorial. È scritto per l’ESP32-CAM ma richiede solo una minima modifica (cfg.setPins(pins::FreeNove)) per funzionare con l’ESP32-WROVER CAM.

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

Buon divertimento con il tinkering ; )

Stefan Maetschke