ESP32-CAM Prendre des photos et les afficher sur le serveur Web

ESP32-CAM Prendre des photos et les afficher sur le serveur Web

Apprenez à créer un serveur Web avec la carte ESP32-CAM qui vous permet d’envoyer une commande pour prendre une photo et de visualiser la dernière photo capturée dans votre navigateur enregistrée dans SPIFFS. Nous avons également ajouté la possibilité de faire pivoter l’image si nécessaire.

ESP32-CAM Prendre des photos et les afficher sur le serveur Web

Nous avons d’autres projets ESP32-CAM dans notre blog qui pourraient vous plaire. En fait, vous pouvez pousser ce projet plus loin, en ajoutant un capteur PIR pour prendre une photo lorsqu’un mouvement est détecté, un bouton-poussoir physique pour prendre une photo, ou également inclure des capacités de streaming vidéo dans un autre chemin d’URL.

Autres projets et tutoriels ESP32-CAM :

Regardez la démonstration vidéo

Regardez la vidéo de démonstration suivante pour voir ce que vous allez créer tout au long de ce didacticiel.

YouTube video

Pièces requises

Pour suivre ce projet, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

ESP32 CAM Prendre des photos et les afficher sur le serveur

Aperçu du projet

L’image suivante montre le serveur Web que nous allons créer dans ce didacticiel.

ESP32-CAM Affichage du serveur Web de la dernière photo Dernière photo capturée

Lorsque vous accédez au serveur Web, trois boutons s’affichent :

  • TOURNER: selon l’orientation de votre ESP32-CAM, vous devrez peut-être faire pivoter la photo ;
  • CAPTURE DE PHOTOS : lorsque vous cliquez sur ce bouton, l’ESP32-CAM prend une nouvelle photo et l’enregistre dans le SPIFF ESP32. Veuillez attendre au moins 5 secondes avant d’actualiser la page Web pour vous assurer que l’ESP32-CAM prend et stocke la photo ;
  • RAFRAÎCHIR LA PAGE: lorsque vous cliquez sur ce bouton, la page Web s’actualise et est mise à jour avec la dernière photo.

Noter: comme mentionné précédemment, la dernière photo capturée est stockée dans le SPIFF ESP32, donc même si vous redémarrez votre carte, vous pouvez toujours accéder à la dernière photo enregistrée.

Installation du module complémentaire ESP32

Nous allons programmer la carte ESP32 à l’aide de l’IDE Arduino. Donc, vous avez besoin de l’IDE Arduino installé ainsi que du module complémentaire ESP32 :

Installation des bibliothèques

Pour construire le serveur Web, nous utiliserons le ESPAsyncWebServer bibliothèque. Cette bibliothèque nécessite également la AsyncTCP Bibliothèque pour fonctionner correctement. Suivez les étapes suivantes pour installer ces bibliothèques.

Installation de la librairie ESPAsyncWebServer

Suivez les étapes suivantes pour installer le ESPAsyncWebServer bibliothèque:

  1. Cliquez ici pour télécharger la librairie ESPAsyncWebServer. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
  2. Décompressez le dossier .zip et vous devriez obtenir ESPAsyncWebServer-maître dossier
  3. Renommez votre dossier de ESPAsyncWebServer-maître à ESPAsyncWebServer
  4. Bouge le ESPAsyncWebServer dossier dans le dossier des bibliothèques d’installation de votre IDE Arduino

Alternativement, après avoir téléchargé la bibliothèque, vous pouvez aller à Esquisser > Inclure la bibliothèque > Ajouter une bibliothèque .ZIP… et sélectionnez la bibliothèque que vous venez de télécharger.

Installation de la bibliothèque TCP asynchrone pour ESP32

La librairie ESPAsyncWebServer nécessite le AsyncTCP bibliothèque pour travailler. Suivez les étapes suivantes pour installer cette bibliothèque :

  1. Cliquez ici pour télécharger la bibliothèque AsyncTCP. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
  2. Décompressez le dossier .zip et vous devriez obtenir Maître AsyncTCP dossier
  3. Renommez votre dossier de Maître AsyncTCP à AsyncTCP
  4. Bouge le AsyncTCP dossier dans le dossier des bibliothèques d’installation de votre IDE Arduino
  5. Enfin, rouvrez votre IDE Arduino

Alternativement, après avoir téléchargé la bibliothèque, vous pouvez aller à Esquisser > Inclure la bibliothèque > Ajouter une bibliothèque .ZIP… et sélectionnez la bibliothèque que vous venez de télécharger.

Esquisse de serveur Web de prise et d’affichage de photos ESP32-CAM

Copiez le code suivant dans votre IDE Arduino. Ce code construit un serveur Web qui vous permet de prendre une photo avec votre ESP32-CAM et d’afficher la dernière photo prise. Selon l’orientation de votre ESP32-CAM, vous souhaiterez peut-être faire pivoter l’image, nous avons donc également inclus cette fonctionnalité.

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp32-cam-take-photo-display-web-server/
  
  IMPORTANT!!! 
   - Select Board "AI Thinker ESP32-CAM"
   - 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
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include "WiFi.h"
#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <ESPAsyncWebServer.h>
#include <StringArray.h>
#include <SPIFFS.h>
#include <FS.h>

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Create AsyncWebServer object on port 80
AsyncWebServer server(80);

boolean takeNewPhoto = false;

// Photo File Name to save in SPIFFS
#define FILE_PHOTO "/photo.jpg"

// OV2640 camera module pins (CAMERA_MODEL_AI_THINKER)
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#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

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body { text-align:center; }
    .vert { margin-bottom: 10%; }
    .hori{ margin-bottom: 0%; }
  </style>
</head>
<body>
  <div id="container">
    <h2>ESP32-CAM Last Photo</h2>
    <p>It might take more than 5 seconds to capture a photo.</p>
    <p>
      <button onclick="rotatePhoto();">ROTATE</button>
      <button onclick="capturePhoto()">CAPTURE PHOTO</button>
      <button onclick="location.reload();">REFRESH PAGE</button>
    </p>
  </div>
  <div><img src="https://www.raspberryme.com/esp32-cam-take-photo-display-web-server/saved-photo" id="photo" width="70%"></div>
</body>
<script>
  var deg = 0;
  function capturePhoto() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/capture", true);
    xhr.send();
  }
  function rotatePhoto() {
    var img = document.getElementById("photo");
    deg += 90;
    if(isOdd(deg/90)){ document.getElementById("container").className = "vert"; }
    else{ document.getElementById("container").className = "hori"; }
    img.style.transform = "rotate(" + deg + "deg)";
  }
  function isOdd(n) { return Math.abs(n % 2) == 1; }
</script>
</html>)rawliteral";

void setup() {
  // Serial port for debugging purposes
  Serial.begin(115200);

  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  if (!SPIFFS.begin(true)) {
    Serial.println("An Error has occurred while mounting SPIFFS");
    ESP.restart();
  }
  else {
    delay(500);
    Serial.println("SPIFFS mounted successfully");
  }

  // Print ESP32 Local IP Address
  Serial.print("IP Address: http://");
  Serial.println(WiFi.localIP());

  // Turn-off the 'brownout detector'
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);

  // OV2640 camera module
  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;
  config.pixel_format = PIXFORMAT_JPEG;

  if (psramFound()) {
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    ESP.restart();
  }

  // Route for root / web page
  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send_P(200, "text/html", index_html);
  });

  server.on("/capture", HTTP_GET, [](AsyncWebServerRequest * request) {
    takeNewPhoto = true;
    request->send_P(200, "text/plain", "Taking Photo");
  });

  server.on("/saved-photo", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, FILE_PHOTO, "image/jpg", false);
  });

  // Start server
  server.begin();

}

void loop() {
  if (takeNewPhoto) {
    capturePhotoSaveSpiffs();
    takeNewPhoto = false;
  }
  delay(1);
}

// Check if photo capture was successful
bool checkPhoto( fs::FS &fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}

// Capture Photo and Save it to SPIFFS
void capturePhotoSaveSpiffs( void ) {
  camera_fb_t * fb = NULL; // pointer
  bool ok = 0; // Boolean indicating if the picture has been taken correctly

  do {
    // Take a photo with the camera
    Serial.println("Taking a photo...");

    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

    // Photo file name
    Serial.printf("Picture file name: %sn", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);

    // Insert the data in the photo file
    if (!file) {
      Serial.println("Failed to open file in writing mode");
    }
    else {
      file.write(fb->buf, fb->len); // payload (image), payload length
      Serial.print("The picture has been saved in ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    // Close the file
    file.close();
    esp_camera_fb_return(fb);

    // check if file has been correctly saved in SPIFFS
    ok = checkPhoto(SPIFFS);
  } while ( !ok );
}

Afficher le code brut

Comment fonctionne le code

Tout d’abord, incluez les bibliothèques requises pour travailler avec la caméra, pour créer le serveur Web et pour utiliser SPIFFS.

#include "WiFi.h"
#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "soc/soc.h"           // Disable brownout problems
#include "soc/rtc_cntl_reg.h"  // Disable brownout problems
#include "driver/rtc_io.h"
#include <ESPAsyncWebServer.h>
#include <StringArray.h>
#include <SPIFFS.h>
#include <FS.h>

Ensuite, écrivez vos informations d’identification réseau dans les variables suivantes, afin que l’ESP32-CAM puisse se connecter à votre réseau local.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Créé un AsyncWebServer objet sur le port 80.

AsyncWebServer server(80);

le prendreNouvellePhoto variable booléenne indique quand il est temps de prendre une nouvelle photo.

boolean takeNewPhoto = false;

Ensuite, définissez le chemin et le nom de la photo à enregistrer dans SPIFFS. 

#define FILE_PHOTO "/photo.jpg"

Ensuite, définissez les broches de la caméra pour le module ESP32-CAM AI THINKER.

#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#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

Construire la page Web

Ensuite, nous avons le code HTML pour créer la page Web :

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body { text-align:center; }
    .vert { margin-bottom: 10%; }
    .hori{ margin-bottom: 0%; }
  </style>
</head>
<body>
  <div id="container">
    <h2>ESP32-CAM Last Photo</h2>
    <p>It might take more than 5 seconds to capture a photo.</p>
    <p>
      <button onclick="rotatePhoto();">ROTATE</button>
      <button onclick="capturePhoto()">CAPTURE PHOTO</button>
      <button onclick="location.reload();">REFRESH PAGE</button>
    </p>
  </div>
  <div><img src="https://www.raspberryme.com/esp32-cam-take-photo-display-web-server/saved-photo" id="photo" width="70%"></div>
</body>
<script>
  var deg = 0;
  function capturePhoto() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/capture", true);
    xhr.send();
  }
  function rotatePhoto() {
    var img = document.getElementById("photo");
    deg += 90;
    if(isOdd(deg/90)){ document.getElementById("container").className = "vert"; }
    else{ document.getElementById("container").className = "hori"; }
    img.style.transform = "rotate(" + deg + "deg)";
  }
  function isOdd(n) { return Math.abs(n % 2) == 1; }
</script>
</html>)rawliteral";

Nous n’entrerons pas dans les détails sur le fonctionnement de ce code HTML. Nous allons juste faire un rapide tour d’horizon.

Fondamentalement, créez trois boutons : TOURNER; CAPTURER UNE PHOTO et RAFRAÎCHIR LA PAGE. Chaque photo appelle une fonction JavaScript différente : rotationPhoto(), capturePhoto() et recharger().

<button onclick="rotatePhoto();">ROTATE</button>
<button onclick="capturePhoto()">CAPTURE PHOTO</button>
<button onclick="location.reload();">REFRESH PAGE</button>

le capturePhoto() fonction envoie une requête sur le /Capturer URL vers l’ESP32, il prend donc une nouvelle photo.

function capturePhoto() {
  var xhr = new XMLHttpRequest();
  xhr.open('GET', "/capture", true);
  xhr.send();
}

le rotationPhoto() fonction fait pivoter la photo.

function rotatePhoto() {
  var img = document.getElementById("photo");
  deg += 90;
  if(isOdd(deg/90)){ document.getElementById("container").className = "vert"; }
  else{ document.getElementById("container").className = "hori"; }
  img.style.transform = "rotate(" + deg + "deg)";
}
function isOdd(n) { return Math.abs(n % 2) == 1; }

Nous ne savons pas quelle est la « meilleure » façon de faire pivoter une photo avec JavaScript. Cette méthode fonctionne parfaitement, mais il peut y avoir de meilleures façons de le faire. Si vous avez des suggestions, partagez-les avec nous.

Enfin, la section suivante affiche la photo.

<div><img src="https://www.raspberryme.com/esp32-cam-take-photo-display-web-server/saved-photo" id="photo" width="70%"></div>

Lorsque, vous cliquez sur le RAFRAÎCHIR bouton, il chargera la dernière image.

mettre en place()

Dans le mettre en place(), initialisez une communication série :

Serial.begin(115200);

Connectez l’ESP32-CAM à votre réseau local :

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  delay(1000);
  Serial.println("Connecting to WiFi...");
}

Initialiser SPIFF :

if (!SPIFFS.begin(true)) {
  Serial.println("An Error has occurred while mounting SPIFFS");
  ESP.restart();
}
else {
  delay(500);
  Serial.println("SPIFFS mounted successfully");
}

Imprimez l’adresse IP locale ESP32-CAM :

Serial.print("IP Address: http://");
Serial.println(WiFi.localIP());

Les lignes qui suivent, configurent et initialisent la caméra avec les bons réglages.

Gérer le serveur Web

Ensuite, nous devons gérer ce qui se passe lorsque l’ESP32-CAM reçoit une requête sur une URL.

Lorsque l’ESP32-CAM reçoit une requête sur la root / URL, nous envoyons le texte HTML pour construire la page Web.

server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {
  request->send_P(200, "text/html", index_html);
});

Lorsque nous appuyons sur le « CAPTURER” bouton sur le serveur web, on envoie une requête à l’ESP32 /Capturer URL. Lorsque cela se produit, nous définissons le prendreNouvellePhoto variable à vrai, pour que nous sachions qu’il est temps de prendre une nouvelle photo.

server.on("/capture", HTTP_GET, [](AsyncWebServerRequest * request) {
  takeNewPhoto = true;
  request->send_P(200, "text/plain", "Taking Photo");
});

En cas de demande sur le /photo-enregistrée URL, envoyez la photo enregistrée dans SPIFFS à un client connecté :

server.on("/saved-photo", HTTP_GET, [](AsyncWebServerRequest * request) {
  request->send(SPIFFS, FILE_PHOTO, "image/jpg", false);
});

Enfin, démarrez le serveur Web.

server.begin();

boucler()

Dans le boucler(), si la prendreNouvellePhoto variable est True, nous appelons la capturePhotoSaveSpiffs() pour prendre une nouvelle photo et l’enregistrer dans SPIFFS. Ensuite, réglez le prendreNouvellePhoto variable à faux.

void loop() {
  if (takeNewPhoto) {
    capturePhotoSaveSpiffs();
    takeNewPhoto = false;
  }
  delay(1);
}

Prendre une photo

Il y a deux autres fonctions dans le sketch : checkPhoto() et capturePhotoSaveSpiffs().

le checkPhoto() La fonction vérifie si la photo a été enregistrée avec succès dans SPIFFS.

bool checkPhoto( fs::FS &fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}

le capturePhotoSaveSpiffs() La fonction prend une photo et l’enregistre dans SPIFFS.

void capturePhotoSaveSpiffs( void ) {
  camera_fb_t * fb = NULL; // pointer
  bool ok = 0; // Boolean indicating if the picture has been taken correctly

  do {
    // Take a photo with the camera
    Serial.println("Taking a photo...");

    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

    // Photo file name
    Serial.printf("Picture file name: %sn", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);

    // Insert the data in the photo file
    if (!file) {
      Serial.println("Failed to open file in writing mode");
    }
    else {
      file.write(fb->buf, fb->len); // payload (image), payload length
      Serial.print("The picture has been saved in ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    // Close the file
    file.close();
    esp_camera_fb_return(fb);

    // check if file has been correctly saved in SPIFFS
    ok = checkPhoto(SPIFFS);
  } while ( !ok );
}

Cette fonction était basée sur ce croquis par dualvim.

Code de téléchargement ESP32-CAM

Pour télécharger le code sur le ESP32-CAM carte, connectez-la à votre ordinateur à l’aide d’un Programmeur FTDI. Suivez le diagramme schématique suivant :

Schéma de câblage du programmeur ESP32-CAM FTDI 5V

Important: GPIO 0 doit être connecté à GND pour que vous puissiez télécharger le code.

De nombreux programmeurs FTDI ont un cavalier qui vous permet de sélectionner 3,3 V ou 5 V. Assurez-vous que le cavalier est au bon endroit pour sélectionner 5V.

ESP32-CAM Programmeur FTDI
Terre Terre
5V CCV (5 V)
U0R TX
U0T RX
GPIO 0 Terre

Pour importer le code, procédez comme suit :

1) Aller à Outils > Conseil et sélectionnez Penseur IA ESP32-CAM.

2) Allez à Outils > Port et sélectionnez le port COM auquel l’ESP32 est connecté.

3) Ensuite, cliquez sur le bouton de téléchargement pour télécharger le code.

1642128488 941 ESP32 CAM Prendre des photos et les afficher sur le serveur

4) Lorsque vous commencez à voir ces points sur la fenêtre de débogage comme indiqué ci-dessous, appuyez sur le bouton RST embarqué ESP32-CAM.

1642128488 12 ESP32 CAM Prendre des photos et les afficher sur le serveur

Après quelques secondes, le code devrait être téléchargé avec succès sur votre carte.

Manifestation

Ouvrez votre navigateur et saisissez l’adresse IP ESP32-CAM. Ensuite, cliquez sur le « CAPTURER UNE PHOTO” pour prendre une nouvelle photo et attendre quelques secondes que la photo soit enregistrée dans SPIFFS.

Ensuite, si vous appuyez sur le « RAFRAÎCHIR LA PAGE« , la page sera mise à jour avec la dernière photo enregistrée. Si vous avez besoin d’ajuster l’orientation de l’image, vous pouvez toujours utiliser le « TOURNER” pour le faire.

Le serveur Web ESP32-CAM affiche la démonstration de la dernière photo capturée

Dans votre fenêtre Arduino IDE Serial Monitor, vous devriez voir des messages similaires :

Le serveur Web ESP32-CAM affiche la dernière photo capturée Arduino IDE Serial Monitor

Dépannage

Si vous obtenez l’une des erreurs suivantes, lisez notre Guide de dépannage ESP32-CAM : problèmes les plus courants résolus

  • Échec de la connexion à ESP32 : expiration du délai d’attente de l’en-tête de paquet
  • L’initialisation de la caméra a échoué avec l’erreur 0x20001 ou similaire
  • Détecteur de baisse de tension ou erreur de méditation Guru
  • Sketch too big error – Mauvais schéma de partition sélectionné
  • La carte sur COMX n’est pas disponible – Port COM non sélectionné
  • Erreur Psram : le service GPIO isr n’est pas installé
  • Signal Wi-Fi faible
  • Pas d’adresse IP dans le moniteur série Arduino IDE
  • Impossible d’ouvrir le serveur Web
  • L’image est en retard/montre beaucoup de latence

Conclusion

Nous espérons que vous avez trouvé cet exemple utile. Nous avons essayé de le garder aussi simple que possible afin qu’il soit facile pour vous de le modifier et de l’inclure dans vos propres projets. Vous pouvez combiner cet exemple avec le détecteur de mouvement PIR ESP32-CAM avec capture de photo pour capturer et afficher une nouvelle photo lorsqu’un mouvement est détecté.

Pour plus de projets ESP32-CAM, vous pouvez Abonnez-vous à notre newsletter. Si vous n’avez pas encore d’ESP32-CAM, vous pouvez obtenez-en un pour environ 6 $.

Si vous aimez ce projet, vous aimerez peut-être aussi d’autres projets avec l’ESP32-CAM :

Merci pour la lecture.