Auf YouTube ansehen

ESP32 Tutorial 42/55 - Foto mit Kamera aufnehmen und auf Micro SD speichern CAM-1 | SunFounder's ESP32 Kit

In diesem Tutorial werden wir den ESP32-Mikrocontroller zusammen mit seinem Erweiterungsboard von SunFounder verwenden, um Fotos mit einer Kamera aufzunehmen und diese direkt auf einer microSD-Karte zu speichern. Dieses Projekt nutzt die integrierten Funktionen des ESP32, einschließlich Wi-Fi und Bluetooth, um ein kompaktes Fotografie-Gerät zu schaffen. Am Ende dieses Tutorials werden Sie eine funktionierende Einrichtung haben, die Bilder aufnehmen und speichern kann, die später auf einem Computer abgerufen werden können.

Für diejenigen, die neu im ESP32-Ökosystem sind, bietet dieses Kit eine vielseitige Plattform für verschiedene Projekte, einschließlich dieses hier. Die in diesem Projekt verwendete Kamera ist die OV2640, die eine Auflösung von 1600x1200 Pixeln bietet. Auch wenn sie nicht mit der Qualität moderner Smartphones mithalten kann, reicht sie für grundlegende Aufnahmeaufgaben aus. Um eventuelle Schritte zu klären, sollten Sie das Video zu diesem Tutorial überprüfen (im Video bei 00:00).

Hardware erklärt

Die Hauptkomponenten dieses Projekts sind der ESP32-Mikrocontroller, das Kameramodul (OV2640) und eine micro SD-Karte zur Speicherung. Der ESP32 ist ein leistungsstarker Mikrocontroller mit integrierten Wi-Fi- und Bluetooth-Funktionen, was ihn ideal für IoT-Anwendungen macht. Das Kameramodul erfasst Bilder, die dann vom ESP32 verarbeitet werden.

Die micro SD-Karte dient als Speichermedium für die aufgenommenen Bilder. In diesem Aufbau kommuniziert der ESP32 mit dem Kameramodul über spezifische GPIO-Pins, und die Bilder werden im JPEG-Format auf der SD-Karte gespeichert. Dies ermöglicht eine einfache Abfrage und Anzeige der Fotos später.

• Stellen Sie sicher, dass die Kamera beim Einfügen in die ESP32-Platine korrekt ausgerichtet ist.
• Verwenden Sie eine microSD-Karte mit einer Kapazität von 32 GB oder weniger, um Kompatibilitätsprobleme zu vermeiden.
• Verbinden Sie GPIO 0 mit GND für den Programmiermodus.
• Achten Sie auf die Stromversorgung, um Probleme mit braunem Strom zu vermeiden.
• Halten Sie die Kamera während der Aufnahme von Fotos ruhig, um verschwommene Bilder zu vermeiden.

Verdrahtungsanweisungen

Um das ESP32-Kameramodul zu verdrahten, stelle zunächst sicher, dass das ESP32 ausgeschaltet ist. Verbinde das micro SD-Kartenmodul mit dem ESP32 unter Verwendung der folgenden Pins: verbinde dieCSPin der SD-Karte an den ESP32GPIO 5,MOSIzuGPIO 23,MISOzuGPIO 19, undSCKzuGPIO 18. Verbinden Sie als Nächstes die Pins des Kameramoduls wie folgt:PWDNzuGPIO 32,XCLKzuGPIO 0,SIODzuGPIO 26, undSIOCzuGPIO 27. Die Pixeldaten-PinsY2zuY9sollte verbunden sein mitGPIO 5durchGPIO 39wie in Ihrem Code definiert.

Stellen Sie sicher, dass Sie die Erd- und Strompins entsprechend verbinden. Der ESP32 kann mit der im Kit enthaltenen Batterie betrieben werden. Überprüfen Sie nach dem Verdrahten, ob die Verbindungen sicher sind, bevor Sie das Gerät einschalten. Wenn Sie die Anweisungen genau befolgen, sollten Sie sehen, dass die Kamera korrekt initialisiert, wenn Sie den Code hochladen.

Codebeispiele und Schritt-für-Schritt-Anleitungen

Im Code beginnen wir mit der Einbindung notwendiger Bibliotheken und der Definition der Kamera-Pin-Konfigurationen. Die VariablepictureNumberwird initialisiert, um die Anzahl der aufgenommenen Fotos zu verfolgen.

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Disable brownout detector
  Serial.begin(115200);
  camera_config_t config;
  // Configuration settings for the camera
  config.ledc_channel = LEDC_CHANNEL_0;
  // Additional camera settings...
}

Die Setup-Funktion initialisiert die serielle Kommunikation und konfiguriert die Kameraeinstellungen. Die Konfiguration umfasst Parameter wieledc_channel,pin_d0, undxclk_freq_hzfür optimale Leistung.

Als Nächstes entfernen wir den Bildaufnahmeprozess, indem wir eine Schleife verwenden, um mehrere Bilder zu machen. Die Bilddaten werden auf der SD-Karte mit einem Dateinamen gespeichert, der auf derpictureNumber.

for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = esp_camera_fb_get(); // Take Picture
    String path = "/picture" + String(pictureNumber) + ".jpg"; // File path
    File file = fs.open(path.c_str(), FILE_WRITE); // Open file to write
    // Write image data to file
    file.write(fb->buf, fb->len);
    // Update picture number in EEPROM
    EEPROM.write(0, pictureNumber);
}

Diese Schleife erfasst bis zu fünf Bilder, wobei jedes Bild mit einem einzigartigen Dateinamen gespeichert wird. Die Verwendung von EEPROM ermöglicht es dem Programm, die letzte Bildnummer zu merken, wodurch sichergestellt wird, dass jedes neue Bild einen einzigartigen Identifikator hat.

Demonstration / Was zu erwarten ist

Wenn Sie den Code ausführen, wird der ESP32 die Kamera und die SD-Karte initialisieren. Nach dem Drücken der Reset-Taste am ESP32 wird er eine Reihe von Bildern aufnehmen, die basierend auf dem EEPROM-Wert fortlaufend von 0 bis 255 nummeriert sind. Nachdem die Bilder aufgenommen wurden, können Sie die micro SD-Karte entfernen und die Bilder auf Ihrem Computer anzeigen.

Zu den häufigsten Fallstricken gehört, sicherzustellen, dass die micro SD-Karte ordnungsgemäß formatiert und eingesetzt ist, sowie eine stabile Kameraposition beizubehalten, um verschwommene Bilder zu vermeiden. Wenn Sie Probleme haben, dass die Kamera keine Bilder aufnimmt, überprüfen Sie die Verkabelung und die Konfigurationen im Code (im Video um 06:45).

Video-Zeitstempel

• 00:00 Beginn
• 1:39 Einführung
• 5:19 ESP32 Kamera-Code erklärt
• 11:10 Auswahl des ESP32-Boards und des COM-Ports in der Arduino IDE
• 12:52 Fotos drinnen und draußen machen Test

Bilder

esp32-41-setting-3

extension_bopard_camera

20240103_163227858_iOS

esp32-41-setting-1

esp32-41-setting-2

esp32-41-setting-3

extension_bopard_camera

20240103_163227858_iOS

esp32-41-setting-1

esp32-41-setting-2

/*
 * Rui Santos  
 * Vollständige Projektdetails unter https://RandomNerdTutorials.com/esp32-cam-take-photo-save-microsd-card  
 * 
 * WICHTIG!!!  
 * - Wählen Sie das Board "AI Thinker ESP32-CAM"  
 * - GPIO 0 muss mit GND verbunden sein, um ein Sketch hochzuladen  
 * - Nachdem GPIO 0 mit GND verbunden wurde, drücken Sie die RESET-Taste auf dem ESP32-CAM-Board, um Ihr Board in den Flash-Modus zu versetzen  
 * 
 * Die Erlaubnis wird hiermit kostenlos jeder Person erteilt, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien erhält.  
 * Der obige Copyright-Hinweis und dieser Genehmigungshinweis sind in allen Kopien oder wesentlichen Teilen der Software einzuschließen.
 */
#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h" // SD-Karte ESP32
#include "SD_MMC.h" // SD-Karte ESP32
#include "soc/soc.h" // Deaktivieren Sie Brownour-Probleme.
#include "soc/rtc_cntl_reg.h" // Deaktivieren Sie Brownour-Probleme.
#include "driver/rtc_io.h"
#include <EEPROM.h> // Von Flash-Speicher lesen und schreiben

 // definieren Sie die Anzahl der Bytes, auf die Sie zugreifen möchten
#define EEPROM_SIZE 1

 // Pin-Definition für 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); // Deaktivieren Sie den Brownout-Detektor

  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;
  }

 // Kamera initialisieren
  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("Starte SD-Karte");
  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;
  }

 // EEPROM mit vordefinierter Größe initialisieren
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;

  for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = NULL;

 // Foto mit Kamera aufnehmen
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

 // Pfad, wo das neue Bild auf der SD-Karte gespeichert wird
    String path = "/picture" + String(pictureNumber) + ".jpg";

    fs::FS &fs = SD_MMC;
 // Serial.printf("Bilddateiname: %s\n", 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); // Bilddaten in eine Datei schreiben
      if (shoot == 4) {
        Serial.printf("Saved file to path: %s\n", path.c_str());
      }else{
        Serial.printf("Shooting... \n");
      }
      EEPROM.write(0, pictureNumber); // Aktualisieren Sie die Bildnummer im EEPROM
      EEPROM.commit();
    }
    file.close(); // Schließe die Datei
    esp_camera_fb_return(fb); // Geben Sie den Framebuffer an den Kameratreiber zurück.
    delay(200); // Kurze Verzögerung zwischen den Aufnahmen
  }
 // Schaltet die weiße integrierte LED (Blitz) des ESP32-CAM aus, die an GPIO 4 angeschlossen ist.
  pinMode(4, OUTPUT);
  digitalWrite(4, LOW);
  rtc_gpio_hold_en(GPIO_NUM_4);

 // Versetzen Sie das ESP32-CAM in den Tiefschlaf.
  delay(2000);
  Serial.println("Going to sleep now");
  delay(2000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop() {
 // Leere Schleife, da wir das ESP32-CAM in den Tiefschlaf versetzen.
}