Dans ce projet, nous allons fabriquer un détecteur de mouvement avec capture de photos à l’aide d’un ESP32-CAM. Lorsque votre capteur PIR détecte un mouvement, il se réveille, prend une photo et l’enregistre sur la carte microSD.
Ce projet est très similaire au précédent, mais après tant de demandes, nous avons ajouté un capteur de mouvement PIR au circuit. Ainsi, lorsqu’un mouvement est détecté, une photo est prise et enregistrée sur la carte microSD.
Autres projets et tutoriels ESP32-CAM :
Nous avons un projet similaire utilisant un Raspberry Pi et un module caméra :
Regardez le didacticiel vidéo
Vous pouvez regarder le didacticiel vidéo ou continuer à lire pour les instructions complètes du projet.
Pièces requises
Pour ce projet, vous aurez besoin des pièces suivantes :
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 avec réveil externe activé.
- Lorsqu’un mouvement est détecté, le capteur de mouvement PIR envoie un signal pour réveiller l’ESP32.
- L’ESP32-CAM prend une photo et l’enregistre sur la carte microSD.
- Il revient en mode veille profonde jusqu’à ce qu’un nouveau signal du capteur de mouvement PIR soit reçu.
Lecture recommandée: ESP32 Deep Sleep avec Arduino IDE et sources de réveil
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. Donc, vous avez besoin de l’IDE Arduino installé ainsi que du module complémentaire ESP32 :
ESP32-CAM Prendre une photo avec PIR Sketch
Copiez le code suivant dans votre IDE Arduino.
/*********
Rui Santos
Complete project details at https://Raspberryme.com/esp32-cam-pir-motion-detector-photo-capture/
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
RTC_DATA_ATTR int bootCount = 0;
// 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);
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;
pinMode(4, INPUT);
digitalWrite(4, LOW);
rtc_gpio_hold_dis(GPIO_NUM_4);
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");
delay(500);
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);
delay(1000);
// 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);
esp_sleep_enable_ext0_wakeup(GPIO_NUM_13, 0);
Serial.println("Going to sleep now");
delay(1000);
esp_deep_sleep_start();
Serial.println("This will never be printed");
}
void loop() {
}
Ce code est très similaire à l’un de nos précédents projets ESP32-CAM, mais il permet un réveil externe sur GPIO 13.
esp_sleep_enable_ext0_wakeup(GPIO_NUM_13,0);Pour en savoir plus sur le code, accédez au projet suivant :
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.
Diagramme schématique
Assemblez toutes les pièces comme indiqué dans le schéma suivant.
Si vous préférez, vous pouvez plutôt suivre le diagramme de Fritzing.
Pour éviter les problèmes lors du téléchargement, nous vous recommandons d’assembler le circuit uniquement après avoir téléchargé le code.
Manifestation
Après avoir téléchargé le code et assemblé le circuit, insérez une carte microSD formatée et mettez votre circuit sous tension – vous pouvez utiliser un chargeur portable, par exemple.
Ensuite, appuyez sur le bouton de réinitialisation (RST) et il devrait commencer à fonctionner. Lorsqu’il détecte un mouvement, il allume le flash, prend une photo et l’enregistre sur la carte microSD.
Expérimentez plusieurs fois avec ce circuit pour vous assurer qu’il fonctionne. Ensuite, insérez la carte microSD dans votre ordinateur pour voir les photos capturées.
Voici un exemple :
Maintenant, vous pouvez terminer ce projet comme vous le souhaitez, vous pouvez soit utiliser un caméra factice et insérez votre ESP32-CAM avec le capteur de mouvement PIR, ou vous pouvez construire votre propre boîtier.
Vous pouvez également appliquer les concepts appris dans ce didacticiel dans vos propres projets.
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 aimé ce projet. 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 $.
S’il y a un projet que vous aimeriez voir avec l’ESP32-CAM ou si vous souhaitez partager votre projet avec nous, écrivez un commentaire dans la section des commentaires ci-dessous.
Nous avons d’autres projets et tutoriels sur l’ESP32-CAM qui pourraient vous plaire :
Merci pour la lecture.