Contrôler la LED Flash de l’ESP32-CAM

Ce court tutoriel vous montre comment allumer ou éteindre la LED Flash de l’ESP32-CAM, avec ou sans deep-sleep. Vous apprendrez aussi à contrôler la luminosité de la LED et à quoi faire attention lorsque vous utilisez la LED et l’interface carte SD ensemble.

Pièces requises

Vous aurez besoin d’un ESP32-CAM pour tester les exemples de code. Vous pouvez obtenir un ESP32-CAM avec un Shield USB-TTL pour la programmation ou un adaptateur FTDI USB-TTL. Je recommande l’adaptateur FTDI USB-TTL, car il est plus pratique pour programmer, mais j’ai listé les deux options ci-dessous.

Si vous voulez utiliser le lecteur de carte SD, vous aurez besoin d’une carte SD ne dépassant pas 16 Go. Cependant, elle ne sera pas nécessaire pour ce tutoriel.

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.

Faire clignoter la LED Flash

Si vous n’utilisez pas la carte SD ni le mode deep-sleep de l’ESP32-CAM, contrôler la LED flash est simple. La LED flash est connectée au GPIO 4 et le code habituel Blink fonctionne parfaitement.

void setup() {
  pinMode(GPIO_NUM_4, OUTPUT);
}

void loop() {
  digitalWrite(GPIO_NUM_4, HIGH);
  delay(1000);
  digitalWrite(GPIO_NUM_4, LOW);
  delay(1000);
}

Si vous sélectionnez la carte AI Thinker ESP32-CAM, la constante GPIO_NUM_4 pour le GPIO 4 est définie.

Dans la fonction setup, nous pouvons donc utiliser GPIO_NUM_4 pour configurer le GPIO 4 en mode sortie. Dans la fonction loop, nous avons le code habituel Blink qui allume la LED pendant une seconde puis l’éteint pendant une autre seconde.

Si vous ne savez pas comment télécharger du code sur l’ESP32-CAM, consultez le tutoriel Programming the ESP32-CAM.

Contrôler la luminosité de la LED Flash

Le GPIO 4 supporte aussi le PWM (modulation de largeur d’impulsion), ce qui signifie que vous pouvez contrôler la luminosité de la LED flash. L’exemple suivant augmente la luminosité b de 0 (éteint) à la luminosité maximale (255) en boucle :

void setup() {
  pinMode(GPIO_NUM_4, OUTPUT);
}

void loop() {
  for (int b = 0; b < 256; b++) {
    analogWrite(GPIO_NUM_4, b);
    delay(10);
  }
}

Faire clignoter la LED Flash avec deep-sleep

Les choses se compliquent quand vous voulez faire clignoter la LED en combinaison avec le deep-sleep. Par exemple, vous voulez mettre l’ESP32-CAM en veille, le réveiller quand un objet passe, allumer la LED flash, prendre une photo, éteindre la LED et retourner en veille.

Le problème est que l’état de sortie des broches GPIO est normalement perdu quand l’ESP32 entre en deep-sleep. Les broches GPIO flottent sans valeur définie. Vous pouvez éviter cela en appelant la fonction rtc_gpio_hold_en(pin) pour une broche spécifique ou la fonction rtc_gpio_force_hold_en_all() pour figer toutes les broches dans leur état actuel.

Cependant, quand l’ESP32 se réveille du deep-sleep, vous devez désactiver ce maintien des broches, sinon vous ne pouvez pas changer leur état. Pour désactiver le maintien, vous pouvez appeler les fonctions rtc_gpio_hold_dis(pin) ou rtc_gpio_force_hold_dis_all().

L’exemple de code suivant montre comment utiliser ces fonctions pour éteindre la LED pendant une seconde, pendant que l’ESP32 est réveillé, puis allumer la LED pendant que l’ESP32 dort une seconde :

#include "driver/rtc_io.h"

void setup() {
  rtc_gpio_hold_dis(GPIO_NUM_4);
  pinMode(GPIO_NUM_4, OUTPUT);

  digitalWrite(GPIO_NUM_4, LOW);
  delay(1000);
  digitalWrite(GPIO_NUM_4, HIGH);

  rtc_gpio_hold_en(GPIO_NUM_4);
  esp_sleep_enable_timer_wakeup(1 * 1000 * 1000);
  esp_deep_sleep_start();
}

void loop() {}

Entrons un peu plus dans les détails.

D’abord, nous importons le fichier driver/rtc_io.h, nécessaire pour les fonctions rtc_gpio_hold_xxx.

Dans la fonction setup, nous commençons par appeler rtc_gpio_hold_dis(GPIO_NUM_4). Cela désactive tout maintien sur la broche GPIO 4. Sans cela, nous ne pourrions pas changer l’état de la broche 4 plus tard.

Dans la ligne suivante, nous appelons pinMode(GPIO_NUM_4, OUTPUT) pour passer la broche GPIO 4 en mode sortie. Puis nous pouvons mettre la broche 4 à LOW (éteindre la LED) en appelant digitalWrite(GPIO_NUM_4, LOW).

Après un délai d’une seconde, nous mettons la broche 4 à HIGH puis ça devient intéressant. Nous voulons entrer en deep-sleep mais perdrions l’état de la broche 4. Nous devons donc appeler rtc_gpio_hold_en(GPIO_NUM_4) pour maintenir l’état HIGH actuel de la broche 4.

Enfin, nous réglons la minuterie de deep-sleep à une seconde (esp_sleep_enable_timer_wakeup) et entrons en deep-sleep via esp_deep_sleep_start().

Quand l’ESP32 se réveille après une seconde, il recommence au début de la fonction setup. La fonction loop n’est jamais appelée.

LED Flash et interface carte SD

Contrôler la LED flash est particulièrement délicat quand vous voulez aussi utiliser la carte SD. En effet, la ligne de données HS2_DATA1 de l’interface carte SD est partagée avec la LED flash. Le schéma suivant montre le circuit de commande de la LED flash.

Vous pouvez voir que l’alimentation de LED_FLASH est commutée via un transistor Q1, lui-même contrôlé par une ligne de signal nommée HS2_DATA1. Si vous regardez maintenant le schéma de câblage de la prise carte SD, vous verrez aussi la ligne HS2_DATA1 (dernier fil), utilisée pour transférer les données vers la carte SD :

C’est la raison pour laquelle la LED de l’ESP32-CAM clignote brièvement quand vous écrivez sur la carte SD.

Puisque la LED et la carte SD utilisent toutes deux HS2_DATA1, vous devez vous assurer de ne pas maintenir GPIO 4 ou manipuler la LED/GPIO 4 pendant que vous écrivez ou lisez sur la carte SD.

L’exemple de code suivant montre comment allumer la LED, prendre une photo, la sauvegarder sur la carte SD, éteindre la LED puis dormir 5 secondes avant la prochaine itération.

#include "FS.h"
#include "SD_MMC.h"
#include "driver/rtc_io.h"
#include "esp32cam.h"

const auto RES = esp32cam::Resolution::find(800, 600);
RTC_DATA_ATTR uint16_t counter = 0;

void takeAndSavePic() {
  static char path[64];
  auto frame = esp32cam::capture();
  if (frame) {
    sprintf(path, "/img%d.jpg", counter++);
    File file = SD_MMC.open(path, FILE_WRITE);
    frame->writeTo(file);
    file.close();
    Serial.printf("Wrote: %s\n", path);
    delay(10);
  }
}

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::AiThinker);
  cfg.setResolution(RES);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

void setup() {
  Serial.begin(115200);
  rtc_gpio_hold_dis(GPIO_NUM_4);
  
  SD_MMC.begin();
  initCamera();

  pinMode(GPIO_NUM_4, OUTPUT);
  digitalWrite(GPIO_NUM_4, HIGH);
  takeAndSavePic();
  digitalWrite(GPIO_NUM_4, LOW);

  rtc_gpio_hold_en(GPIO_NUM_4);
  esp_sleep_enable_timer_wakeup(5 * 1000 * 1000);
  esp_deep_sleep_start();
}

void loop() { }

Pour ce code, vous aurez besoin de la bibliothèque esp32cam, qui facilite la gestion de la caméra. Vous pouvez l’installer via le Library Manager de l’IDE Arduino. Cherchez simplement « esp32cam » :

Je ne détaillerai pas le fonctionnement du code caméra mais me concentrerai sur l’interaction entre la prise de photo, la sauvegarde sur carte SD, le contrôle de la LED flash et l’utilisation du deep-sleep. Tout cela se passe dans la fonction setup.

Comme vous pouvez le voir, la première chose est d’appeler rtc_gpio_hold_dis(GPIO_NUM_4) pour désactiver tout maintien sur GPIO 4. Sinon, nous ne pouvons pas contrôler la flash ni utiliser la carte SD.

Ensuite, nous initialisons l’interface carte SD via SD_MMC.begin() et aussi la caméra via initCamera().

Puis nous allumons la LED flash en appelant digitalWrite(GPIO_NUM_4, HIGH), prenons une photo, la sauvegardons sur la carte SD, puis éteignons la LED.

Avant d’entrer en deep-sleep, vous devez appeler rtc_gpio_hold_en(GPIO_NUM_4) pour garantir que GPIO 4 conserve son état (LOW) pendant le deep-sleep et que la LED flash reste éteinte.

Après cela, nous réglons la minuterie de deep-sleep à 5 secondes puis lançons le mode deep-sleep. L’ESP32 se réveillera automatiquement après 5 secondes et le cycle recommencera.

Éteindre la Flash lors de l’écriture sur la carte SD

Comme mentionné, la LED flash et la carte SD partagent la même ligne de signal nommée HS2_DATA1, et donc la LED clignote brièvement lors de l’écriture sur la carte SD. Vous pouvez éviter cela en activant le mode 1-bit pour le SD Card interface :

 SD_MMC.begin("/sdcard", true);

Le second argument mode1bit==true active le mode 1-bit. Dans ce mode, la ligne HS2_DATA1 (GPIO 4) n’est pas utilisée et la LED ne clignotera pas lors de l’écriture sur la carte SD. Bien que la vitesse d’écriture soit plus lente, vous pouvez maintenant contrôler librement GPIO 4, puisqu’il est alors utilisé uniquement par la LED.

Vous pouvez tester cela avec le code suivant. Il éteint la LED et écrit un fichier 10 fois :

#include "FS.h"
#include "SD_MMC.h"

void setup() {
  Serial.begin(115200);

  pinMode(GPIO_NUM_4, OUTPUT);
  digitalWrite(GPIO_NUM_4, LOW);  

  //SD_MMC.begin();  // LED will switch on
  SD_MMC.begin("/sdcard", true);  // LED remains off

  for (int i = 0; i < 10; i++) {
    delay(1000);
    File file = SD_MMC.open("/test.txt", FILE_WRITE);
    file.println("TEST");
    file.close();
    Serial.println("File written");
  }
}

void loop() { }

Avec SD_MMC.begin(), la LED s’allumera (malgré qu’elle soit configurée pour être éteinte) dès que le code commence à écrire les fichiers. Avec SD_MMC.begin("/sdcard", true) par contre, la LED reste éteinte.

Conclusions

Dans ce tutoriel, vous avez appris à contrôler la LED flash de l’ESP32-CAM dans divers scénarios, notamment en combinaison avec le deep-sleep et le support carte SD.

Il est important de mentionner qu’il faut éviter d’allumer la LED flash pendant de longues périodes. Le schéma montre qu’il n’y a pas de résistance de limitation de courant pour la LED, ce qui signifie qu’elle peut facilement surchauffer et griller.

Si vous avez besoin d’informations plus fondamentales sur l’ESP32-CAM, consultez le tutoriel Programming the ESP32-CAM. Si vous voulez appliquer ce que vous avez appris ici pour construire une caméra activée par mouvement, voyez le tutoriel Motion Activated ESP32-CAM. Enfin, si vous souhaitez utiliser l’ESP32-CAM pour la détection d’objets, le Object Detection with ESP32-CAM and YOLO vous sera utile.

Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.

Bon bricolage ; )