Dieses kurze Tutorial zeigt, wie man die Flash-LED des ESP32-CAM ein- oder ausschaltet, mit und ohne deep-sleep. Du lernst außerdem, wie du die Helligkeit der LED steuerst und worauf du achten musst, wenn du LED und SD-Karten-Schnittstelle zusammen verwendest.
Benötigte Teile
Du benötigst ein ESP32-CAM, um die Codebeispiele auszuprobieren. Du kannst ein ESP32-CAM mit einem USB-TTL Shield zum Programmieren oder einen FTDI USB-TTL Adapter verwenden. Ich empfehle den FTDI USB-TTL Adapter, da er beim Programmieren praktischer ist, aber ich habe beide Optionen unten aufgeführt.
Wenn du den SD-Kartenleser verwenden möchtest, brauchst du eine SD-Karte, die nicht größer als 16 GB ist. Für dieses Tutorial benötigst du sie jedoch nicht.
ESP32-CAM mit USB-TTL Shield
FTDI USB-TTL Adapter
MicroSD Card 16GB
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.
Flash-LED blinken
Wenn du die SD-Karte oder den deep-sleep-Modus des ESP32-CAM nicht verwendest, ist das Steuern der Flash-LED einfach. Die Flash-LED ist an GPIO 4 angeschlossen und das übliche Blink code funktioniert einwandfrei.
void setup() {
pinMode(GPIO_NUM_4, OUTPUT);
}
void loop() {
digitalWrite(GPIO_NUM_4, HIGH);
delay(1000);
digitalWrite(GPIO_NUM_4, LOW);
delay(1000);
}
Wenn du das § auswählstAI Thinker ESP32-CAM als Board, ist die Konstante GPIO_NUM_4 für GPIO 4 definiert.
In der setup Funktion können wir daher GPIO_NUM_4 verwenden, um GPIO 4 auf Ausgangsmodus zu setzen. In der loop Funktion haben wir das übliche Blink code das die LED eine Sekunde einschaltet und für eine weitere Sekunde ausschaltet.
Wenn du nicht weißt, wie man Code auf das ESP32-CAM lädt, schau dir das Programming the ESP32-CAM Tutorial an.
Helligkeit der Flash-LED steuern
GPIO 4 unterstützt außerdem PWM (Pulse Width Modulation), was bedeutet, dass du die Helligkeit der Flash-LED steuern kannst. Das folgende Beispiel erhöht die Helligkeit b von 0 (aus) bis zur maximalen Helligkeit (255) in einer Schleife:
void setup() {
pinMode(GPIO_NUM_4, OUTPUT);
}
void loop() {
for (int b = 0; b < 256; b++) {
analogWrite(GPIO_NUM_4, b);
delay(10);
}
}
Flash-LED blinken mit deep-sleep
Es wird knifflig, wenn du die LED in Kombination mit deep-sleep blinken lassen willst. Zum Beispiel möchtest du das ESP32-CAM in den Schlaf versetzen, es aufwecken, wenn sich ein Objekt bewegt, die Flash-LED einschalten, ein Foto machen, die LED ausschalten und wieder schlafen legen.
Das Problem ist, dass der Ausgangszustand von GPIO-Pins normalerweise verloren geht, wenn der ESP32 in den deep-sleep geht. Die GPIO-Pins treiben dann einfach vor sich hin, ohne definierten Wert. Du kannst das vermeiden, indem du die rtc_gpio_hold_en(pin) für einen bestimmten Pin oder die rtc_gpio_force_hold_en_all() Funktion aufrufst, um alle Pins in ihrem aktuellen Zustand einzufrieren.
Allerdings musst du, wenn der ESP32 aus dem deep-sleep aufwacht, dieses Halten der Pins deaktivieren, sonst kannst du den Zustand der Pins nicht setzen. Um das Halten zu deaktivieren, kannst du die Funktionen rtc_gpio_hold_dis(pin) oder rtc_gpio_force_hold_dis_all() aufrufen.
Die folgenden Codebeispiele zeigen, wie man diese Funktionen verwendet, um die LED für eine Sekunde auszuschalten, während der ESP32 wach ist, und dann die LED einzuschalten, während der ESP32 für eine Sekunde schläft:
#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() {}
Lass uns das etwas genauer besprechen.
Zuerst importieren wir die driver/rtc_io.h Datei, die für die rtc_gpio_hold_xxx Funktionen benötigt wird.
In der setup-Funktion beginnen wir mit dem Aufruf von rtc_gpio_hold_dis(GPIO_NUM_4). Damit wird jegliches Halten auf GPIO-Pin 4 deaktiviert. Ohne das könnten wir den Zustand von Pin 4 später nicht ändern.
In der nächsten Zeile rufen wir pinMode(GPIO_NUM_4, OUTPUT) auf, um GPIO-Pin 4 auf Ausgangsmodus zu schalten. Und dann können wir Pin 4 auf LOW setzen (LED ausschalten), indem wir digitalWrite(GPIO_NUM_4, LOW) aufrufen.
Nach einer Verzögerung von einer Sekunde setzen wir Pin 4 auf HIGH und dann wird es interessant. Wir wollen in den deep-sleep gehen, würden aber den Zustand von Pin 4 verlieren. Deshalb müssen wir rtc_gpio_hold_en(GPIO_NUM_4) aufrufen, um den aktuellen HIGH Zustand von Pin 4 zu halten.
Schließlich setzen wir den deep-sleep-Timer auf eine Sekunde (esp_sleep_enable_timer_wakeup) und treten mittels esp_deep_sleep_start() in den deep-sleep ein.
Wenn der ESP32 nach einer Sekunde aufwacht, beginnt er wieder am Anfang der setup Funktion. Die loop Funktion wird nie aufgerufen.
Flash-LED und SD-Karten-Schnittstelle
Das Steuern der Flash-LED ist besonders knifflig, wenn du auch die SD-Karte verwenden willst. Das liegt daran, dass die HS2_DATA1-Datenleitung der SD-Karten-Schnittstelle von der Flash-LED geteilt wird. Das folgende Diagramm zeigt die Schaltung zur Steuerung der Flash-LED.
Du kannst sehen, dass die Stromversorgung von LED_FLASH über Transistor § geschaltet wird,Q1 der seinerseits von einer Signalleitung mit der Bezeichnung § gesteuert wird.HS2_DATA1Wenn du dir nun das Anschlussdiagramm für die SD-Kartenbuchse ansiehst, wirst du auch die HS2_DATA1 Leitung (letztes Kabel) sehen, die verwendet wird, um Daten auf die SD-Karte zu übertragen:
Deshalb blinkt die LED des ESP32-CAM normalerweise kurz, wenn du auf die SD-Karte schreibst.
Da die LED und die SD-Karte beide HS2_DATA1 verwenden, musst du darauf achten, GPIO 4 nicht zu halten oder irgendetwas mit der LED/GPIO 4 zu machen, während du auf die SD-Karte schreibst oder von ihr liest.
Das folgende Codebeispiel zeigt, wie man die LED einschaltet, ein Bild macht, es auf der SD-Karte speichert, die LED ausschaltet und dann für 5 Sekunden schläft, bis die nächste Iteration beginnt.
#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() { }
Für diesen Code benötigst du die esp32cam Bibliothek, die die Handhabung der Kamera vereinfacht. Du kannst sie über den Library Manager in der Arduino IDE installieren. Einfach nach „esp32cam“ suchen:
Ich werde nicht ins Detail gehen, wie der Kameracode funktioniert, sondern mich auf das Zusammenspiel zwischen dem Aufnehmen eines Bildes, dem Speichern auf der SD-Karte, der Steuerung der Flash-LED und der Nutzung von deep-sleep konzentrieren. Das alles passiert in der setup Funktion.
Wie du sehen kannst, ist das Erste, rtc_gpio_hold_dis(GPIO_NUM_4) aufzurufen, um jegliches Halten auf GPIO 4 zu deaktivieren. Andernfalls können wir das Flash nicht steuern oder die SD-Karte verwenden.
Als Nächstes initialisieren wir die SD-Karten-Schnittstelle über SD_MMC.begin() und initialisieren zusätzlich die Kamera via initCamera().
Dann schalten wir die Flash-LED ein, indem wir digitalWrite(GPIO_NUM_4, HIGH) aufrufen, machen ein Foto, speichern es auf der SD-Karte und schalten die LED dann wieder aus.
Bevor wir in den deep-sleep gehen können, musst du rtc_gpio_hold_en(GPIO_NUM_4) aufrufen, um sicherzustellen, dass GPIO 4 seinen Status beibehält (LOW) während des deep-sleep und die Flash-LED aus bleibt.
Danach setzen wir den Timer für den deep-sleep auf 5 Sekunden und starten den deep-sleep-Modus. Der ESP32 wacht nach 5 Sekunden automatisch auf und der Zyklus wiederholt sich.
Flash ausschalten beim Schreiben auf die SD-Karte
Wie bereits erwähnt teilen die Flash-LED und die SD-Karte die gleiche Signalleitung mit der Bezeichnung HS2_DATA1, und daher blinkt die LED kurz, wenn du auf die SD-Karte schreibst. Du kannst dies vermeiden, indem du den 1-Bit-Modus für das SD Card interface aktivierst:
SD_MMC.begin("/sdcard", true);
Das zweite Argument mode1bit==true, setzt den 1-Bit-Modus. In diesem Modus wird die HS2_DATA1 Leitung (GPIO 4) nicht verwendet und die LED wird beim Schreiben auf die SD-Karte nicht blinken. Zwar ist die Schreibgeschwindigkeit langsamer, aber du kannst nun GPIO 4 frei steuern, da er dann nur noch von der LED verwendet wird.
Du kannst das mit folgendem Testcode ausprobieren. Er schaltet die LED aus und schreibt zehnmal eine Datei:
#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() { }
Mit SD_MMC.begin(), wird die LED eingeschaltet (trotz Einstellung auf aus), sobald der Code beginnt, die Dateien zu schreiben. Mit SD_MMC.begin("/sdcard", true) hingegen ist die LED aus und bleibt aus.
Fazit
In diesem Tutorial hast du gelernt, wie man die Flash-LED des ESP32-CAM in verschiedenen Szenarien steuert, insbesondere in Kombination mit deep-sleep und SD-Karten-Unterstützung.
Es lohnt sich zu erwähnen, dass du vermeiden solltest, die Flash-LED über längere Zeit eingeschaltet zu lassen. Das Schaltbild zeigt, dass kein Vorwiderstand für die LED vorhanden ist. Das bedeutet, sie kann leicht überhitzen und durchbrennen.
Wenn du grundlegende Informationen zum ESP32-CAM brauchst, sieh dir das Programming the ESP32-CAM Tutorial an. Wenn du das Gelernte anwenden möchtest, um eine bewegungsaktivierte Kamera zu bauen, siehe das Motion Activated ESP32-CAM Tutorial. Und schließlich, wenn du das ESP32-CAM für die Objekterkennung verwenden willst, ist das Object Detection with ESP32-CAM and YOLO hilfreich.
Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.
Viel Spaß beim Basteln ; )
