ESP32-CAM est un module ESP-WROOM-32 du fabricant AI Thinker associé à une caméra couleur 2MP OV2640. Le module ESP32-CAM dispose également d’un lecteur de carte SD qui pourra servir à enregistrer des images lorsqu’un événement est détecté (détecteur de présence ou de mouvement par exemple). Espressif fournit une API complète qui permet d’accéder à toutes les fonctionnalités du module caméra. C’est vraiment une excellente base pour développer son propre système de vidéo surveillance IP sans avoir la crainte que le flux vidéo arrive sur des serveurs douteux.

Un exemple de serveur vidéo est proposé par Espressif dans le SDK des cartes ESP32. Vous pouvez l’installer très simplement en suivant la procédure décrite dans ce tutoriel. Le flux vidéo du serveur vidéo n’est pas supporté par Domoticz, Jeedom (et de facto par NextDom). J’ai donc fait une adaptation d’un exemple proposé sur le GitHub d’Espressif. Ce firmware diffuse deux flux vidéos. Le premier est une image fixe que l’on pourra intégrer à l’aide du module Camera officiel de Jeedom, Nextdom ainsi qu’à Domoticz. C’est le serveur domotique qui s’occupe de récupérer un image à intervalle régulier. Le second est un flux vidéo au format MJPEG. On pourra l’intégrer à Home Assistant, Hass.io ou Node-RED. Le firmware devrait être compatible avec d’autres modules caméra ESP32 tel que M5Stack, ESP Eye et Wrover Kit d’Espressif mais je ne dispose pas des cartes pour tester. N’hésitez pas à me signaler vos retours dans les commentaires.

Un exemple de reconnaissance faciale est également disponible. Attention, une simple photo suffit pour leurrer le programme de reconnaissance faciale !! Ne l’utilisez pas pour déverrouiller votre porte d’entrée 😉 .

Présentation du module ESP32-CAM de AI Thinker

Le module ESP32-CAM a été développé par le fabricant chinois AI Thinker sur la base du module ESP32 ESP-WROVER-32 à 240Mhz équipé de 520 Ko intégrée de SRAM et 4 Mo de PSRAM externe (pour le stockage des programmes et données de l’utilisateur). La carte qui ne mesure que 27 x 40.5 x 4.5 mm est équipée d’un lecteur de carte micro SD et d’une LED flash. La documentation détaillée est disponible (en chinois) sur cette page.

ESP32-CAM AI Thinker. Vues du dessus et du dessous. Reset, flash LED, connecteur caméra DVP, lecteur de carte SD

16 broches de l’ESP-WROVER-32 sont exposées. On pourra par exemple ajouter une sonde climatique (BME280) ou un détecteur de mouvement au module caméra. Les broches U0T (GPIO1 port série TX) et U0R (GPIO3, port série RX) seront nécessaires pour téléverser le programme. La broche IO0 (GPIO0) sera nécessaire pour mettre l’ESP32 en flash mode pour téléverser le programme.

Les broches GPIO2 GPIO4 GPIO12 GPIO13 GPIO14 GPIO15 GPIO16 sont disponibles pour vos projets.

Repérage de broches (pinout) de l’ESP32-CAM

Plusieurs broches sont utilisées pour le module caméra OV2640 et le lecteur de carte micro SD qui utilise le bus SPI standard

Par défaut, la carte est livrée avec un module caméra 2MP (1600*1200 pixels) OV2640 du fabricant OmniVision. La librairie est compatible avec le module OV7670. Attention, contrairement à ce qu’on pourrait croire, l’OV7670 n’offre une résolution que de 640×480 pixels.

Pour une application de vidéo surveillance, on trouve des modules OV2640 avec une optique de type fisheye pouvant atteindre jusqu’à 160° (au lieu de 78° en standard) qui est mieux adaptée.

Le design du module ESP32-CAM étant Open Source, de très (très) nombreux fabricants produisent cette carte. On la trouve maintenant très facilement

Voir plus de modules ESP32-CAM

Circuit pour flasher un firmware sur l’ESP32-CAM

La carte ESP32-CAM est dépourvu de connecteur micro USB (ainsi que de convertisseur USB vers Série). C’est étonnant pour une carte de développement. Il faudra donc penser à acheter un module FTDI si vous n’en possédez pas encore. Vous aurez également besoin de quelques jumpers femelle-femelle. Connectez les broches du module FTDI comme ceci.

FTDI	ESP32 CAM
5V	5V
GND	GND
TX	UOT
RX	UOR
	IO0 sur GND + RESET à chaque téléversement

Avant de pouvoir téléverser le programme depuis l’IDE Arduino (ou un autre environnement), il faudra mettre l’ESP32 en flash mode. Pour cela, il faut connecter la broche IO0 à la broche GND puis faire un reset (ou mettre sous tension).

Installation de l’IDE Arduino et des librairies pour les cartes ESP32

Ce paragraphe s’adresse à tous ceux qui débutent dans le monde des micro-contrôleurs. Si vous disposez déjà d’un IDE Arduino et des librairies nécessaires pour les cartes ESP32, vous pouvez directement sauter à l’étape suivante.

Remarque. N’oubliez pas de mettre à jour le SDK des cartes ESP32 avant d’aller plus loin.

Commencez par télécharger et installer l’IDE Arduino qui convient à votre environnement en vous rendant sur le site officiel. Une fois installé, lancez l’IDE Arduino.

Ouvrez le panneau des préférences et cliquez sur le bouton situé à droite de l’option URL de gestionnaire de cartes supplémentaires.

Dans la boîte de dialogue qui s’ouvre, ajoutez le lien suivant puis cliquez sur OK

https://dl.espressif.com/dl/package_esp32_index.json

Ouvrez le gestionnaire de carte depuis le menu Outils puis Type de carte

Cherchez le SDK avec le mot clé ESP32 puis cliquez sur installer.

Maintenant que les cartes ESP32 sont gérées depuis le gestionnaire de carte, les librairies pourront être mises à jour dès qu’une nouvelle version est disponible.

Vous trouverez d’autres tutoriels pour allez plus loin avec l’IDE Arduino ici.

Sélection du module ESP32

Maintenant que le framework ESP32 est installé, il faut sélectionner le module ESP32 Wrover dans la liste utilisé par AI Thinker. Ouvrez le menu Outils et faites descendre la liste Type de carte. Modifiez ensuite les réglages suivants :

• Flash Mode : QIO (par défaut normalement)
• Partition Schema : Huge APP (3MB No OTA)
• Core Debug Level : il est directement géré dans les paramètres du programme (paragraphe suivant)
• Port : sélectionnez le port USB sur lequel est connecté le module FTDI. Ici un exemple sur macOS. Sur Windows, il prendra la forme COMx

Installation du firmware sur l’ESP32-CAM. Image JPEG et flux vidéo

Comme je l’ai dit en introduction, de nombreux logiciels domotiques ne supportent pas l’intégration d’un flux vidéo au format MJPG, voici une petit adaptation d’un exemple publié par Espressif sur son compte GitHub.

Voir le code source sur Github

Vous disposez de plusieurs réglages de base au début du programme.

Tout d’abord, il est possible d’activer le débogueur du firmware ESP32

#define SERIAL_DEBUG true // Enable / Disable log - activer / désactiver le journal
#define ESP_LOG_LEVEL ESP_LOG_VERBOSE // ESP_LOG_NONE, ESP_LOG_VERBOSE, ESP_LOG_DEBUG, ESP_LOG_ERROR, ESP_LOG_WARM, ESP_LOG_INFO

Le firmware délivre deux sorties vidéos. Une capture fixe qui nécessite une actualisation manuelle de la page web. Un flux vidéo au format MJPEG. Vous pouvez changer le port du serveur web et l’URL de sortie en fonction de vos besoins

// Web server port - port du serveur web
#define WEB_SERVER_PORT 80
#define URI_STATIC_JPEG "/jpg/image.jpg"
#define URI_STREAM "/stream"

Enfin vous pouvez changer l’orientation de l’image en fonction de la position de la caméra ainsi que le niveau de compression

// Basic image Settings (compression, flip vertical orientation) - Réglages basiques de l'image (compression, inverse l'orientation verticale)
#define FLIP_V true // Vertical flip - inverse l'image verticalement
#define MIRROR_H true // Horizontal mirror - miroir horizontal
#define IMAGE_COMPRESSION 10 //0-63 lower number means higher quality - Plus de chiffre est petit, meilleure est la qualité de l'image, plus gros est le fichier

N’oubliez pas enfin d’indiquer vos identifiants de connexion au réseau Wi-Fi

//Replace with your network credentials - Remplacez par vos identifiants de connexion WiFi
const char* ssid = "xxxx";
const char* password = "xxxx";

Créez un nouveau croquis et coller le code suivant puis

• Modifiez vos paramètres.
• Mettez l’ESP32 en flash Mode en reliant la broche IO0 au GND puis en faisant un RESET avec le bouton situé sur la face intérieure de la carte
• Téléversez le croquis

/*********
  projetsdiy.fr - diyprojects.io

  IMPORTANT BEFORE TO DOWNLOAD SKETCH !!!
   - Install ESP32 libraries
   - Select Board "ESP32 Wrover Module"
   - Select the Partion Scheme "Huge APP (3MB No OTA)"
   - GPIO 0 must be connected to GND to upload a sketch
   - After connecting GPIO 0 to GND, press the ESP32-CAM on-board RESET button to put your board in flashing mode

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.

  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include 
#include 
#include "esp_timer.h"
#include "esp_camera.h"

#include 
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h"           //disable brownout problems
#include "soc/rtc_cntl_reg.h"  //disable brownout problems
#include "dl_lib.h"
#include "esp_http_server.h"    // API https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/protocols/esp_http_server.html

#include "driver/sdmmc_host.h"
#include "driver/sdmmc_defs.h"
#include "sdmmc_cmd.h"
#include "esp_vfs_fat.h"

//Replace with your network credentials - Remplacez par vos identificants de connexion WiFi
const char* ssid = "XXXX";
const char* password = "XXXX"; 

#define SERIAL_DEBUG true                // Enable / Disable log - activer / désactiver le journal
#define ESP_LOG_LEVEL ESP_LOG_VERBOSE    // ESP_LOG_NONE, ESP_LOG_VERBOSE, ESP_LOG_DEBUG, ESP_LOG_ERROR, ESP_LOG_WARM, ESP_LOG_INFO

// Web server port - port du serveur web
#define WEB_SERVER_PORT 80
#define URI_STATIC_JPEG "/jpg/image.jpg"
#define URI_STREAM "/stream"

// Basic image Settings (compression, flip vertical orientation) - Réglages basiques de l'image (compression, inverse l'orientation verticale)
#define FLIP_V true            // Vertical flip - inverse l'image verticalement
#define MIRROR_H true          // Horizontal mirror - miroir horizontal
#define IMAGE_COMPRESSION 10   //0-63 lower number means higher quality - Plus de chiffre est petit, meilleure est la qualité de l'image, plus gros est le fichier

static const char *TAG = "esp32-cam";

/*
   Handler for video streaming - Entête pour le flux vidéo
*/
#define PART_BOUNDARY "123456789000000000000987654321"
static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

// Uncomment your dev board model - Décommentez votre carte de développement
// This project was only tested with the AI Thinker Model - le croquis a été testé uniquement avec le modèle AI Thinker
//#define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
#define CAMERA_MODEL_AI_THINKER

#if defined(CAMERA_MODEL_WROVER_KIT)
#define PWDN_GPIO_NUM    -1
#define RESET_GPIO_NUM   -1
#define XCLK_GPIO_NUM    21
#define SIOD_GPIO_NUM    26     //Flash LED - Flash Light is On if SD card is present
#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      19
#define Y4_GPIO_NUM      18
#define Y3_GPIO_NUM       5
#define Y2_GPIO_NUM       4
#define VSYNC_GPIO_NUM   25
#define HREF_GPIO_NUM    23
#define PCLK_GPIO_NUM    22

#elif defined(CAMERA_MODEL_M5STACK_PSRAM)
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    15
#define XCLK_GPIO_NUM     27
#define SIOD_GPIO_NUM     25
#define SIOC_GPIO_NUM     23
#define Y9_GPIO_NUM       19
#define Y8_GPIO_NUM       36
#define Y7_GPIO_NUM       18
#define Y6_GPIO_NUM       39
#define Y5_GPIO_NUM        5
#define Y4_GPIO_NUM       34
#define Y3_GPIO_NUM       35
#define Y2_GPIO_NUM       32
#define VSYNC_GPIO_NUM    22
#define HREF_GPIO_NUM     26
#define PCLK_GPIO_NUM     21

#elif defined(CAMERA_MODEL_AI_THINKER)
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26  //Flash LED - Flash Light is On if SD card is present
#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
#else
#error "Camera model not selected"
#endif

httpd_handle_t stream_httpd = NULL;

/*
   This method only stream one JPEG image - Cette méthode ne publie qu'une seule image JPEG
   Compatible with/avec Jeedom / NextDom / Domoticz
*/
static esp_err_t capture_handler(httpd_req_t *req) {
  camera_fb_t *fb = NULL;
  esp_err_t res = ESP_OK;
  size_t fb_len = 0;
  int64_t fr_start = esp_timer_get_time();

  res = httpd_resp_set_type(req, "image/jpeg");
  if (res == ESP_OK)
  {
    res = httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=image.jpg");  //capture
  }
  if (res == ESP_OK) {
    ESP_LOGI(TAG, "Take a picture");
    //while(1){
    fr_start = esp_timer_get_time();
    fb = esp_camera_fb_get();
    if (!fb)
    {
      ESP_LOGE(TAG, "Camera capture failed");
      httpd_resp_send_500(req);
      return ESP_FAIL;
    } else {
      fb_len = fb->len;
      res = httpd_resp_send(req, (const char *)fb->buf, fb->len);

      esp_camera_fb_return(fb);
      // Uncomment if you want to know the bit rate - décommentez pour connaître le débit
      //int64_t fr_end = esp_timer_get_time();
      //ESP_LOGD(TAG, "JPG: %uKB %ums", (uint32_t)(fb_len / 1024), (uint32_t)((fr_end - fr_start) / 1000));
      return res;
    }
    //}
  }
}

/*
   This method stream continuously a video
   Compatible with/avec Home Assistant, HASS.IO
*/
esp_err_t stream_handler(httpd_req_t *req) {
  camera_fb_t * fb = NULL;
  esp_err_t res = ESP_OK;
  size_t _jpg_buf_len;
  uint8_t * _jpg_buf;
  char * part_buf[64];
  static int64_t last_frame = 0;
  if (!last_frame) {
    last_frame = esp_timer_get_time();
  }

  res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
  if (res != ESP_OK) {
    return res;
  }
  ESP_LOGI(TAG, "Start video streaming");
  while (true) {
    fb = esp_camera_fb_get();
    if (!fb) {
      ESP_LOGE(TAG, "Camera capture failed");
      res = ESP_FAIL;
    } else {
      if (fb->format != PIXFORMAT_JPEG) {
        bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
        if (!jpeg_converted) {
          ESP_LOGE(TAG, "JPEG compression failed");
          esp_camera_fb_return(fb);
          res = ESP_FAIL;
        }
      } else {
        _jpg_buf_len = fb->len;
        _jpg_buf = fb->buf;
      }
    }
    if (res == ESP_OK) {
      size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);

      res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
    }
    if (res == ESP_OK) {
      res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
    }
    if (res == ESP_OK) {
      res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
    }
    if (fb->format != PIXFORMAT_JPEG) {
      free(_jpg_buf);
    }
    esp_camera_fb_return(fb);
    if (res != ESP_OK) {
      break;
    }

    //Uncomment if you want to know the bit rate - décommentez pour connaître le débit
    /*
      int64_t fr_end = esp_timer_get_time();
      int64_t frame_time = fr_end - last_frame;
      last_frame = fr_end;
      frame_time /= 1000;
      ESP_LOGD(TAG, "MJPG: %uKB %ums (%.1ffps)",
        (uint32_t)(_jpg_buf_len/1024),
        (uint32_t)frame_time, 1000.0 / (uint32_t)frame_time);
    */
  }

  last_frame = 0;
  return res;
}

void startCameraServer() {
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.server_port = WEB_SERVER_PORT;

  // endpoints
  static const httpd_uri_t static_image = {
    .uri       = URI_STATIC_JPEG,
    .method    = HTTP_GET,
    .handler   = capture_handler,
    .user_ctx  = NULL
  };

  static const httpd_uri_t stream_video = {
    .uri       = URI_STREAM,
    .method    = HTTP_GET,
    .handler   = stream_handler,
    .user_ctx  = NULL
  };

  ESP_LOGI(TAG, "Register URIs and start web server");
  if (httpd_start(&stream_httpd, &config) == ESP_OK) {
    if ( httpd_register_uri_handler(stream_httpd, &static_image) != ESP_OK) {
      ESP_LOGE(TAG, "register uri failed for static_image");
      return;
    };
    if ( httpd_register_uri_handler(stream_httpd, &stream_video) != ESP_OK) {
      ESP_LOGE(TAG, "register uri failed for stream_video");
      return;
    };
  }
}

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector

  Serial.begin(115200);
  Serial.setDebugOutput(SERIAL_DEBUG);
  esp_log_level_set("*", ESP_LOG_LEVEL);

  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_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;       //XCLK 20MHz or 10MHz
  config.pixel_format = PIXFORMAT_JPEG; //YUV422,GRAYSCALE,RGB565,JPEG
  config.frame_size = FRAMESIZE_SVGA;   //UXGA SVGA VGA QVGA Do not use sizes above QVGA when not JPEG
  config.jpeg_quality = 10;
  config.fb_count = 2;                  //if more than one, i2s runs in continuous mode. Use only with JPEG

  // Camera init - Initialise la caméra
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    ESP_LOGE(TAG, "Camera init failed with error 0x%x", err);
    return;
  } else {
    ESP_LOGD(TAG, "Camera correctly initialized ");
    sensor_t * s = esp_camera_sensor_get();
    s->set_vflip(s, FLIP_V);
    s->set_hmirror(s, MIRROR_H);
  }

  // Wi-Fi connection - Connecte le module au réseau Wi-Fi
  ESP_LOGD(TAG, "Start Wi-Fi connexion ");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  ESP_LOGD(TAG, "Wi-Fi connected ");

  // Start streaming web server
  startCameraServer();

  ESP_LOGI(TAG, "Camera Stream Ready");
  Serial.println(WiFi.localIP());
}

void loop() {
  delay(1);
}

Voir le code source sur Github

Tester si tout fonctionne correctement

Un fois que le programme est téléversé, l’IDE Arduino affiche le message Téléversement terminé.

Ouvrez le moniteur série depuis le menu Outils. Débranchez la broche IO0 du GND et faites un RESET sur la carte. Si vous avez activé le journal de déboggage, vous obtiendrez immédiatement l’adresse IP de la caméra.

Connectez-vous sur l’adresse http://IP_ESP32CAM/stream pour visualiser directement le flux vidéo

Intégrer le module ESP32-CAM à un serveur domotique

Maintenant, il est très facile d’intégrer le flux vidéo ou la capture dans la majorité des serveurs domotiques Open Source. Voici plusieurs guides détaillés pour Domoticz, Jeedom / Nexdom et Home Assistant

A LIRE AUSSI :

Intégrer un module ESP32-CAM à Domoticz (firmware modifié)

Utiliser la LED Flash dans vos projets

L’ESP32-CAM dispose d’une LED flash sur la face avant de la carte. Elle est connectée au GIPO4 (broche n°26) de l’ESP32 comme on peut le voir sur le diagramme ci-dessous. Manque de chance cette broche est partagée avec la broche DATA1 du lecteur de carte SD (repère HS2_DATA1 sur le diagramme). Si vous n’utilisez pas le lecteur de carte micro SD dans vos projets, vous pourrez piloter la LED Flash. Dans le cas contraire, celle-ci est allumée en permanence dès qu’une carte SD est présente dans le lecteur. C’est un peu dommage car la LED allumée risque de signaler la présence de la caméra ou provoquer une gêne visuelle dans une chambre. C’est aussi problématique si l’on souhaite faire fonctionner l’ESP32-CAM sur batterie ou chaque micro-ampère consommé diminue d’autant l’autonomie.

Diagramme ESP32-CAM v1.6 disponible sur GitHub

Voici un exemple de code à intégrer à votre projet pour désactiver la LED Flash (uniquement si vous n’enregistrez pas d’image sur la carte micro SD)

int PIN_LED_LED = 4;

setup(){
    pinMode(PIN_LED_LED, OUTPUT);
}

loop(){
   digitalWrite(PIN_LED_LED, LOW);
}

Voilà, il ne reste plus qu’à développer votre propre caméra de surveillance IP. Pour être parfait, il faudra pensez à mettre en place une authentification (au moins avec un identifiant et mot de passe). Pour le moment le flux vidéo et l’image sont accessibles sans restriction. Ce n’est pas un (trop gros) problème si la caméra est connectée au réseau WiFi local mais il faudra mettre en place plus de sécurité si le module ESP32-CAM doit être exposé à internet. Je vous conseille de connecter votre flux vidéo à un serveur domotique sécurisé avec un certificat SSL pour ne pas avoir à gérer ce développement.

Avez-vous aimé cet article ?