ESP32-CAM Prendre une photo et l'enregistrer sur une carte MicroSD avec la date et l'heure (horodatage)

Dans ce didacticiel, vous apprendrez à prendre une photo avec l’ESP32-CAM et à l’enregistrer sur la carte microSD. Nous inclurons la date et l’heure actuelles dans le nom du fichier. Inclure la date et l’heure sur le nom de fichier est utile car chaque image aura un nom de fichier unique, ce qui signifie qu’il n’y a aucun problème avec l’écrasement des fichiers existants ; vous saurez quand chaque photo a été prise ; et il sera plus facile d’organiser ou de récupérer vos fichiers plus tard.

ESP32-CAM Prenez une photo et enregistrez-la sur une carte MicroSD avec horodatage de la date et de l'heure

Nouveau sur l’ESP32-CAM ? Consultez notre eBook : Build ESP32-CAM Projects.

Conditions préalables

Avant de continuer avec ce guide, vérifiez les prérequis suivants.

ESP32-CAM

Pour ce projet, nous utiliserons une carte ESP32-CAM AI-Thinker.

Si vous n’êtes pas familier avec l’ESP32-CAM, vous pouvez suivre les tutoriels suivants :

Vous pouvez également utiliser une autre carte caméra ESP32, il vous suffit de vous assurer qu’elle prend en charge une carte microSD et que vous ajustez le bon brochage sur le code. Ceci est uniquement compatible avec les caméras OV2640.

EDI Arduino

Nous allons programmer la carte ESP32 à l’aide de l’IDE Arduino. Vous avez donc besoin de l’IDE Arduino installé ainsi que du module complémentaire ESP32. Vous pouvez suivre le tutoriel suivant pour installer le module complémentaire ESP32, si vous ne l’avez pas déjà fait :

Carte Micro SD

Nous enregistrerons les photos prises avec l’ESP32-CAM sur la carte microSD. Votre carte microSD doit être formatée en FAT32.

Pour vous familiariser avec la gestion des fichiers avec la carte microSD et l’ESP32, vous pouvez jeter un œil au tutoriel suivant :

Obtenir la date et l’heure avec l’ESP32 (fuseau horaire précis et heure d’été)

Nous utiliserons la date et l’heure actuelles sur les noms de fichiers des images. Nous avons un tutoriel détaillé expliquant comment définir le fuseau horaire et l’heure d’été lors de l’obtention de l’heure d’un serveur NTP à l’aide de l’ESP32 :

Aperçu du projet

Le diagramme suivant montre une vue d’ensemble de haut niveau de l’exemple que nous allons créer.

ESP32-CAM Prendre une photo et enregistrer sur une carte MicroSD avec vue d'ensemble du projet de date et d'heure

Dans ce didacticiel, nous allons vous montrer un exemple simple qui effectue les opérations suivantes :

L’ESP32-CAM se connecte à votre routeur via Wi-Fi (cela est nécessaire pour que nous puissions obtenir l’heure d’un serveur NTP);
L’ESP32 se connecte à un serveur NTP pour initialiser la date et l’heure avec le fuseau horaire correct ;
Il initialise la caméra et la carte microSD ;
L’appareil photo prend une nouvelle photo ;
Il obtient la date et l’heure actuelles du serveur NTP ;
La photo est enregistrée sur la carte microSD – son nom de fichier contient la date et l’heure
il a été pris (c’est un nom de fichier unique);
Répétez les étapes 4 à 6 toutes les 10 secondes. À des fins de démonstration, l’ESP32-CAM effectuera cette tâche encore et encore sur la boucle(). L’idée est d’appliquer les concepts que vous apprendrez avec cet exemple à vos propres projets.

L’utilisation de la date et de l’heure sur le nom de fichier de l’image présente plusieurs avantages :

toutes les images auront un nom de fichier différent – vous n’aurez aucun problème à écraser les fichiers précédents lors de la réinitialisation de l’ESP32 ;
vous saurez quand chaque photo a été prise ;
il sera plus facile d’organiser vos photos plus tard.

Pièces requises

Pour suivre ce didacticiel, vous avez besoin d’un module de caméra ESP32 prenant en charge une carte microSD, la carte microSD elle-même et du matériel pour télécharger le code sur la carte (il peut s’agir du programmeur ESP32-CAM MB ou d’un programmeur FTDI).

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 !

Code

Copiez le code suivant dans votre IDE Arduino. Avant de télécharger le code sur votre carte, vous devez insérer votre SSID et votre mot de passe, ainsi que la chaîne de fuseau horaire pour définir le fuseau horaire correct pour votre emplacement (en savoir plus sur la définition de la chaîne de fuseau horaire ci-dessous).

/*********
  Rui Santos
  Complete instructions at https://Raspberryme.com/esp32-cam-photo-microsd-card-timestamp
  
  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_camera.h"
#include "FS.h"                // SD Card ESP32
#include "SD_MMC.h"            // SD Card ESP32
#include "soc/soc.h"           // Disable brownout problems
#include "soc/rtc_cntl_reg.h"  // Disable brownout problems
#include "driver/rtc_io.h"
#include <WiFi.h>
#include "time.h"

// REPLACE WITH YOUR NETWORK CREDENTIALS
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// REPLACE WITH YOUR TIMEZONE STRING: https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
String myTimezone ="WET0WEST,M3.5.0/1,M10.5.0";

// Pin definition for CAMERA_MODEL_AI_THINKER
// Change pin definition if you're using another ESP32 camera module
#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

// Stores the camera configuration parameters
camera_config_t config;

// Initializes the camera
void configInitCamera(){
  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; //YUV422,GRAYSCALE,RGB565,JPEG
  config.grab_mode = CAMERA_GRAB_LATEST;

  // Select lower framesize if the camera doesn't support PSRAM
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10; //0-63 lower number means higher quality
    config.fb_count = 1;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  
  // Initialize the Camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
}

// Connect to wifi
void  initWiFi(){
  WiFi.begin(ssid, password);
  Serial.println("Connecting Wifi");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
}

// Function to set timezone
void setTimezone(String timezone){
  Serial.printf("  Setting Timezone to %s\n",timezone.c_str());
  setenv("TZ",timezone.c_str(),1);  //  Now adjust the TZ.  Clock settings are adjusted to show the new local time
  tzset();
}

// Connect to NTP server and adjust timezone
void initTime(String timezone){
  struct tm timeinfo;
  Serial.println("Setting up time");
  configTime(0, 0, "pool.ntp.org");    // First connect to NTP server, with 0 TZ offset
  if(!getLocalTime(&timeinfo)){
    Serial.println(" Failed to obtain time");
    return;
  }
  Serial.println("Got the time from NTP");
  // Now we can set the real timezone
  setTimezone(timezone);
}

// Get the picture filename based on the current ime
String getPictureFilename(){
  struct tm timeinfo;
  if(!getLocalTime(&timeinfo)){
    Serial.println("Failed to obtain time");
    return "";
  }
  char timeString[20];
  strftime(timeString, sizeof(timeString), "%Y-%m-%d_%H-%M-%S", &timeinfo);
  Serial.println(timeString);
  String filename = "/picture_" + String(timeString) +".jpg";
  return filename; 
}

// Initialize the micro SD card
void initMicroSDCard(){
  // Start Micro SD card
  Serial.println("Starting SD Card");
  if(!SD_MMC.begin()){
    Serial.println("SD Card Mount Failed");
    return;
  }
  uint8_t cardType = SD_MMC.cardType();
  if(cardType == CARD_NONE){
    Serial.println("No SD Card attached");
    return;
  }
}

// Take photo and save to microSD card
void takeSavePhoto(){
  // Take Picture with Camera
  camera_fb_t * fb = esp_camera_fb_get();
 
  //Uncomment the following lines if you're getting old pictures
  //esp_camera_fb_return(fb); // dispose the buffered image
  //fb = NULL; // reset to capture errors
  //fb = esp_camera_fb_get();
  
  if(!fb) {
    Serial.println("Camera capture failed");
    delay(1000);
    ESP.restart();
  }

  // Path where new picture will be saved in SD Card
  String path = getPictureFilename();
  Serial.printf("Picture file name: %s\n", path.c_str());
  
  // Save picture to microSD card
  fs::FS &fs = SD_MMC; 
  File file = fs.open(path.c_str(),FILE_WRITE);
  if(!file){
    Serial.printf("Failed to open file in writing mode");
  } 
  else {
    file.write(fb->buf, fb->len); // payload (image), payload length
    Serial.printf("Saved: %s\n", path.c_str());
  }
  file.close();
  esp_camera_fb_return(fb); 
}

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // disable brownout detector

  Serial.begin(115200);
  delay(2000);

  // Initialize Wi-Fi
  initWiFi();
  // Initialize time with timezone
  initTime(myTimezone);    
  // Initialize the camera  
  Serial.print("Initializing the camera module...");
  configInitCamera();
  Serial.println("Ok!");
  // Initialize MicroSD
  Serial.print("Initializing the MicroSD card module... ");
  initMicroSDCard();
}

void loop() {    
  // Take and Save Photo
  takeSavePhoto();
  delay(10000);
}

Afficher le code brut

Comment fonctionne le code

Continuez à lire pour savoir comment le code fonctionne, ou passez à la Manifestation section.

Inclure les bibliothèques

Tout d’abord, incluez les bibliothèques requises pour gérer la caméra, la carte microSD et l’heure.

#include "esp_camera.h"
#include "FS.h"                // SD Card ESP32
#include "SD_MMC.h"            // SD Card ESP32
#include "soc/soc.h"           // Disable brownout problems
#include "soc/rtc_cntl_reg.h"  // Disable brownout problems
#include "driver/rtc_io.h"
#include <WiFi.h>
#include "time.h"

Informations d’identification réseau

Insérez vos identifiants réseau dans les variables suivantes.

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

Chaîne de fuseau horaire

Insérez votre chaîne de fuseau horaire dans la variable myTimezone. Vous pouvez vérifier un liste des variables de chaîne de fuseau horaire ici. Par exemple, je vis à Porto. Le fuseau horaire est Europe/Lisbonne. Dans la liste des variables de chaîne de fuseau horaire, je vois que la variable de chaîne de fuseau horaire pour mon emplacement est WET0WEST,M3.5.0/1,M10.5.0

//REPLACE WITH YOUR TIMEZONE STRING: https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
String myTimezone ="WET0WEST,M3.5.0/1,M10.5.0";

Brochage et configurations de la caméra

Ensuite, incluez la définition de broche pour le modèle de caméra que nous utilisons. Pour le module ESP32‑CAM AI-Thinker, voici la définition de la broche (modifiez-la si vous utilisez un autre modèle de caméra ESP32) :

// Pin definition for CAMERA_MODEL_AI_THINKER
// Change pin definition if you're using another ESP32 camera module
#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

Vous pouvez trouver la définition des broches pour plusieurs cartes de caméra ESP32 différentes ici : Cartes de caméra ESP32-CAM : Guide d’affectation des broches et des GPIO.

La ligne suivante est nécessaire pour enregistrer les configurations de la caméra. Nous ajouterons la définition de la broche et les paramètres de l’image plus tard dans le code.

// Stores the camera configuration parameters
camera_config_t config;

Configurer et initialiser la caméra

La fonction configInitCamera() commence par affecter les GPIO que vous avez définis précédemment ainsi que le format d’image.

// Initializes the camera
void configInitCamera(){
  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; //YUV422,GRAYSCALE,RGB565,JPEG
  config.grab_mode = CAMERA_GRAB_LATEST;

Le format de l’image est défini dans la ligne suivante

config.pixel_format = PIXFORMAT_JPEG; //YUV422,GRAYSCALE,RGB565,JPEG

Il peut être défini sur l’un des formats suivants :

PIXFORMAT_JPEG
PIXFORMAT_YUV422
PIXFORMAT_GRAYSCALE
PIXFORMAT_RGB565
PIXFORMAT_JPEG (format que nous utilisons)

Définissez la taille du cadre, la qualité de l’image et le nombre d’images enregistrées dans la mémoire tampon :

  // Select lower framesize if the camera doesn't support PSRAM
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10; //0-63 lower number means higher quality
    config.fb_count = 1;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }

Si le modèle de caméra prend en charge la PSRAM, nous définissons la taille d’image sur UXGA (1600 × 1200) et la qualité d’image sur 1.

Vous pouvez définir la taille du cadre sur l’une de ces options :

TAILLE D’IMAGE_UXGA (1600 x 1200)
TAILLE D’IMAGE_QVGA (320 x 240)
TAILLE D’IMAGE_CIF (352 x 288)
TAILLE D’IMAGE_VGA (640 x 480)
TAILLE D’IMAGE_SVGA (800 x 600)
TAILLE D’IMAGE_XGA (1024 x 768)
FRAMESIZE_SXGA (1280 x 1024)

La qualité de l’image peut être un nombre compris entre 0 et 63. Un nombre inférieur signifie une qualité supérieure.

Important : des nombres très faibles pour la qualité d’image, en particulier à une résolution plus élevée, peuvent faire planter l’ESP32-CAM ou il peut ne pas être en mesure de prendre les photos correctement. Donc, si vous remarquez que les images prises avec l’ESP32-CAM sont coupées en deux ou avec des couleurs étranges, c’est probablement un signe que vous devez baisser la qualité (sélectionnez un nombre plus élevé comme 10).

Les lignes suivantes initialisent la caméra avec les configurations que vous avez configurées précédemment. Si la caméra ne s’initialise pas correctement, cela renverra un message d’erreur.

  // Initialize the Camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }

Initialiser le Wi-Fi

La fonction initWiFi() connecte votre carte à votre réseau local en utilisant les informations d’identification que vous avez configurées précédemment.

// Connect to wifi
void  initWiFi(){
  WiFi.begin(ssid, password);
  Serial.println("Connecting Wifi");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
}

Initialiser l’heure et définir le fuseau horaire

La fonction setTimezone() définira la variable d’environnement TZ avec le fuseau horaire correct. call setenv(« TZ », fuseau horaire, 1), où fuseau horaire est l’un des fuseaux horaires listés ici. Ensuite, appelez tzset() pour mettre à jour ce fuseau horaire. Vous devriez déjà avoir défini votre fuseau horaire plus tôt dans le code (variable myTimezone).

// Function to set timezone
void setTimezone(String timezone){
  Serial.printf("  Setting Timezone to %s\n",timezone.c_str());
  setenv("TZ",timezone.c_str(),1);  //  Now adjust the TZ.  Clock settings are adjusted to show the new local time
  tzset();
}

La fonction initTime() connecte l’ESP32-CAM au serveur NTP et définit le fuseau horaire correct.

// Connect to NTP server and adjust timezone
void initTime(String timezone){
  struct tm timeinfo;
  Serial.println("Setting up time");
  configTime(0, 0, "pool.ntp.org");    // First connect to NTP server, with 0 TZ offset
  if(!getLocalTime(&timeinfo)){
    Serial.println(" Failed to obtain time");
    return;
  }
  Serial.println("Got the time from NTP");
  // Now we can set the real timezone
  setTimezone(timezone);
}

Obtenir l’heure actuelle et le nom du fichier image

Le but de ce didacticiel est d’enregistrer des images sur la carte microSD qui incluent la date et l’heure dans le nom de fichier de l’image. Le nom du fichier sera au format suivant :

picture_YYYY-MM-DD_HH-MM-SS.jpg

La fonction getPictureFilename() obtient la date et l’heure actuelles et génère une chaîne qui peut être utilisée comme nom pour le nom du fichier image.

String getPictureFilename(){

Tout d’abord, nous obtenons la date et l’heure :

struct tm timeinfo;
if(!getLocalTime(&timeinfo)){
  Serial.println("Failed to obtain time");
  return "";
}

Ensuite, nous convertissons la variable timeinfo en une chaîne au format suivant Ym-d_H-MS et imprimons le résultat :

strftime(timeString, sizeof(timeString), "%Y-%m-%d_%H-%M-%S", &timeinfo);
Serial.println(timeString);

Après avoir la date et l’heure dans un format String, nous pouvons le concaténer avec « image » et « .jpg », qui est le format de l’image.

String filename = "/picture_" + String(timeString) +".jpg";

Enfin, nous renvoyons le nom du fichier :

return filename;

Initialiser la carte microSD

La fonction initMicroSDCard() initialise la carte microSD. Il renvoie un message d’erreur en cas d’échec de l’initialisation.

// Start Micro SD card
Serial.println("Starting SD Card");
if(!SD_MMC.begin()){
  Serial.println("SD Card Mount Failed");
  return;
}

Les lignes suivantes renvoient une erreur au cas où aucune carte microSD n’est connectée.

uint8_t cardType = SD_MMC.cardType();
if(cardType == CARD_NONE){
  Serial.println("No SD Card attached");
  return;
}

Prendre et enregistrer une photo

Pour prendre et enregistrer une photo, nous avons créé la fonction takeSavePhoto().

Tout d’abord, il commence par prendre une photo à l’aide de la fonction esp_camera_fb_get().

camera_fb_t * fb = esp_camera_fb_get();

Cette ligne précédente crée un frame buffer fb qui contient l’image.

Si vous obtenez de vieilles images lorsque vous prenez une photo, cela peut signifier que le tampon d’image enregistre plusieurs images. Pour éviter cela, vous pouvez décommenter les lignes suivantes dans le code :

//esp_camera_fb_return(fb); // dispose the buffered image
//fb = NULL; // reset to capture errors
//fb = esp_camera_fb_get();

En cas d’échec de la capture, nous imprimons un message d’erreur et redémarrons la carte (le redémarrage de la carte est facultatif, vous pouvez gérer l’erreur différemment si vous préférez, comme essayer de prendre une autre photo).

if(!fb) {
  Serial.println("Camera capture failed");
  delay(1000);
  ESP.restart();
}

Après avoir pris la photo, nous appellerons la fonction getPictureFilename() pour obtenir un nom de fichier pour la photo avec l’horodatage actuel.

  // Path where new picture will be saved in SD Card
  String path = getPictureFilename();
  Serial.printf("Picture file name: %s\n", path.c_str());

Maintenant que nous avons l’image (frame buffer fb) et le nom du fichier image, nous pouvons l’enregistrer sur la carte micro SD.

Ouvrez la carte microSD en mode écriture et créez un fichier avec le nom de fichier que nous avons défini précédemment (c’est sur la variable path) :

fs::FS &fs = SD_MMC; 
File file = fs.open(path.c_str(),FILE_WRITE);

Si nous ne sommes pas en mesure d’ouvrir le fichier (en raison d’une erreur sur la carte microSD ou lors de la création du fichier), nous imprimons un message d’erreur.

if(!file){
  Serial.printf("Failed to open file in writing mode");
}

Enregistrez l’image en passant comme arguments le frame buffer et sa longueur à la méthode write().

 file.write(fb->buf, fb->len); // payload (image), payload length

Après cela, fermez le fichier :

file.close();

Enfin, appelez esp_camera_fb_return(fb) pour effacer le tampon fb, afin qu’il soit disponible pour l’utilisation de l’image suivante.

esp_camera_fb_return(fb);

installation()

Dans setup(), initialisez le moniteur série, initialisez le Wi-Fi, définissez le fuseau horaire, configurez et initialisez la caméra et initialisez la carte microSD.

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

  Serial.begin(115200);
  delay(2000);

  // Initialize Wi-Fi
  initWiFi();
  // Initialize time with timezone
  initTime(myTimezone);    
  // Initialize the camera  
  Serial.print("Initializing the camera module...");
  configInitCamera();
  Serial.println("Ok!");
  // Initialize MicroSD
  Serial.print("Initializing the MicroSD card module... ");
  initMicroSDCard();
}

boucle()

Dans la boucle(), appelez la fonction takeSavePhoto() pour prendre une photo et l’enregistrer sur la carte microSD. Le nom de l’image inclura déjà l’horodatage actuel.

void loop() {    
  // Take and Save Photo
  takeSavePhoto();
  delay(10000);
}

Cette fonction est appelée encore et encore dans la boucle() toutes les 10 secondes.

Nous le faisons à des fins de démonstration. Maintenant, vous devriez pouvoir utiliser la fonction takeSavePhoto() dans vos propres projets pour prendre des photos avec un nom de fichier unique.

Manifestation

Après avoir inséré vos informations d’identification réseau et votre chaîne de fuseau horaire, téléchargez le code sur votre carte.

Si vous avez un ESP32-CAM AI-Thinker, vous devez sélectionner AI Thinker ESP32-CAM dans le menu Outils> Carte.

Sélection de l'ESP32-CAM Ai Thinker dans l'IDE Arduino

Après cela, sélectionnez le port COM dans Outils > Port.

Enfin, téléchargez le code.

Si vous rencontrez des problèmes pour télécharger le code, consultez notre guide de dépannage : Guide de dépannage ESP32-CAM : Problèmes les plus courants résolus.

Après avoir téléchargé avec succès le code sur la carte, ouvrez le moniteur série à un débit en bauds de 115200. Appuyez sur le bouton RST pour qu’il redémarre la carte et qu’elle commence à exécuter le code.

N’oubliez pas d’insérer une carte microSD dans la fente pour carte microSD ESP32-CAM.

Toutes les 10 secondes, le flash se déclenchera et enregistrera une image sur la carte microSD. Laissez le code s’exécuter pendant un certain temps afin d’obtenir une quantité considérable d’images.

Dans le moniteur série, vous devriez obtenir quelque chose comme indiqué ci-dessous.

ESP32-CMA Prendre des photos avec la démonstration du moniteur série d'horodatage

Ensuite, insérez la carte microSD dans votre ordinateur pour voir les photos capturées.

Dossier d'images ESP32-CAM sur carte microSD

Les photos doivent avoir la date et l’heure dans son nom. Par exemple:

picture_2023-01-17_17-31-40.jpg

Cela signifie que cette photo a été prise le :

Année : 2023
Mois : 01 (janvier)
Jour : 17
Heure : 17:31:40 (17:31:40)

Conclusion

Dans ce projet, vous avez appris à demander la date et l’heure (avec le bon fuseau horaire et l’heure d’été) à partir d’Internet à l’aide de l’ESP32-CAM et à utiliser ces informations pour nommer vos photos. De cette façon, vous savez à quelle heure et à quelle date une certaine photo a été prise, et vous n’avez pas à vous soucier d’écraser des photos sur la carte microSD.

Pour un tutoriel détaillé sur l’obtention de la date et de l’heure avec l’ESP32 et la définition du fuseau horaire, nous vous recommandons le tutoriel suivant :

Pour en savoir plus sur l’ESP32-CAM et construire plus de projets, nous jetons un coup d’œil à notre eBook :

Nous espérons que vous avez trouvé ce tutoriel intéressant.

Merci d’avoir lu.

Revivez l’histoire de Raspberry Pi dans cette vidéo :