Diffuser une vidéo avec ESP32-WROVER CAM

Dans ce tutoriel, je vais vous montrer comment diffuser une vidéo depuis une carte Freenove ESP32-WROVER CAM sur votre réseau Wi-Fi local vers votre navigateur Web. Cela signifie que vous pouvez facilement créer votre propre système de caméra de surveillance sans fil que vous pouvez surveiller depuis votre ordinateur.

Si vous n’avez jamais utilisé cette carte auparavant, je vous suggère de lire le Programming the ESP32-WROVER CAM tutoriel en premier, qui vous aidera à démarrer avec la carte.

Overview

Pièces requises

Vous aurez besoin d’une carte Freenove ESP32-WROVER CAM pour suivre ce tutoriel. En général, la carte est livrée avec des accessoires tels qu’une carte SD, un lecteur de carte SD et un câble USB-C, mais au cas où ils manqueraient, je les ai également liés ci-dessous.

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.

Diffusion vidéo

Dans ce projet, nous allons mettre en place un serveur de streaming vidéo qui fonctionne sur l’ESP32-WROVER. La caméra de l’ESP32-WROVER capture des images et les diffuse via le Wi-Fi. Le routeur Wi-Fi transmet ces images au navigateur Web de votre PC, qui les affiche sous forme de flux vidéo. L’image ci-dessous illustre l’architecture du système :

Streaming Video via local Wi-Fi — Diffusion vidéo via Wi-Fi local

Notez que le flux vidéo n’est pas chiffré ni sécurisé, mais sera uniquement visible via une URL au sein de votre réseau Wi-Fi local, par exemple 192.168.2.40/stream. Seules les personnes ayant accès à votre réseau Wi-Fi pourront voir le flux vidéo.

Code simple pour un serveur de streaming vidéo

Le cœur pour l’ESP32-WROVER CAM est fourni avec un exemple de code pour un CameraWebServer qui diffuse des vidéos ; voir le Programming the ESP32-WROVER CAM tutoriel pour plus de détails. Mais ce code est complexe et l’interface du serveur Web offre de nombreuses options.

C’est parfait pour expérimenter, mais si vous voulez juste le flux vidéo simple (par exemple pour Home Assistant) et un code simple que vous pouvez intégrer à d’autres fonctions, comme un flux vidéo activé par détection de mouvement, alors le code suivant est plus facile à utiliser.

La simplification est en grande partie due à la bibliothèque esp32cam, que vous pouvez installer via le gestionnaire de bibliothèques dans l’Arduino IDE. Il suffit de chercher « esp32cam » et d’appuyer sur INSTALL. L’image ci-dessous montre l’installation terminée :

esp32cam library installed via Library Manager — Bibliothèque esp32cam installée via le gestionnaire de bibliothèques

Vous trouverez ci-dessous le code complet pour le serveur de streaming vidéo, qui utilise la bibliothèque esp32cam. Jetez-y un coup d’œil rapide, puis nous en examinerons les détails :

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

Bibliothèques

Le sketch commence par inclure les bibliothèques nécessaires :

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

Ces bibliothèques permettent la fonctionnalité de serveur HTTP (WebServer.h), la connectivité Wi-Fi (WiFi.h), et le contrôle de la caméra via la bibliothèque esp32cam.

Constantes

Ensuite, nous définissons des constantes pour les paramètres Wi-Fi et caméra :

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

Les variables WIFI_SSID et WIFI_PASS stockent les identifiants du réseau Wi-Fi. Vous devrez remplacer SSID et PASSWORD par les informations de connexion réelles de votre réseau Wi-Fi.

Le URL est le chemin sur lequel le flux vidéo sera diffusé. Vous pouvez le changer comme vous le souhaitez. Par exemple, « /video » ou « /frontdoor », assurez-vous simplement de garder la barre oblique (‘/’) au début.

La variable RESOLUTION définit la résolution souhaitée pour la caméra. Voici une liste des valeurs possibles pour la résolution de la caméra, bien que selon la caméra, toutes ne fonctionnent pas forcément :

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

Objets

La ligne suivante crée l’objet serveur HTTP qui écoute sur le port 80. C’est notre serveur web qui fournit le flux vidéo.

WebServer server(80);

handleStream

La fonction handleStream() gère le flux vidéo chaque fois qu’un client accède au chemin /stream :

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

Cette ligne récupère le client actuellement connecté au serveur. La réponse est ensuite préparée :

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

Cet en-tête indique au navigateur qu’il va recevoir un flux MJPEG multipart, où chaque partie est séparée par une frontière appelée frame.

Dans la boucle, la fonction capture d’abord une image de la caméra :

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

Si une image est capturée avec succès, un en-tête décrivant l’image JPEG est construit et envoyé au 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 fonction initCamera() configure et démarre la caméra 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);
}

D’abord, un objet Config est créé. La fonction setPins configure les broches de la caméra selon la carte FreeNove. L’ESP32-WROVER CAM est de FreeNove et c’est ce que vous devez définir ici. Vous pouvez trouver le pin configurations of other supported boards here.

setResolution définit la résolution à utiliser, tandis que setBufferCount détermine le nombre de tampons d’image utilisés en interne, ce qui peut aider à obtenir des fréquences d’images plus rapides.

La fonction setJpeg règle la qualité de compression JPEG entre 0 et 100. 80 est un bon compromis entre qualité et taille. 90 offre une meilleure qualité mais une réduction de taille moindre. Pour une vidéo plus fluide, vous pouvez réduire la résolution et la compression JPEG, mais évidemment vous obtiendrez des images plus petites avec une qualité inférieure.

Enfin, Camera.begin(cfg) initialise la caméra avec ces paramètres.

initWifi

La fonction initWifi() connecte la carte ESP32-WROVER au réseau Wi-Fi spécifié :

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) désactive l’écriture des identifiants dans la mémoire flash, ce qui accélère la reconnexion. L’appareil est mis en mode station (WIFI_STA), et tente de se connecter au Wi-Fi avec les identifiants donnés.

Une fois connecté, l’adresse IP et le chemin du flux sont affichés dans le moniteur série. Vous devrez copier-coller cette URL affichée dans la barre d’adresse de votre navigateur pour voir le flux vidéo. L’URL réelle dépendra de votre carte ESP32-WROVER, mais vous pouvez changer le suffixe « stream ». Pour ma carte, je vois l’URL suivante dans le moniteur série :

Streaming URL printed to Serial Monitor — URL de streaming affichée dans le moniteur série

Ainsi, je copie « http://192.168.2.40/stream » dans la barre d’adresse de mon navigateur Chrome pour accéder à la vidéo.

initServer

La fonction initServer() associe le chemin de streaming au gestionnaire et démarre le serveur :

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

Cela mappe toute requête vers /stream à la fonction handleStream(), puis démarre le serveur.

setup

La fonction setup() démarre la communication série, connecte au Wi-Fi, initialise la caméra et configure le serveur web :

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

loop

Enfin, la fonction loop() gère en continu les requêtes HTTP entrantes :

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

Cette ligne permet à l’ESP32-WROVER de répondre aux requêtes des clients en invoquant les gestionnaires enregistrés tels que handleStream().

Dans l’ensemble, ce code crée un serveur de streaming MJPEG simple mais efficace, accessible depuis n’importe quel navigateur web sur le même réseau, fournissant un flux vidéo en direct depuis l’ESP32-WROVER CAM.

Pour télécharger ce code sur votre ESP32-WROVER CAM, sélectionnez la carte ESP32 Wrover Module et appuyez sur le bouton de téléchargement.

Select ESP32 Wrover Module as board — Sélectionnez ESP32 Wrover Module comme carte

Si vous avez besoin d’aide, consultez notre Programming the ESP32-WROVER CAM tutoriel.

Conclusions

Dans ce tutoriel, vous avez appris à diffuser une vidéo depuis un ESP32-WROVER CAM via votre réseau Wi-Fi local vers votre navigateur Web.

L’ESP32-WROVER CAM fonctionne très bien mais c’est une carte assez volumineuse. Si vous avez besoin d’une carte avec un encombrement plus réduit, je vous suggère le XIAO-ESP32-S3-Sense, qui est minuscule – un cube d’environ 20 mm.

Pour la détection d’objets, jetez aussi un œil au Object Detection with ESP32-CAM and YOLO tutoriel. Il est écrit pour l’ESP32-CAM mais nécessite seulement un changement minimal (cfg.setPins(pins::FreeNove)) pour fonctionner avec l’ESP32-WROVER CAM.

Si vous avez des questions, n’hésitez pas à les laisser dans la section des commentaires.

Bon bricolage ; )

Stefan Maetschke