Dans cet article, vous apprendrez à programmer le module ESP32-CAM. Les modules caméra ESP32 sont relativement bon marché et très pratiques pour créer des systèmes simples de surveillance ou de monitoring. Par exemple, prendre automatiquement des photos d’animaux la nuit dans votre jardin ou annoncer les visiteurs à votre porte d’entrée via une webcam sont des cas d’usage courants.
Cependant, téléverser et exécuter des programmes sur les cartes de développement ESP32-CAM courantes est un peu délicat. Dans cet article, nous examinons différentes méthodes pour programmer et dépanner une carte ESP32-CAM.
Pièces requises
Vous trouverez ci-dessous les composants nécessaires pour réaliser le projet. Certains éléments comme le câble USB, la carte micro SD ou le lecteur de carte SD sont peut-être déjà en votre possession. Pas besoin de les acheter alors, aucun de ces éléments n’est spécifique à ce projet.
Si vous ne possédez pas d’adaptateur FTDI USB-TTL, c’est vraiment un accessoire à avoir. Tôt ou tard, vous en aurez besoin si vous continuez à bricoler avec des microcontrôleurs ESP32. Celui listé est simple mais suffira dans la plupart des cas.
ESP32-CAM avec shield USB-TTL
Adaptateur FTDI USB-TTL
Carte MicroSD 4GB
Lecteur de carte SD
Câble USB de données
Arduino IDE
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Bases de la carte de développement ESP32-CAM
La carte de développement ESP32-CAM est un module compact qui combine une puce ESP32-S, une caméra, un flash intégré et un emplacement pour carte microSD. La carte intègre le Wi-Fi et le Bluetooth et supporte une caméra OV2640 ou OV7670 avec une résolution allant jusqu’à 2 mégapixels.
Vous trouverez ci-dessous la spécification détaillée de la carte. Notez que dans le code d’exemple, nous ferons référence au modèle original AI-Thinker de la carte ESP32-CAM, mais il existe de nombreux clones avec les mêmes spécifications ou des spécifications similaires.
Ils sont généralement programmés et utilisés de la même manière. Il y a toutefois une exception. Si votre carte possède un connecteur à 6 rangées de broches (contre seulement 4 rangées), elle peut être programmée plus facilement avec le shield de programmation. Voir la photo ci-dessous pour comparaison :
Il y a aussi une différence au niveau de la broche GND (indiquée par la flèche rouge). Dans la Version 1 (à gauche), cette broche est étiquetée GND/R et sert à réinitialiser la carte. Dans la Version 2 (à droite), cette broche sert de masse (GND).
La Version 2 à droite avec ses 4 broches nécessite que vous appuyiez manuellement sur les boutons BOOT et RST lors du téléversement du code (nous y reviendrons), tandis que la Version 1 le fait automatiquement. Malheureusement, la Version 2 est assez courante et il est plus simple d’utiliser un programmateur FTDI dans ce cas plutôt que le shield de programmation.
Caractéristiques
- Module SoC ultra-compact 802.11b/g/n Wi-Fi + BT/BLE.
- Processeur double cœur 32 bits basse consommation pour applications.
- Fréquence principale jusqu’à 240 MHz, puissance de calcul jusqu’à 600 DMIPS.
- SRAM intégrée de 520 KB, PSRAM externe de 4M.
- Supporte des interfaces telles que UART/SPI/I2C/PWM/ADC/DAC.
- Supporte les caméras OV2640 et OV7670, flash intégré.
- Supporte le transfert d’images via WiFi, supporte carte TF.
- Supporte plusieurs modes de veille.
- Supporte les modes de fonctionnement STA/AP/STA+AP.
Spécifications
- Dimensions : 27*40.5*4.5(±0.2)mm
- Flash SPI : 32Mbit par défaut
- RAM : 520KB interne + 4M PSRAM externe
- BT : normes BT 4.2BR/EDR et BLE
- WiFi : 802.11 b/g/n/e/i
- Interfaces supportées : UART, SPI, I2C, PWM
- Support carte TF : 4G (fonctionne généralement jusqu’à 16GB)
- Ports IO : 9
- Format de sortie image : JPEG (seulement supporté par OV2640), BMP, GRAYSCALE
- Antenne : antenne intégrée, gain 2dBi
- Sécurité : WPA/WPA2/WPAS-Enterprise/WPS
- Alimentation : 5V
- Température de fonctionnement : -20 °C à 85 °C
Consommation électrique
- Sans flash : 180mA@5V
- Avec flash à luminosité maximale : 310mA@5V
- Deep-sleep : 6mA@5V
- Modem-sleep : 20mA@5V
- Light-sleep : 6.7mA@5V
Brochage
L’image suivante montre le brochage de l’ESP32-CAM. Notez qu’en théorie l’ESP32-CAM peut fonctionner sous 3.3V mais des comportements instables et des images avec filigranes ont été signalés. L’alimentation recommandée est donc 5V @ 2A.
Notez aussi que IO0 est connecté à la broche XCLK de la caméra et doit rester flottant (non connecté) lors de l’exécution de l’ESP32. Vous ne devez tirer IO0 vers la masse (GND) que lors du téléversement du code. Nous y reviendrons.
Comparé à une carte ESP32 standard, la carte ESP32-CAM dispose d’un nombre beaucoup plus réduit de broches GPIO disponibles. Cela s’explique par le fait que la plupart des broches GPIO sont utilisées par la caméra et le lecteur de carte SD. De plus, il faut éviter d’utiliser GPIO1, GPIO3 et GPIO0, car ils sont nécessaires à la programmation de la carte. Pour plus d’informations, voir le More GPIO pins for ESP32-CAM tutoriel.
La broche P_OUT est étiquetée VCC sur certaines cartes. C’est une broche de sortie d’alimentation qui fournit 3.3V ou 5V selon un solder pad. Vous ne pouvez pas utiliser cette broche pour alimenter la carte ! Utilisez la broche 5V pour cela.
Faites aussi attention aux broches de masse.Évitez d’utiliser la broche GND à côté de GPIO1 !Sur certaines cartes ESP32-CAM, cette broche est étiquetée GND/R et sert à réinitialiser la carte. Vous ne pouvez pas l’utiliser comme masse. Pour être sûr, utilisez toujours la broche GND proche de GPIO0.
Enfin, les broches GPIO 2, 4, 12, 13, 14 et 15 sont utilisées par le lecteur de carte SD. Si vous n’utilisez pas le lecteur de carte SD, elles sont disponibles comme GPIO. La LED Flash intégrée est connectée à GPIO 4, ce qui fait que la LED Flash s’allume quand le lecteur de carte SD est utilisé. Vous pouvez utiliser le code suivant pour éviter cela :
SD_MMC.begin("/sdcard", true)
Vous trouverez des informations supplémentaires sur le brochage de la carte ESP32-CAM dans ce tutoriel RandomNerd : ESP32-CAM AI-Thinker Pinout Guide: GPIOs Usage Explained.
Schémas
Si vous avez besoin de comprendre en détail le câblage interne de la carte ESP32-CAM, consultez les schémas suivants (source). Cliquez sur l’image pour ouvrir ou download le PDF avec les schémas en pleine résolution.
Installation du Core ESP32
Pour programmer l’ESP32-CAM, vous aurez besoin de l’Arduino IDE avec le support des cartes ESP32 installé. Heureusement, l’installation du Core ESP32 est très simple. Lancez simplement votre Arduino IDE et suivez les étapes ci-dessous. En cas de problème, vous trouverez des instructions plus détaillées dans notre tutoriel How to Program ESP32 with Arduino IDE.
URLs supplémentaires pour le gestionnaire de cartes
Commencez par ouvrir la boîte de dialogue Préférences en sélectionnant « Preferences… » dans le menu « File » :
Cela ouvrira la boîte de dialogue Préférences ci-dessous. Sous l’onglet Settings, vous trouverez un champ de saisie en bas de la fenêtre intitulé « Additional boards manager URLs » :
Dans ce champ, copiez l’URL suivante : « https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json«
Cela permettra à l’Arduino IDE de savoir où trouver les bibliothèques du core ESP32. Ensuite, nous allons installer ces bibliothèques via le Boards Manager.
Gestionnaire de cartes
Ouvrez le BOARDS MANAGER en cliquant sur l’icône de carte dans la barre latérale comme montré ci-dessous :
Le BOARDS MANAGER apparaîtra à droite de la barre latérale. Tapez « ESP32 » dans le champ de recherche en haut et vous devriez voir deux types de cartes ESP32 : les « Arduino ESP32 Boards » et les cartes « esp32 par Espressif ». Nous voulons les bibliothèques esp32 par Espressif. Cliquez sur le bouton INSTALL et attendez la fin du téléchargement et de l’installation.
Une fois installé, votre Boards Manager devrait ressembler à ceci, bien que la version exacte (ici 3.0.0-a) puisse différer.
À l’étape suivante, je vous montre comment sélectionner la carte ESP32 que vous souhaitez programmer.
Sélectionner la carte
Pour sélectionner une carte, allez dans le menu Tools. Cliquez sur Board : « Arduino Uno ». Vous verrez peut-être une carte différente de celle montrée ci-dessous, ce n’est pas un problème. Allez dans le sous-menu et vous devriez voir les « Arduino AVR Boards » et en dessous « esp32 » (comme vous pouvez le voir, j’ai aussi les cartes esp8266 installées). Cliquez sur « esp32 » et vous aurez une longue liste de cartes disponibles.
Trouvez la carte AI Thinker ESP32-CAM dans la liste et cliquez dessus.
Vous êtes maintenant prêt à téléverser et exécuter du code sur la carte ESP32-CAM. Je vais vous montrer deux méthodes différentes. Vous pouvez utiliser un des shields de programmation souvent vendus avec le module ESP32-CAM. Ou vous pouvez utiliser un programmateur FTDI séparé et plus universel. Nous commençons par le shield de programmation.
Téléverser du code avec un shield de programmation
Pour programmer une puce ESP32 directement, vous devez utiliser l’interface UART série. Elle est accessible via les broches U0TXD et U0RXD visibles dans le brochage. Cependant, nous voulons programmer l’ESP32 via le port USB de notre ordinateur (et l’Arduino IDE). Pour cela, nous avons besoin d’un convertisseur USB vers UART.
Shield de programmation
Beaucoup de cartes de développement avec ESP32 ont une puce intégrée (CH340) qui fait cette conversion USB vers UART, mais le module ESP32-CAM n’en possède malheureusement pas. Vous avez donc besoin d’un shield de programmation, comme celui illustré ci-dessous, ou d’un programmateur FTDI, que nous verrons plus tard.
Il suffit d’empiler le module ESP32-CAM sur le shield de programmation comme montré ci-dessous, de connecter un câble USB du shield à votre ordinateur, et vous êtes prêt à programmer.
Connexion du shield de programmation à l’ordinateur
Assurez-vous d’abord que le câble USB est bien connecté et fonctionne. Vous devriez entendre un son de connexion sur votre ordinateur et une LED rouge sur le shield devrait s’allumer lorsque vous branchez le câble USB. Ensuite, assurez-vous d’avoir sélectionné la carte AI Thinker ESP32-CAM et le port série approprié. Voir l’image ci-dessous.
Le port série que vous voyez sera probablement différent. Cela dépend de votre ordinateur et du port USB utilisé pour connecter l’ESP32-CAM.
Mode programmation
Pour téléverser un programme sur l’ESP32-CAM, vous devez faire ce qui suit :
Démarrez le téléversement via le bouton upload dans l’Arduino IDE :
Sur le shield de programmation, appuyez et maintenez le bouton IO0 sur le côté du module :
Attendez que le texte « Connecting ….. » apparaisse dans le panneau de sortie :
Puis (tout en maintenant IO0 enfoncé) appuyez et relâchez le bouton RST (une demi-seconde) sur l’ESP32-CAM (PAS sur le shield de programmation !). Ce bouton est placé dans une position vraiment peu pratique, mais le bouton RST du shield ne fonctionnait pas pour moi. L’image ci-dessous montre l’emplacement du bouton RST à presser.
Quand les points dans le texte « Connecting ….. » cessent d’apparaître, vous pouvez relâcher le bouton IO0. Après cela, vous devriez voir le texte suivant apparaître dans le panneau de sortie, indiquant que le code est en cours de téléversement :
Mode exécution
Une fois que le texte « Hard resetting via RTS pin… » apparaît dans le panneau de sortie, le téléversement est terminé. Vous pouvez alors exécuter le programme téléversé en appuyant sur le bouton RST du module ESP32-CAM. Comme précédemment, n’utilisez pas le bouton RST du shield de programmation et ne pressez pas le bouton IO0.
Vous pouvez utiliser le code test suivant pour essayer le téléversement.
Code test pour ESP32-CAM avec shield de programmation
C’est un simple programme Blink qui allume la LED Flash de l’ESP32-CAM pendant 10 ms, attend 2 secondes, puis répète le cycle.
int flashPin = 4;
void setup() {
pinMode(flashPin, OUTPUT);
}
void loop() {
digitalWrite(flashPin, HIGH);
delay(10);
digitalWrite(flashPin, LOW);
delay(2000);
}
Si vous voyez la LED clignoter, vous avez réussi à téléverser un programme sur l’ESP32-CAM.
Vous avez peut-être remarqué que téléverser du code sur l’ESP32-CAM est une procédure vraiment fastidieuse. On s’attendrait à ce que le shield de programmation bascule automatiquement l’ESP32 en mode programmation, sans avoir à appuyer sur des boutons, mais cela ne fonctionnait pas avec les deux shields que j’ai essayés.
Même dans ce cas, le timing semble assez critique et la communication fragile. J’ai souvent dû essayer plusieurs fois pour réussir un téléversement. Débrancher et rebrancher le câble USB aidait souvent. Parfois, le téléversement démarrait sans que je presse aucun bouton après avoir changé de port USB.
Dans la section suivante, je vous montre comment utiliser un programmateur FTDI, qui facilite un peu le téléversement du code, mais ce n’est toujours pas entièrement automatique.
Téléverser du code avec un programmateur FTDI
Un programmateur FTDI ou adaptateur FTDI USB-TTL fait essentiellement le même travail que le shield de programmation pour l’ESP32-CAM. Il convertit les signaux USB en signaux série et permet de programmer des microcontrôleurs comme Arduino et ESP32 via l’interface UART.
Contrairement au shield de programmation, le programmateur FTDI n’est pas dédié à une carte spécifique mais peut être utilisé avec tous les microcontrôleurs supportant la communication série. Bien que plus flexible, il nécessite que vous fassiez vous-même le câblage entre le programmateur FTDI et le microcontrôleur. C’est ce que nous allons faire dans la section suivante.
Connexion du programmateur FTDI avec l’ESP32-CAM
L’image suivante montre comment connecter le programmateur FTDI au module ESP32-CAM :
Les connexions sont simples. Commencez par connecter la masse (GND) du programmateur à la masse du module ESP32-CAM (fil bleu). Faites de même avec l’alimentation 5V (fil rouge). Notez que certains programmateurs FTDI ont des cavaliers ou interrupteurs pour passer de 3.3V à 5V. Faites attention à cela.
Ensuite, connectez la broche U0T (U0TXD) de l’ESP32-CAM à la broche RXD du programmateur (fil jaune). De même, U0R est connecté à TXD (fil vert). La communication série est ainsi établie.
Pour passer l’ESP32-CAM en mode programmation, la broche IO0 doit être reliée à la masse (GND). Mais pour exécuter le programme, IO0 doit rester déconnectée. J’ai donc ajouté un interrupteur entre IO0 et GND (fil violet) qui me permet de basculer entre mode programmation et mode exécution. Voir photo ci-dessous :
Sélection de la carte ESP32-CAM
Branchez le programmateur FTDI avec l’ESP32-CAM connecté au port USB, cliquez sur le menu déroulant dans l’Arduino IDE puis sur « Select other board and port… » :
Cela ouvrira une boîte de dialogue où vous tapez « ESP32-CAM » dans la barre de recherche. Vous verrez la carte « AI Thinker ESP32-CAM » sous Boards. Cliquez dessus, sélectionnez le port COM pour l’activer, puis cliquez sur OK :
ESP32-CAM non reconnu sur le port COM
Si vous ne pouvez pas sélectionner de PORT malgré la connexion de l’ESP32-CAM via le programmateur FTDI, alors le pilote CP210X est manquant. Rendez-vous sur SILICON LABS Software Downloads et téléchargez le pilote CP210x pour votre système d’exploitation, par exemple pour Windows « CP210x VCP Windows » :
Cela téléchargera un fichier ZIP. Décompressez-le et lancez l’installateur. Après cela, votre ESP32-CAM devrait apparaître comme connecté à un port USB. Si vous avez encore des problèmes, vous devrez peut-être aussi installer le FTDI Driver pour le programmateur FTDI.
Mode programmation
La programmation avec le programmateur FTDI est très similaire à l’utilisation du shield de programmation. Commencez par passer le module ESP32-CAM en mode programmation en basculant l’interrupteur (IO0 connecté à GND).
Puis appuyez sur le bouton Upload dans l’Arduino IDE :
Attendez que le texte « Connecting ….. » apparaisse dans le moniteur série :
Puis appuyez rapidement et relâchez le bouton RST sur l’ESP32-CAM.
Les points après « Connecting ….. » devraient cesser d’apparaître et vous devriez voir la progression du téléversement dans le panneau de sortie :
Ce qui semble aussi fonctionner est de passer l’ESP32-CAM en mode programmation (interrupteur), puis d’appuyer sur le bouton RST et de le relâcher, puis de presser le bouton Upload dans l’Arduino IDE. Cela évite d’avoir à « chronométrer » le message de connexion.
Mode exécution
Une fois que le texte « Hard resetting via RTS pin… » apparaît dans le panneau de sortie, le téléversement est terminé. Basculez l’interrupteur pour passer du mode programmation au mode exécution et appuyez sur le bouton RST de l’ESP32-CAM pour démarrer le programme.
Vous pouvez utiliser le même code test que montré plus haut ou essayer quelque chose d’un peu plus avancé comme le code suivant.
Code test pour ESP32-CAM avec programmateur FTDI
C’est essentiellement le même programme Blink, mais nous augmentons lentement la luminosité de la LED Flash sur 255 étapes, puis l’éteignons pendant une seconde avant de répéter le cycle.
int flashPin = 4;
void setup() {
pinMode(flashPin, OUTPUT);
}
void loop() {
for (int b = 0; b < 255; b++) {
analogWrite(flashPin, b);
delay(1);
}
analogWrite(flashPin, 0);
delay(1000);
}
Comme la programmation reste fastidieuse (même avec le programmateur FTDI), vous voudrez tester d’abord le fonctionnement de la carte SD et de la caméra avant d’essayer un programme plus complexe. Dans les deux sections suivantes, je vous montre comment faire.
Tester la carte SD
Selon la fiche technique, l’ESP32-CAM ne supporte que les cartes microSD de 4GB. Cependant, les cartes microSD de 8GB et 16GB fonctionnent généralement bien. Les cartes plus grandes doivent être reformatées en FAT32. Utilisez le logiciel guiformat.exe de ridgecrop pour formater les cartes SD plus grandes en FAT32.
Le programme test suivant crée un fichier test, écrit du texte dedans, puis lit ce texte. Si cela fonctionne, votre carte SD fonctionne.
#include "SD_MMC.h"
#include "FS.h"
#include "LittleFS.h"
int flashPin = 4;
void setup() {
Serial.begin(115200);
SD_MMC.begin();
LittleFS.begin(true);
File file = LittleFS.open("/test.txt", FILE_WRITE);
file.print("*** Test successful ***");
file.close();
file = LittleFS.open("/test.txt");
while (file.available()) {
Serial.write(file.read());
}
file.close();
pinMode(flashPin, OUTPUT);
analogWrite(flashPin, 0);
}
void loop() {
}
Voici une explication plus détaillée du code.
Bibliothèques et initialisation
Nous commençons par inclure les bibliothèques nécessaires pour les opérations sur la carte SD et le système de fichiers : SD_MMC.h, FS.h, et LittleFS.h.
#include "SD_MMC.h" #include "FS.h" #include "LittleFS.h"
Nous définissons aussi une variable flashPin pour représenter la broche connectée à la LED flash.
int flashPin = 4;
Fonction setup
Dans la fonction setup(), nous initialisons la communication série à 115200 bauds.
void setup() {
Serial.begin(115200);
Nous initialisons ensuite la carte SD et le système de fichiers LittleFS. Appeler LittleFS.begin avec true garantit que le système de fichiers LittleFS est créé. En général, cela ne doit être fait qu’une fois, mais cela ne fait pas de mal d’appeler cette fonction à chaque fois.
SD_MMC.begin(); LittleFS.begin(true);
Ensuite, nous créons un fichier nommé test.txt en mode écriture, écrivons un message test dedans, puis fermons le fichier.
File file = LittleFS.open("/test.txt", FILE_WRITE);
file.print("*** Test successful ***");
file.close();
Nous rouvrons le fichier en mode lecture, lisons son contenu caractère par caractère, et l’affichons dans le moniteur série.
file = LittleFS.open("/test.txt");
while (file.available()) {
Serial.write(file.read());
}
file.close();
Enfin, nous configurons la broche flashPin en sortie et éteignons la LED Flash en mettant sa valeur PWM à 0. Je fais cela car écrire sur la carte SD allume automatiquement la LED Flash, ce qui est gênant. Le code test fonctionne bien sans ces deux lignes, mais je n’aimais pas la LED Flash dans mes yeux à chaque test.
pinMode(flashPin, OUTPUT); analogWrite(flashPin, 0);
Fonction loop
La fonction loop() est laissée vide, car tout se passe dans la fonction setup. Pour relancer le programme, vous devez réinitialiser l’ESP32-CAM.
void loop() {
}
Sortie dans le moniteur série
Si tout fonctionne correctement, vous devriez voir les lignes suivantes dans le moniteur série. Notez la dernière ligne « *** Test successful *** », qui prouve que nous avons pu écrire et lire sur la carte SD.
Autres tests
Vous pouvez aussi exécuter le test plus complexe fourni avec la bibliothèque ESP32. Il affiche des informations de débogage supplémentaires, ce qui peut être utile. Voir le sketch SDMMC_Test.ino. Le même code est disponible via les exemples Sketch : File -> Examples -> Examples for AI-Thinker ESP32-CAM -> SDMMC -> SDMMC_Test.
Tester la caméra
Après la carte SD, nous voulons tester la caméra. Le code ci-dessous est une version simplifiée de programmes plus complexes. À chaque démarrage de l’ESP32-CAM (appui sur le bouton reset), il prend une photo et la stocke sur la carte SD.
Ce code est spécifique au modèle AI-Thinker mais fonctionnera bien avec la plupart des autres cartes caméra basées sur ESP32, à condition qu’elles disposent de PSRAM (voir model definitions). Il suffit de remplacer le pin definitions selon votre modèle.
#include "esp_camera.h"
#include "soc/rtc_cntl_reg.h"
#include "SD_MMC.h"
#include "EEPROM.h"
// 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
void configCamera() {
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;
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 10;
config.fb_count = 2;
esp_err_t err = esp_camera_init(&config);
sensor_t* s = esp_camera_sensor_get();
s->set_brightness(s, 0);
s->set_contrast(s, 0);
s->set_saturation(s, 0);
s->set_special_effect(s, 0);
s->set_whitebal(s, 1);
s->set_awb_gain(s, 1);
s->set_wb_mode(s, 0);
s->set_exposure_ctrl(s, 1);
s->set_aec2(s, 0);
s->set_ae_level(s, 0);
s->set_aec_value(s, 300);
s->set_gain_ctrl(s, 1);
s->set_agc_gain(s, 0);
s->set_gainceiling(s, (gainceiling_t)0);
s->set_bpc(s, 0);
s->set_wpc(s, 1);
s->set_raw_gma(s, 1);
s->set_lenc(s, 1);
s->set_hmirror(s, 0);
s->set_vflip(s, 0);
s->set_dcw(s, 1);
s->set_colorbar(s, 0);
}
unsigned int incCounter() {
unsigned int cnt = 0;
int adr = 0;
EEPROM.get(adr, cnt);
EEPROM.put(adr, cnt + 1);
EEPROM.commit();
return cnt;
}
void skipPictures(int n) {
for(int i=0; i<n; i++) {
camera_fb_t* fb = esp_camera_fb_get();
esp_camera_fb_return(fb);
}
}
void takePicture() {
camera_fb_t* fb = esp_camera_fb_get();
unsigned int cnt = incCounter();
String path = "/pic" + String(cnt) + ".jpg";
Serial.println(path);
File file = SD_MMC.open(path.c_str(), FILE_WRITE);
file.write(fb->buf, fb->len);
file.close();
esp_camera_fb_return(fb);
}
void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
Serial.begin(115200);
SD_MMC.begin();
EEPROM.begin(16);
configCamera();
skipPictures(n);
takePicture();
esp_deep_sleep_start();
}
void loop() {
}
Ce code est un bon point de départ pour des cas d’usage plus avancés. Par exemple, prendre une photo lorsqu’un capteur de mouvement ou de lumière est déclenché, ou prendre des photos à intervalles réguliers. Voici un peu plus de détails sur le fonctionnement de ce code.
Constantes et bibliothèques
Tout d’abord, nous incluons les bibliothèques nécessaires telles que esp_camera.h, soc/rtc_cntl_reg.h, SD_MMC.h, et EEPROM.h. Ces bibliothèques fournissent des fonctionnalités pour la configuration de la caméra, les opérations sur la carte SD et l’utilisation de l’EEPROM.
#include "esp_camera.h" #include "soc/rtc_cntl_reg.h" #include "SD_MMC.h" #include "EEPROM.h"
Configuration de la caméra
La fonction configCamera() configure les paramètres de la caméra tels que le canal LEDC, les broches des lignes de données (D0-D7), XCLK, PCLK, VSYNC, HREF, SCCB SDA, SCCB SCL, PWDN, RESET, ainsi que divers réglages comme le format des pixels, la taille de l’image, la qualité JPEG, etc.
void configCamera() {
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;
...
sensor_t* s = esp_camera_sensor_get();
s->set_brightness(s, 0);
s->set_contrast(s, 0);
s->set_saturation(s, 0);
...
}
Comme mentionné, selon le type de caméra, les définitions des broches peuvent changer. Si la qualité des images ne vous satisfait pas, de nombreux paramètres sont modifiables.
Fonction d’incrémentation du compteur
La fonction incCounter() lit et incrémente une valeur de compteur stockée dans la mémoire EEPROM. Elle récupère le compteur actuel, l’incrémente, l’écrit dans l’EEPROM, et retourne la valeur précédente.
unsigned int incCounter() {
unsigned int cnt = 0;
int adr = 0;
EEPROM.get(adr, cnt);
EEPROM.put(adr, cnt + 1);
EEPROM.commit();
return cnt;
}
Cela garantit un compteur continu pour les photos prises, même après un reset de l’ESP32-CAM. Ce compteur est aussi utilisé pour créer des noms de fichiers uniques pour les images stockées sur la carte SD.
Si vous voulez réinitialiser le compteur, vous pouvez téléverser et exécuter le code suivant :
#include "EEPROM.h"
void setup() {
EEPROM.begin(512);
unsigned int cnt = 0;
int adr = 0;
EEPROM.put(adr, cnt);
EEPROM.commit();
}
void loop() {
}
Ignorer les images
La fonction SkipPictures(n) capture n images et les jette. La raison est la suivante : la caméra intègre plusieurs fonctions automatiques, comme la balance des blancs automatique, qui prennent du temps et plusieurs images pour s’ajuster à l’environnement. Après un redémarrage depuis le mode deep sleep, il faut donc laisser un peu de temps à la caméra pour s’adapter.
void skipPictures(int n) {
for(int i=0; i<n; i++) {
camera_fb_t* fb = esp_camera_fb_get();
esp_camera_fb_return(fb);
}
}
Si vous prenez la première image juste après un redémarrage, elle sera de mauvaise qualité, souvent avec une forte teinte bleue, ou trop sombre ou trop claire. En sautant les premières images, vous obtenez généralement (mais pas toujours) des photos de bonne qualité.
Vous pouvez aussi essayer de désactiver la balance des blancs automatique et d’autres fonctions automatiques dans les réglages de la caméra, mais il faudra alors un environnement assez stable pour régler les autres paramètres. Sinon, il sera difficile d’obtenir de bonnes images.
Capture et stockage d’image
La fonction suivante capture une image avec la caméra et la sauvegarde sur la carte SD. Elle récupère un buffer d’image, incrémente le compteur, crée un chemin de fichier unique pour l’image, écrit les données dans le fichier, puis libère le buffer.
void takePicture() {
camera_fb_t* fb = esp_camera_fb_get();
unsigned int cnt = incCounter();
String path = "/pic" + String(cnt) + ".jpg";
Serial.println(path);
File file = SD_MMC.open(path.c_str(), FILE_WRITE);
file.write(fb->buf, fb->len);
file.close();
esp_camera_fb_return(fb);
}
Notez que nous utilisons la variable compteur pour créer les noms de fichiers. Si vous n’aimez pas ces noms, c’est ici qu’il faut les modifier.
Fonction setup
Dans la fonction setup(), nous désactivons d’abord le détecteur de brownout. L’ESP32-CAM est trop prompt à signaler des erreurs de brownout si l’alimentation délivre un courant faible au démarrage. Appeler WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0) évite ce problème.
Ensuite, nous initialisons la communication série, démarrons la carte SD, initialisons l’EEPROM, configurons la caméra, capturons une image, puis lançons le mode deep sleep. Cela signifie qu’à chaque démarrage ou reset, une nouvelle photo est prise et stockée sur la carte SD.
void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
Serial.begin(115200);
SD_MMC.begin();
EEPROM.begin(512);
configCamera();
takePicture();
esp_deep_sleep_start();
}
Fonction loop
La fonction loop() est vide. Tout se passe dans setup et une seule photo est prise, après quoi la carte passe en deep sleep en attendant un redémarrage.
Exemple de serveur web caméra
Si vous voulez un test qui utilise les capacités WiFi de l’ESP32, l’exemple CameraWebServer est intéressant. Vous le trouverez sous File -> Examples -> ESP32 -> Camera -> CameraWebServer.
Vous devrez modifier légèrement le code dans CameraWebServer.ino. D’abord, définissez le modèle de caméra que vous utilisez. Assurez-vous que seul le modèle que vous avez est défini !
// =================== // Select camera model // =================== //#define CAMERA_MODEL_WROVER_KIT // Has PSRAM //#define CAMERA_MODEL_ESP_EYE // Has PSRAM ... //#define CAMERA_MODEL_M5STACK_UNITCAM // No PSRAM #define CAMERA_MODEL_AI_THINKER // Has PSRAM //#define CAMERA_MODEL_TTGO_T_JOURNAL // No PSRAM //#define CAMERA_MODEL_XIAO_ESP32S3 // Has PSRAM
Ensuite, entrez les identifiants WiFi de votre réseau domestique :
// =========================== // Enter your WiFi credentials // =========================== const char* ssid = "**********"; const char* password = "**********";
Après avoir téléversé le code et réinitialisé l’ESP32-CAM, vous devriez voir le texte suivant dans le moniteur série :
CameraWebServerNotez la dernière ligne, qui vous donne l’URL (adresse IP) où le serveur web tourne. Copiez-collez cette URL dans la barre d’adresse de votre navigateur et vous verrez le site web suivant, qui diffuse les images de la caméra ESP32-CAM vers votre navigateur.
CameraWebServer dans le navigateur webEt voilà ! Cela devrait vous fournir assez d’informations et d’exemples pour commencer avec le module ESP32-CAM.
Si vous avez besoin d’un exemple plus simple pour le streaming vidéo, consultez le tutoriel Stream Video with ESP32-CAM. Pour une caméra activée par détection de mouvement, voyez le tutoriel Motion Activated ESP32-CAM.
Résumé
Le module ESP32-CAM est une carte sympa et performante une fois qu’elle fonctionne. Cependant, téléverser du code de manière fiable est fastidieux. J’ai souvent dû essayer plusieurs fois et débrancher le câble USB pour que ça marche. En fait, la méthode la plus fiable était la suivante :
- Débrancher le câble USB
- Passer la carte en mode programmation
- Rebrancher le câble USB
- Lancer le téléversement dans l’Arduino IDE
Cela fonctionnait toujours et ne nécessitait pas d’appuyer sur le bouton RST pendant le téléversement. Pour exécuter l’ESP32-CAM, il suffisait de désactiver le mode programmation et d’appuyer sur reset. Pas besoin de débrancher le câble USB pour cela. Il fallait juste débrancher la carte et refaire la procédure pour téléverser un nouveau programme.
Un autre truc que j’ai trouvé est que retirer la carte SD aide quand la carte refuse d’entrer en mode programmation. Cela arrivait souvent quand le code précédemment flashé utilisait la carte SD.
Si vous avez des difficultés avec votre carte ESP32-CAM, voici quelques liens avec des informations supplémentaires et une liste de questions fréquentes avec leurs réponses.
Enfin, si vous cherchez une carte qui ne nécessite pas de shield de programmation ou de programmateur FTDI pour le flash, regardez la ESP32-WROVER CAM, qui offre aussi plus de GPIO libres mais est plus grande. Si vous avez besoin d’une carte très petite avec microphone, je recommande la XIAO-ESP32-S3-Sense.
Bon bricolage !
Liens
Voici quelques liens que j’ai trouvés utiles pour débuter avec l’ESP32-CAM :
- Getting Started With ESP32-CAM
- How to Program / Upload Code to ESP32-CAM AI-Thinker (Arduino IDE)
- ESP32-CAM Troubleshooting Guide: Most Common Problems Fixed
- ESP32-CAM AI-Thinker Pinout Guide: GPIOs Usage Explained
- ESP32-CAM Take Photo and Save to MicroSD Card
- Camera Pin Definitions
- Supported Camera Models
Questions fréquentes
Voici quelques questions courantes et leurs solutions pour vous aider à dépanner :
Q : Pourquoi mon ESP32-CAM ne se connecte-t-il pas au Wi-Fi ?
R : Vérifiez que vous avez saisi le bon SSID et mot de passe dans votre code. Assurez-vous que le réseau Wi-Fi est à portée et fonctionne correctement.
Q : Comment améliorer la qualité d’image de la caméra ?
R : Ajustez les paramètres de la caméra dans votre code pour optimiser la qualité d’image. Essayez différentes résolutions et fréquences d’images pour trouver la meilleure configuration pour votre projet.
Q : Comment ajouter plus de GPIO ?
R : Vous pouvez initialiser l’interface carte SD en mode 1 bit, ce qui libère deux broches GPIO supplémentaires. Pour plus de détails, voir le More GPIO pins for ESP32-CAM tutoriel.
Q : Pourquoi mon ESP32-CAM ne capture-t-il pas d’images nettes ?
R : Un mauvais éclairage peut affecter la qualité d’image. Assurez-vous d’un bon éclairage pour la caméra. Ajustez les paramètres dans votre code pour une qualité optimale. Vérifiez aussi que vous avez retiré le petit film protecteur de l’objectif.
Q : Que faire si mon ESP32-CAM ne répond pas aux commandes du moniteur série ?
R : Vérifiez les paramètres de communication série dans votre code et assurez-vous que le baud rate correct (115200) est configuré à la fois dans le code et dans le moniteur série. Vérifiez les connexions entre la carte ESP32-CAM et l’ordinateur.
Q : Pourquoi ma carte SD n’est-elle pas détectée ?
R : Assurez-vous que la carte SD est bien insérée dans le slot et formatée correctement (FAT32). Vérifiez dans votre code que l’initialisation de la carte SD est correcte. Les cartes de 4 à 16GB devraient fonctionner. Les cartes de plus grande capacité peuvent poser problème.
Q : Mon ESP32-CAM chauffe, est-ce normal ?
R : Il est normal que l’ESP32-CAM chauffe un peu en fonctionnement, mais s’il chauffe excessivement, vérifiez qu’il n’y a pas de court-circuit ou de problème d’alimentation.
Q : Comment réduire la consommation d’énergie de l’ESP32-CAM ?
R : Désactivez les périphériques inutiles et optimisez votre code pour minimiser la consommation. Envisagez d’utiliser les modes veille pour économiser de l’énergie quand la carte n’est pas utilisée.
Q : Pourquoi les images prises par l’ESP32-CAM ont-elles une teinte bleue après un redémarrage ?
R : La caméra a des fonctions automatiques, comme la balance des blancs automatique, qui prennent du temps pour s’ajuster à l’environnement. Sans cela, vous obtenez des images bleutées ou trop sombres ou claires. Une solution simple est de prendre plusieurs images après un redémarrage et de les ignorer. Voir la fonction skipPictures() dans le tutoriel qui fait exactement cela.
Q : Pourquoi mon ESP32-CAM ne capture-t-il pas d’images ?
R : Vérifiez que le module caméra est bien connecté à la carte ESP32-CAM. Assurez-vous que les broches de la caméra sont correctement câblées et que le module caméra est supporté par votre code.
Q : Comment diffuser une vidéo depuis l’ESP32-CAM ?
R : Implémentez un serveur de streaming sur l’ESP32-CAM en utilisant des bibliothèques comme ESP32-CAM-Webserver pour diffuser la vidéo via Wi-Fi. Assurez-vous que votre réseau supporte la bande passante nécessaire au streaming.
Q : Pourquoi mon ESP32-CAM n’est-il pas reconnu par l’Arduino IDE ?
R : Assurez-vous d’avoir installé le package de support des cartes ESP32 dans l’Arduino IDE. Vérifiez votre câble USB et les connexions au port pour assurer une communication correcte avec la carte ESP32-CAM.
Q : Pourquoi mon ESP32-CAM affiche-t-il « Timed out waiting for packet header » lors du téléversement ?
R : Cette erreur peut être due à une connexion USB lente ou instable. Essayez un autre câble USB ou port, et assurez-vous que la carte ESP32-CAM est sous tension et en mode bootloader avant de téléverser le code.
Q : Que faire si mon ESP32-CAM se fige pendant le téléversement ?
R : Déconnectez le câble USB, réinitialisez la carte ESP32-CAM, puis essayez de téléverser à nouveau. Assurez-vous que votre code ne provoque pas de blocage ou de plantage pendant le téléversement.
Q : Puis-je téléverser du code sur l’ESP32-CAM sans fil ?
R : Oui, vous pouvez téléverser du code sans fil via la programmation OTA (Over-The-Air). Implémentez la fonctionnalité OTA dans votre code et suivez les étapes nécessaires pour téléverser sans connexion USB.
Q : Pourquoi mon ESP32-CAM n’entre-t-il pas en mode bootloader pour le téléversement ?
R : Vérifiez bien la connexion de la broche GPIO0 à la masse sur la carte ESP32-CAM. Assurez-vous d’appuyer sur le bouton reset au bon moment pour entrer en mode bootloader pour le téléversement.
Q : Comment résoudre l’erreur « A fatal error occurred: Failed to connect to ESP32: Timed out waiting for packet header » lors du téléversement ?
R : Cette erreur peut être due à un mauvais réglage du baud rate ou un câble USB défectueux. Essayez de changer le baud rate dans les paramètres de l’Arduino IDE ou d’utiliser un autre câble USB pour établir une connexion stable avec la carte ESP32-CAM.
Q : Quelles étapes suivre si je vois « esptool.FatalError: Timed out waiting for packet header » lors du téléversement ?
R : Cette erreur indique un problème de timeout de communication entre l’ordinateur et la carte ESP32-CAM. Vérifiez le câble USB, le port et les connexions de la carte. Redémarrez l’IDE, réinitialisez la carte, puis essayez de téléverser à nouveau.
Q : Que faire si je vois l’erreur « Brownout detector was triggered » ?
R : Cette erreur survient généralement si l’alimentation de l’ESP32-CAM est insuffisante, provoquant une chute de tension. Un circuit interne détecte ce problème, envoie ce message d’erreur au moniteur série et réinitialise la carte. Assurez-vous d’alimenter l’ESP32-CAM via la broche 5V avec une alimentation capable de fournir 1A. Pour plus d’informations, voir notre Fix brownout of ESP32-CAM tutoriel.
