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 😉 .
Sommaire
- 1 Présentation du module ESP32-CAM de AI Thinker
- 2 Circuit pour flasher un firmware sur l’ESP32-CAM
- 3 Installation de l’IDE Arduino et des librairies pour les cartes ESP32
- 4 Sélection du module ESP32
- 5 Installation du firmware sur l’ESP32-CAM. Image JPEG et flux vidéo
- 6 Tester si tout fonctionne correctement
- 7 Intégrer le module ESP32-CAM à un serveur domotique
- 8 Utiliser la LED Flash dans vos projets
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 ?
[Total: 8 Moyenne: 5]