ESP32-CAM, flash du firmware. Test sur Domoticz, Jeedom, Home Assistant, NextDom, Node-RED

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.

ai thinker esp32 cam diagram

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

Un connecteur uFL (IPEX) pour antenne externe est également disponible mais il faudra souder une résistance CMS pour pouvoir l’utiliser (autant dire que ce n’est pas gagné !).

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) et U0R (GPIO3) 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 et GPIO16 sont disponibles pour vos projets.

ai thinker esp32 cam pinout

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

ai thinker esp32 cam pinout ov2640

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.

Par contre 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 pour une application de vidéosurveillance.

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

Circuit pour flasher un firmware

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.

Comme vous pouvez le constater les broches RX / TX ne sont pas croisées comme cela devrait être normalement le cas. Si vous rencontrez des problèmes, croisez les broches RX/TX. Il y a peut être une erreur sur ma carte ESP32-CAM générique.

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

J’ai essayé d’alimenter le module via la broche VCC ou 3V3 sans succès. Cela dépend peut être d’un fabricant à l’autre.

esp32cam pinout ftdi cable ide arduino

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).

Après chaque téléversement, déconnectez la broche IO0 du GND et faites un RESET pour redémarrer le firmware.

esp32-cam diagram flash mode firmware ide arduino ftdi cable

 

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. Un dépôt permet maintenant d’installer le SDK depuis le gestionnaire de cartes de l’IDE Arduino. Suivez ce tutoriel pour en savoir plus.

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.

sdk espressif esp32 ide arduino preferences

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

Attention, une ligne par URL.

link sdk espressif esp32 ide arduino

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

2 install sdk espressif esp32 ide arduino

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

install sdk espressif esp32 ide arduino

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

esp32 wrover ai thinker ide arduino parameters

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. En attendant de développer un firmware plus complet, j’ai fait une petit adaptation d’un exemple publié par Espressif sur son compte 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
  Complete project details at https://RandomNerdTutorials.com

  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 <esp_event_loop.h>
#include <esp_log.h>
#include "esp_timer.h"
#include "esp_camera.h"

#include <WiFi.h>
#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);
}

Tester si tout fonctionne correctement

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

ide arduino esp32 ai thinker upload completed

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 ave activé le journal de déboggage, vous obtiendrez immédiatement l’adresse IP de la caméra.

ip esp32cam ide arduino serial monitor

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

esp32-cam test ios

Intégrer le module ESP32-CAM sur Jeedom et NextDom

Pour une raison qui m’échappe encore, le plugin RTSP refuse obstinément d’accepter le protocole HTTP. J’ai donc du me tourner vers le officiel caméra (payant).

jeedom camera plugin officiel

Après installation et activation du plugin, ouvrez le panneau sécurité puis caméra. Cliquer sur Ajouter pour intégrer la caméra ESP32-CAM à Jeedom.

jeedom add new camera

Rien de bien méchant au niveau de la configuration. Il suffit d’indiquer l’IP de la caméra et d’indiquer l’adresse /jpg/image.jpg dans les deux champs URL de snapshot et URL de flux. N’indiquer aucun type de caméra. N’oubliez pas d’attribuer un objet, d’activer et de rendre visible l’accessoire avant de sauvegarder.

jeedom camera plugin esp32-cam reglage url flux snapshot ip

Je vous conseille d’aller sur l’onglet Image et d’ajuster la taille de l’image (30% donne un bon résultat avec une image SVGA de 800 x 600 pixels).

jeedom camera redimensionnement image widget esp32-cam

Vous pouvez créer un mini film plutôt que d’enregistrer des captures en cochant l’option Toujours faire une video sur l’onglet Capture. N’oubliez pas d’indiquer le nombre d’images par seconde à capturer.

jeedom camera capture mini video esp32-cam

Voilà, Jeedom et NextDom récupèrent (ici toutes les 5 secondes) une image sur l’ESP32-CAM et l’affiche correctement dans le Widget.

jeedom esp32-cam widget

Widget ESP32-CAM sur Jeedom

nextdom esp32-cam widget

ESP32-CAM sur NextDom

L’enregistrement de cliché et d’une vidéo fonctionne parfaitement sur Jeedom mais pas encore sur NextDom (j’ai signalé le problème)

historique capture image video esp32-cam jeedom

Intégrer le module ESP32-CAM sur Domoticz

La gestion des caméras de surveillance n’est pas le point fort de Domoticz. Elles sont cachées dans le menu de configuration puis plus d’options et enfin Caméras !

domoticz camera settings

Cliquer sur Ajouter une Caméra

domoticz add new camera ip

Configurer la caméra avec les paramètres suivants :

  • Activer
  • Attribuer un nom à la caméra
  • Choisir HTTP dans le protocole
  • Indiquer l’adresse IP de la caméra
  • Changer le port si nécessaire (80 par défaut dans le firmware)
  • Dans le champ ImageURL, indiquer jpg/image.jpg. Attention, il faut absolument retirer le / sinon ça ne fonctionne pas
  • Cliquer sur Tester la Connexion. Si tout est correct, un image apparaît dans la fenêtre de droite

Enregistrer en cliquant sur Ajouter.

domoticz setup camera esp32-cam webcam

La caméra ESP32-CAM est maintenant intégrée à Domoticz.

domoticz esp32-cam settings

En cliquant sur la petite WebCam, Domoticz créé un pseudo flux vidéo en actualisant plusieurs fois par seconde l’image capturée. C’est assez fluide mais on ne pourra pas voir des mouvements rapides. Dommage, l’image est un peu tassée verticalement. L’icône appareil photo permet de télécharger un instantané.

 

Astuce pour intégrer d’autres caméras de surveillance IP à Domoticz

C’est toujours un vrai casse tête pour trouver l’url de capture de l’image fixe ou du flux vidéo. Il existe des outils en ligne qui permettent de scanner les url les plus utilisées par les fabricants de caméras IP. Vous pouvez par exemple utiliser le scanner proposé par le site skjm pour vos autres caméras de surveillance IP. Il suffit d’indiquer l’adresse IP de la caméra et le port puis de lancer un scan.

skjm ip cam jpeg mjpeg icam finder

Comme j’ai utilisé un chemin standard pour le firmware, vous devriez trouver l’ESP32-CAM à la ligne 34

find ip camera url network

Intégrer le module ESP32-CAM à Home Assistant (ou hass.io)

Pour Home Assistant ou Hass.io, on va directement utiliser le flux vidéo streamé par la caméra ESP32. Ouvrez le menu dans le coin supérieur droit

Cliquer sur Configure UI

home assistant configure ui

Puis sur le Plus dans le bas de l’écran

home assistant add widget

Choisir le widget Picture

home assistant add picture widget

Saisir l’adresse IP de l’ESP32-CAM. L’URL se termine par /stream. Home Assistant test l’URL à chaque modification. On obtient directement le flux vidéo dès que l’URL est correcte ! Cliquer sur Save pour terminer.

home assistant esp32-cam stream url address

Le flux vidéo est directement affiché en Live sur le dashboard de Home Assistant / Hass.io

home assistant hassio esp32-cam widget

Intégrer le module ESP32-CAM à un dashboard Node-RED

Le plugin Dashboard de Node-RED permet en quelques instants de développer une interface de contrôle pour ses objets connectés sans avoir besoin d’installer un serveur domotique. Si vous ne connaissez pas encore Node-RED, vous pouvez commencer par ici. Vous aurez également besoin d’installer le plugin Dashboard (commencez par lire ce tutoriel).

Une fois que tout est prêt, placez un Node Template sur le flow

node-red template esp32-cam

Faites un double clic pour ouvrir l’éditeur du template et collez le code HTML suivant en modifiant l’adresse IP de la caméra IP.

<div style="margin-bottom: 10px;">
<img src="https://192.168.1.58/stream" width="600px" style="max-width:100%; height:auto;" >
<p>projetsdiy.fr - diyprojects.io</p>
</div>

node-red template dashboard camera esp32-cam

Créez un groupe sur lequel sera placé le Widget de la caméra en cliquant sur le crayon situé à droite de l’option group. Vous pouvez ajuster la largeur du widget avec l’option Width. Enregistrer et sélectionner le groupe avant d’enregistrer le template

node-red dashboard group

Dans la barre latérale droite de Node-RED, cliquer sur l’icône de gestion du Dashboard

node-red open dashboard settings

Puis cliquer sur le bouton d’ouverture de la fenêtre encadré en rouge sur l’image ci-dessous.

open node-red dashboard ip cam esp32-cam

 

Voilà, le flux vidéo de la caméra ESP32-CAM est parfaitement affiché sur le Dashboard. On pourra même y incorporer une interface pour gérer les options (ce sera pour le prochain tutoriel).

node-red esp32-cam widget

Vous pouvez également copier le flow (menu -> import -> clipboard) pour gagner du temps.

[{"id":"e7934f4a.30204","type":"tab","label":"ESP32-CAM","disabled":false,"info":""},{"id":"fe904cea.e0fc7","type":"ui_template","z":"e7934f4a.30204","group":"44d922f7.9de63c","name":"","order":0,"width":"0","height":"0","format":"<div style=\"margin-bottom: 10px;\">\n<img src=\"http://192.168.1.58/stream\" width=\"600px\" style=\"max-width:100%; height:auto;\" >\n<p>projetsdiy.fr - diyprojects.io</p>\n</div>","storeOutMessages":true,"fwdInMessages":true,"templateScope":"local","x":244.5,"y":118,"wires":[[]]},{"id":"44d922f7.9de63c","type":"ui_group","z":"","name":"ESP32-CAM - Node-RED","tab":"d71da7b7.5bc958","disp":true,"width":"8","collapse":false},{"id":"d71da7b7.5bc958","type":"ui_tab","z":"","name":"ESP32-CAM","icon":"dashboard","disabled":false,"hidden":false}]

Voici quelques tutoriels complémentaires si vous voulez développer vos propres Dashboard sans passer par un serveur domotique

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.

ESP32_CAM V1.6 seeed studio diagram

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.

Inscrivez-vous à la newsletter hebdomadaire

Aucun spam et aucun autre usage ne sera fait de votre email. Vous pouvez vous désinscrire à tout moment.

Promos à ne pas louper

13
Poster un Commentaire

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

  S’abonner  
Notifier de
jfj39

Bonjour, Impossible de téléverser la démo,: ci joint les deux messages d’erreur: reset button //////////////////////////////////////////////////////////// nouvel essai à 115200 bauds Arduino : 1.8.10 (Linux), Carte : “ESP32 Wrover Module, Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS), QIO, 80MHz, 115200, None” Le croquis utilise 770410 octets (58%) de l’espace de stockage de programmes. Le maximum est de 1310720 octets. Les variables globales utilisent 48712 octets (14%) de mémoire dynamique, ce qui laisse 278968 octets pour les variables locales. Le maximum est de 327680 octets. esptool.py v2.6 Serial port /dev/ttyUSB0 Connecting……. Chip is ESP32D0WDQ5 (revision 1) Features: WiFi, BT, Dual Core, 240MHz,… Lire la suite »

SCOYEZ Jérôme

Bonjour,
merci pour le tutoriel mais en essayant de compiler le code j’ai l’erreur suivante:
Arduino : 1.8.10 (Windows 7), Carte : “ESP32 Wrover Module, Huge APP (3MB No OTA/1MB SPIFFS), QIO, 80MHz, 921600, Verbose”

Plusieurs bibliothèque trouvées pour “WiFi.h”
sketch_oct19a:30:20: error: dl_lib.h: No such file or directory

compilation terminated.

Utilisé : C:\Users\Pauline\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.4\libraries\WiFi
Non utilisé : C:\Program
exit status 1
dl_lib.h: No such file or directory

Ce rapport pourrait être plus détaillé avec
l’option “Afficher les résultats détaillés de la compilation”
activée dans Fichier -> Préférences.

Pourriez vous me dire comment y remédier?
Par avance merci

Anonyme

Bonjour,

je lui vois de suite la fonctionnalité attendue de surveillance dans le jardin alimenté par du 18650 qui se recharge par petit panneau solaire.
Et qui :
– envoi un message MQTT pour le mouvement détecté afin d’en enregistrer le jour et l’heure
– prend uniquement les photos alors chargées sur carte MicroSD (quelle taille microSD Max est supporté par cette carte, à vérifier) suite au détecteur de mouvements
– la copie du contenu de la microSD pouvant être soit copié en y connectant une cable USB soit par wifi alors uniquement activé sur une tranche horaire prédéfinie (min-max)

Arthur

Très sympa comme tuto ! Pouvez vous nous dire ou vous l’avez acheté ? J’ai essayé avec celui de l’article de chez Ali mais je n’ai jamais réussi à aller au bout du téléversement. J’ai cru comprendre que le FTDI était source de problème, espressif conseille un CP2102. Bon ça n’a toujours pas résolu mon problème du coup j’en attend un autre d’une autre marque pour voir .
Pareil pour moi en projet de me fabriquer mon visiophone de portail ^^.

Johann

Bonjour et merci pour cet article intéressant.
Je pense essayer cet ESP32-CAM. Quelle solution d’alimentation simple me conseilleriez-vous pour la poser dans une pièce de la maison (avec et/ou sans prise électrique…) ?
Merci !

Miguipda

Bonjour,
quel est la taille maximale supportée pour la carte microSD sur cette carte ?
Je n’ai pas trouvé l’info ici ni sur les specs du site de la marque du produit.
D’avance merci de votre réponse.
Bien à vous.

Papou

Et voilà cette fois elle est vraiment active avec Jeedom et un bouton Click Xiaomi. Un coup de sonnette et je reçois un sms et un mail avec 2 photos du gêneur.
Dommage que lorsque cette miniature est connectée sur Jeedom, on ne puisse plus la connecter directement pour modifier le sens de l’image.

Très bel article bien complet !
“Pour une raison qui m’échappe encore, le plugin RTSP refuse obstinément d’accepter le protocole HTTP.”
J’ai développé le plugin RTSP, peux-tu m’en dire plus sur le soucis que tu as rencontré ?
Merci et à bientôt !

sympa cette article, il me manquait une camera à mon portail, mais je ne voulais pas une grosse camera.. cela sera l’occasion de réaliser une petit camera de rue discrète qui s’intégrera a coté du boitier RFID.

Domotique et objets connectés à faire soi-même