Apprenez à prendre des photos avec la carte ESP32-CAM et à les enregistrer sur une carte microSD à l’aide d’Arduino IDE. Lorsque vous appuyez sur le bouton ESP32-CAM RESET, il se réveille, prend une photo et l’enregistre sur la carte microSD.
Nous utiliserons la carte ESP32-CAM étiquetée comme module AI-Thinker, mais d’autres modules devraient également fonctionner en affectant correctement les broches dans le code.
le Carte ESP32-CAM est un appareil à 9 $ (ou moins) qui combine une puce ESP32-S, une caméra OV2640, un emplacement pour carte microSD et plusieurs broches GPIO.
Pour une introduction à l’ESP32-CAM, vous pouvez suivre les tutoriels suivants :
Regardez le didacticiel vidéo
Pour apprendre à prendre des photos avec l’ESP32-CAM et les enregistrer sur la carte microSD, vous pouvez regarder le didacticiel vidéo suivant ou continuer à lire cette page pour les instructions écrites et toutes les ressources.
Pièces requises
Pour suivre ce tutoriel, vous avez besoin des composants suivants :
Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !
Aperçu du projet
Voici un bref aperçu du fonctionnement du projet.
- L’ESP32-CAM est en mode veille profonde
- Appuyez sur le bouton RESET pour réveiller la carte
- L’appareil photo prend une photo
- La photo est enregistrée sur la carte microSD sous le nom : pictureX.jpg, où X correspond au numéro de la photo
- Le numéro de la photo sera enregistré dans la mémoire flash de l’ESP32 afin qu’il ne soit pas effacé lors du RESET et que nous puissions garder une trace du nombre de photos prises.
Formatage de la carte MicroSD
La première chose que nous vous recommandons de faire est de formater votre carte microSD. Vous pouvez utiliser l’outil de formatage Windows ou tout autre logiciel de formatage microSD.
1. Insérez la carte microSD dans votre ordinateur. Aller à Mon ordinateur et faites un clic droit sur la carte SD. Sélectionner Format comme le montre la figure ci-dessous.
2. Une nouvelle fenêtre apparaît. Sélectionner FAT32, presse Démarrer pour initialiser le processus de formatage et suivez les instructions à l’écran.
Noter: selon les spécifications du produit, l’ESP32-CAM ne doit prendre en charge que les cartes SD de 4 Go. Cependant, nous avons testé avec une carte SD de 16 Go et cela fonctionne bien.
Installation du module complémentaire ESP32
Nous allons programmer la carte ESP32 en utilisant Arduino IDE. Vous avez donc besoin de l’IDE Arduino installé ainsi que du module complémentaire ESP32. Vous pouvez suivre l’un des prochains tutoriels pour installer le module complémentaire ESP32, si ce n’est déjà fait :
Prendre et enregistrer un croquis photo
Copiez le code suivant dans votre IDE Arduino.
/*********
Rui Santos
Complete project details at https://Raspberryme.com/esp32-cam-take-photo-save-microsd-card
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
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 "Arduino.h"
#include "FS.h" // SD Card ESP32
#include "SD_MMC.h" // SD Card ESP32
#include "soc/soc.h" // Disable brownour problems
#include "soc/rtc_cntl_reg.h" // Disable brownour problems
#include "driver/rtc_io.h"
#include <EEPROM.h> // read and write from flash memory
// define the number of bytes you want to access
#define EEPROM_SIZE 1
// Pin definition for 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
int pictureNumber = 0;
void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
Serial.begin(115200);
//Serial.setDebugOutput(true);
//Serial.println();
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; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
config.jpeg_quality = 10;
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}
// Init Camera
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}
//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;
}
camera_fb_t * fb = NULL;
// Take Picture with Camera
fb = esp_camera_fb_get();
if(!fb) {
Serial.println("Camera capture failed");
return;
}
// initialize EEPROM with predefined size
EEPROM.begin(EEPROM_SIZE);
pictureNumber = EEPROM.read(0) + 1;
// Path where new picture will be saved in SD Card
String path = "/picture" + String(pictureNumber) +".jpg";
fs::FS &fs = SD_MMC;
Serial.printf("Picture file name: %sn", path.c_str());
File file = fs.open(path.c_str(), FILE_WRITE);
if(!file){
Serial.println("Failed to open file in writing mode");
}
else {
file.write(fb->buf, fb->len); // payload (image), payload length
Serial.printf("Saved file to path: %sn", path.c_str());
EEPROM.write(0, pictureNumber);
EEPROM.commit();
}
file.close();
esp_camera_fb_return(fb);
// Turns off the ESP32-CAM white on-board LED (flash) connected to GPIO 4
pinMode(4, OUTPUT);
digitalWrite(4, LOW);
rtc_gpio_hold_en(GPIO_NUM_4);
delay(2000);
Serial.println("Going to sleep now");
delay(2000);
esp_deep_sleep_start();
Serial.println("This will never be printed");
}
void loop() {
}
Le code commence par inclure les bibliothèques nécessaires pour utiliser l’appareil photo. Nous incluons également les bibliothèques nécessaires pour interagir avec la carte microSD :
#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h" // SD Card ESP32
#include "SD_MMC.h" // SD Card ESP32
#include "soc/soc.h" // Disable brownour problems
#include "soc/rtc_cntl_reg.h" // Disable brownour problems
#include "driver/rtc_io.h"
#include <EEPROM.h> // read and write from flash memoryEt le EEPROM bibliothèque pour enregistrer les données permanentes dans la mémoire flash.
#include <EEPROM.h>Si vous souhaitez en savoir plus sur la façon de lire et d’écrire des données dans la mémoire flash, vous pouvez suivre le tutoriel suivant :
Définissez le nombre d’octets auxquels vous souhaitez accéder dans la mémoire flash. Ici, nous n’utiliserons qu’un octet qui nous permet de générer jusqu’à 256 numéros d’image.
#define EEPROM_SIZE 1Ensuite, définissez les broches du module de caméra AI-THINKER.
// Pin definition for 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 22Noter: vous devrez peut-être modifier la définition des broches en fonction de la carte que vous utilisez. Une mauvaise affectation des broches entraînera un échec de l’initialisation de la caméra.
Initialiser une variable int appelée imageNuméro celui qui va générer le nom de la photo : picture1.jpg, picture2.jpg, et ainsi de suite.
int pictureNumber = 0;Tout notre code est dans le mettre en place(). Le code ne s’exécute qu’une seule fois lorsque l’ESP32 se réveille (dans ce cas lorsque vous appuyez sur le bouton RESET intégré).
Définissez les paramètres de la caméra :
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; Utilisez les paramètres suivants pour une caméra avec PSRAM (comme celui que nous utilisons dans ce didacticiel).
if(psramFound()){
config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
config.jpeg_quality = 10;
config.fb_count = 2;
}Si la carte n’a pas de PSRAM, définissez les paramètres suivants :
else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}Initialisez la caméra :
// Init Camera
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}Initialisez la carte microSD :
//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;
}Vous trouverez plus d’informations sur l’utilisation de la carte microSD dans le projet suivant :
Les lignes suivantes prennent une photo avec l’appareil photo :
camera_fb_t * fb = NULL;
// Take Picture with Camera
fb = esp_camera_fb_get();
if(!fb) {
Serial.println("Camera capture failed");
return;
}Après cela, initialisez l’EEPROM avec la taille définie précédemment :
EEPROM.begin(EEPROM_SIZE);Le numéro de l’image est généré en ajoutant 1 au numéro actuel enregistré dans la mémoire flash.
pictureNumber = EEPROM.read(0) + 1;Pour enregistrer la photo sur la carte microSD, créez un chemin vers votre fichier. Nous allons enregistrer la photo dans le répertoire principal de la carte microSD et le nom du fichier sera (picture1.jpg, picture2.jpg, picture3.jpg, etc…).
String path = "/picture" + String(pictureNumber) +".jpg";Les lignes suivantes enregistrent la photo sur la carte microSD :
fs::FS &fs = SD_MMC;
Serial.printf("Picture file name: %sn", path.c_str());
File file = fs.open(path.c_str(), FILE_WRITE);
if(!file){
Serial.println("Failed to open file in writing mode");
}
else {
file.write(fb->buf, fb->len); // payload (image), payload length
Serial.printf("Saved file to path: %sn", path.c_str());
EEPROM.write(0, pictureNumber);
EEPROM.commit();
}
file.close();Après avoir enregistré une photo, nous enregistrons le numéro de la photo actuelle dans la mémoire flash pour garder une trace du nombre de photos prises.
EEPROM.write(0, pictureNumber);
EEPROM.commit();Lorsque l’ESP32-CAM prend une photo, la LED intégrée fait clignoter. Après avoir pris la photo, la LED reste allumée, nous envoyons donc des instructions pour l’éteindre. La LED est connectée au GPIO 4.
pinMode(4, OUTPUT);
digitalWrite(4, LOW);
rtc_gpio_hold_en(GPIO_NUM_4);Enfin, nous mettons l’ESP32 en sommeil profond.
esp_deep_sleep_start();Parce que nous ne transmettons aucun argument à la fonction de sommeil profond, la carte ESP32 dormira indéfiniment jusqu’à RESET.
Code de téléchargement ESP32-CAM
Pour télécharger le code sur la carte ESP32-CAM, connectez-la à votre ordinateur à l’aide d’un programmeur FTDI. Suivez le schéma suivant :
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.
Important: GPIO 0 doit être connecté à GND afin que vous puissiez télécharger du code.
| ESP32-CAM | Programmeur FTDI |
| GND | GND |
| 5V | VCC (5V) |
| U0R | Émission |
| U0T | Réception |
| GPIO 0 | GND |
Pour télécharger le code, suivez les étapes suivantes :
1) Aller à Outils > Conseil et sélectionnez AI-penseur ESP32-CAM.
2) Aller à 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.
4) Lorsque vous commencez à voir ces points sur la fenêtre de débogage comme indiqué ci-dessous, appuyez sur le bouton RST intégré de l’ESP32-CAM.
Après quelques secondes, le code devrait être téléchargé avec succès sur votre tableau.
Manifestation
Après avoir téléchargé le code, retirez le cavalier qui relie GPIO 0 à GND.
Ouvrez le moniteur série à un débit en bauds de 115 200. Appuyez sur le bouton de réinitialisation ESP32-CAM. Il devrait s’initialiser et prendre une photo. Lorsqu’il prend une photo, il allume le flash (GPIO 4).
Vérifiez la fenêtre Arduino IDE Serial Monitor pour voir si tout fonctionne comme prévu. Comme vous pouvez le voir, l’image a été enregistrée avec succès sur la carte microSD.
Noter: Si vous rencontrez des problèmes avec l’ESP32-CAM, consultez notre guide de dépannage et voyez si cela vous aide : Guide de dépannage ESP32-CAM : problèmes les plus courants résolus
Après vous être assuré que tout fonctionne comme prévu, vous pouvez déconnecter l’ESP32-CAM du programmeur FTDI et l’alimenter à l’aide d’une alimentation indépendante.
Pour voir les photos prises, retirez la carte microSD de la fente pour carte microSD et insérez-la dans votre ordinateur. Vous devriez avoir toutes les photos enregistrées.
La qualité de votre photo dépend de vos conditions d’éclairage. Trop de lumière peut ruiner vos photos et les environnements sombres entraîneront de nombreux pixels noirs.
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 : attente de l’en-tête du paquet dépassée
- 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 du gourou
- Esquisse trop grosse erreur – Mauvais schéma de partition sélectionné
- La carte à 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é ce didacticiel utile et que vous pourrez l’utiliser dans vos projets. Si vous n’avez pas de carte ESP32-CAM, vous pouvez Cliquez ici pour en obtenir un.
Comme mentionné précédemment, nous avons d’autres tutoriels sur l’ESP32-CAM qui pourraient vous plaire :
Merci pour la lecture.