Diffuser la vidéo avec le kit ESP32 Camera Pro

Dans ce tutoriel, vous apprendrez à diffuser la vidéo du ESP32 Camera Pro Kit via votre réseau Wi-Fi local vers votre navigateur Web. Nous construisons essentiellement une caméra de surveillance sans fil que vous pouvez surveiller depuis votre ordinateur.

Pièces requises

Pour ce projet, vous aurez besoin du ESP32 Camera Pro Kit de SunFounder et d’un câble 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

Le SunFounder ESP32 Camera Pro Kit offre une plateforme compacte et riche en fonctionnalités pour développer des applications de streaming vidéo sans fil et de vision embarquée.

Au cœur se trouve le module ESP32 WROOM-32E, un microcontrôleur double cœur intégrant la connectivité Wi-Fi et Bluetooth, associé à une caméra OV2640 capable de capturer des images jusqu’à une résolution de 1600 × 1200.

La carte d’extension incluse dans le kit regroupe des périphériques essentiels tels qu’un emplacement pour carte micro-SD, un circuit de charge de batterie, des connecteurs d’extension GPIO et une interface caméra 24 broches, offrant à la fois flexibilité et fiabilité pour le prototypage et le déploiement.

Le kit supporte une seule batterie lithium-ion 18650, permettant un fonctionnement autonome sans alimentation externe. Sa combinaison de stockage embarqué, de réseau sans fil et de fonctionnalité caméra le rend idéal pour des scénarios IoT tels que la surveillance à distance, le streaming en temps réel et la journalisation de données.

ESP32 Camera Pro Kit with Battery and Camera — ESP32 Camera Pro Kit avec batterie et caméra

Spécifications techniques

Composant / Fonctionnalité	Spécification
Microcontrôleur	ESP32 WROOM-32E, double cœur Xtensa® 32 bits LX6 @ jusqu’à 240 MHz
Sans fil	Wi-Fi 802.11 b/g/n, Bluetooth 4.2 (BR/EDR + BLE)
Module caméra	OV2640, capteur 2 MP, jusqu’à 1600 × 1200 de résolution, champ de vision ~68°
Stockage embarqué	Emplacement carte micro-SD (supporte jusqu’à 32 Go, FAT32)
Alimentation	Batterie Li-ion 18650 3,7 V (rechargeable via USB, gestion de charge embarquée)
Interfaces d’extension	Connecteurs GPIO femelles, bornier à vis 14 broches (pas de 3,5 mm)
Interface caméra	Connecteur FFC/FPC 24 broches (dédié à l’OV2640)
Indicateurs	LEDs d’alimentation (PWR) et de charge (CHG)
Interfaces de programmation	Micro-USB (UART, alimentation, charge)

Brochage de l’ESP32 WROOM-32E

Installation du Core ESP32

Si c’est votre premier projet avec une carte de la série ESP32, vous devrez d’abord installer le core ESP32. Si les cartes ESP32 sont déjà installées dans votre Arduino IDE, vous pouvez passer cette section.

Commencez par ouvrir la boîte de dialogue Préférences en sélectionnant “Preferences…” dans le menu “File”. Cela ouvrira la boîte de dialogue Préférences illustrée ci-dessous.

Sous l’onglet Settings, vous trouverez un champ de saisie en bas de la boîte de dialogue intitulé “Additional boards manager URLs“ :

Dans ce champ, copiez l’URL suivante :

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

Cela permettra à l’Arduino IDE de savoir où trouver les bibliothèques du core ESP32. Ensuite, nous installerons les cartes ESP32 via le Boards Manager.

Ouvrez le Boards Manager via « Tools -> Boards -> Board Manager ». Le Boards Manager apparaîtra dans la barre latérale gauche. Tapez « ESP32 » dans le champ de recherche en haut et vous verrez deux types de cartes ESP32 : les « Arduino ESP32 Boards » et les cartes « esp32 par Espressif ». Nous voulons les bibliothèques esp32 par Espressif. Cliquez sur le bouton INSTALL et attendez que le téléchargement et l’installation soient terminés.

Install ESP32 Core libraries — Installer les bibliothèques Core ESP32

Sélection de la carte

Enfin, nous devons sélectionner une carte ESP32. Pour le ESP32 Camera Pro Kit, choisissez la carte générique « AI Thinker ESP32-CAM ». Pour cela, cliquez sur le menu déroulant puis sur « Select other board and port… »:

Drop-down Menu for Board Selection — Menu déroulant pour la sélection de la carte

Cela ouvrira une boîte de dialogue où vous pouvez taper « ai » dans la barre de recherche. Vous verrez la carte « AI Thinker ESP32-CAM » sous Boards. Cliquez dessus, sélectionnez le port COM pour l’activer, puis cliquez sur OK :

Board Selection Dialog "AI Thinker ESP32-CAM" board — Boîte de dialogue de sélection de carte « AI Thinker ESP32-CAM »

Alternativement, vous pouvez aussi sélectionner la plus récente « ESP32 Dev Module« , mais dans ce cas vous devez activer PSRAM et Huge APP dans le menu Tools.

Notez que vous devez connecter la carte via le câble USB à votre ordinateur avant de pouvoir sélectionner un port COM.

Streaming vidéo

Dans ce projet, nous mettons en place un serveur de streaming vidéo qui tourne sur l’ESP32, le microprocesseur intégré au ESP32 Camera Pro Kit. La caméra capture des images et l’ESP32 les diffuse via Wi-Fi. Votre routeur Wi-Fi transmet ensuite ces images à un navigateur Web, qui les affiche sous forme de flux vidéo. L’image ci-dessous illustre le montage :

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

Code pour le serveur vidéo

Le code Arduino suivant implémente le serveur de streaming vidéo qui envoie un flux MJPEG continu du ESP32 Camera Pro Kit vers n’importe quel navigateur connecté au même réseau Wi-Fi.

Nous utiliserons la bibliothèque esp32cam, qui simplifie la gestion de la caméra. Vous pouvez l’installer via le Library Manager dans l’Arduino IDE. Il suffit de chercher « esp32cam » et de cliquer sur INSTALL. L’image ci-dessous montre l’installation terminée :

esp32cam library installed via Library Manager — Bibliothèque esp32cam installée via Library Manager

Voici le code complet du serveur de streaming vidéo. Jetez-y un coup d’œil rapide, puis nous en détaillerons les parties :

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

Includes

Le code 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 (esp32cam.h).

Constantes

Ensuite, nous définissons quelques constantes :

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

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

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

Le RESOLUTION définit la résolution souhaitée pour la caméra en utilisant la bibliothèque esp32cam.

Voici une liste des résolutions possibles pour la caméra, bien que selon la caméra utilisée, 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

Vous pouvez afficher la liste des résolutions de la caméra avec la fonction suivante :

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

Notez que la résolution affectera la fréquence d’images maximale. Avec une résolution de 1600×1200, vous n’aurez pas beaucoup plus de 10 images par seconde.

Objets

La ligne suivante crée un 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 recevra un flux MJPEG multipart, où chaque partie est séparée par une frontière appelée frame.

Dans une boucle, la fonction capture 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, puis envoyé au client sous forme de 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 fonction initCamera() configure et démarre le matériel de la caméra :

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

Ici, un objet Config est créé. La fonction setPins configure les broches de la caméra selon la disposition de la carte AiThinker, qui fonctionne aussi pour le ESP32 Camera Pro Kit.setResolution définit la résolution à utiliser, tandis que setBufferCount détermine le nombre de tampons d’image utilisés en interne.

La fonction setJpeg règle la qualité de compression JPEG. 80 est un bon compromis entre qualité et taille. 90 offre une meilleure qualité mais une réduction de taille moindre. Pour un streaming plus rapide, vous pouvez réduire la résolution et la compression JPEG, mais vous obtiendrez évidemment 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 l’ESP32 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 en 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 fournis.

Une fois connecté, l’adresse IP et le chemin du flux sont affichés sur le moniteur série. Vous devrez copier-coller cette URL dans la barre d’adresse de votre navigateur pour voir le flux vidéo. L’URL réelle dépendra de votre ESP32. Dans mon cas, je vois l’URL suivante sur le moniteur série :

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

Je copie donc « http://192.168.2.39/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() s’exécute une fois au démarrage :

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

Elle lance la communication série, connecte au Wi-Fi, initialise la caméra et configure le serveur web.

loop

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

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

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

Pour flasher ce code sur votre module ESP32, assurez-vous de sélectionner la carte AI Thinker ESP32-CAM :

Select AI Thinker ESP32-CAM as board — Sélectionnez AI Thinker ESP32-CAM comme carte

Conclusions

Dans ce tutoriel, vous avez appris à diffuser une vidéo avec le ESP32 Camera Pro Kit via votre réseau Wi-Fi local vers votre navigateur Web.

Avec la batterie fournie, la prise en charge de la charge et les borniers à vis sur la carte d’extension, il est très facile de construire un système de surveillance alimenté par batterie sans soudure. Par exemple, vous pourriez ajouter une lampe torche et un klaxon pour déclencher une alarme en cas de détection de mouvement. Consultez notre Motion Activated ESP32-CAM tutoriel pour plus d’informations.

Notez que la carte d’extension du ESP32 Camera Pro Kit est relativement grande. Si vous avez besoin d’une carte plus petite avec caméra, vous pouvez utiliser le XIAO-ESP32-S3-Sense. Elle est très compacte, mais si vous souhaitez connecter du matériel supplémentaire, vous devez savoir souder.

Une fois que vous avez un flux vidéo, vous pouvez aussi commencer à détecter des objets dans la vidéo. Voir notre Object Detection with ESP32-CAM and YOLO tutoriel. Il est écrit pour l’ESP32-CAM mais ne nécessite qu’un changement minimal (cfg.setPins(pins::AiThinker)) pour fonctionner avec le ESP32 Camera Pro Kit.

Enfin, jetez un œil à SunFounders Wiki for the ESP32 Camera Pro Kit. Vous y trouverez des informations et projets supplémentaires.

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

Bon bricolage 😉

Stefan Maetschke