ESP32 Tutorial 42/55 - Foto maken met camera en opslaan op Micro SD CAM-1 | SunFounder's ESP32-kit

ESP32 Tutorial 42/55 - Foto maken met camera en opslaan op Micro SD CAM-1 | SunFounder's ESP32-kit

In deze tutorial gebruiken we de ESP32-microcontroller samen met de uitbreidingskaart van SunFounder om foto's te maken met een camera en deze direct op een micro-SD-kaart op te slaan. Dit project maakt gebruik van de ingebouwde mogelijkheden van de ESP32, waaronder Wi-Fi en Bluetooth, om een compact fototoestel te creëren. Aan het einde van deze tutorial heb je een werkende opstelling die afbeeldingen kan maken en opslaan, die later op een computer kunnen worden bekeken.

Voor degenen die nieuw zijn in het ESP32-ecosysteem: deze kit biedt een veelzijdig platform voor verschillende projecten, waaronder deze. De camera die in dit project wordt gebruikt is de OV2640, die een resolutie van 1600x1200 pixels biedt. Hoewel dit niet de kwaliteit van moderne smartphones evenaart, is het voldoende voor basale beeldopnametaken. Raadpleeg voor verduidelijking van eventuele stappen de video die bij deze tutorial hoort (in video op 00:00).

Hardware Uitgelegd

De belangrijkste componenten in dit project zijn de ESP32-microcontroller, de cameramodule (OV2640) en een micro-SD-kaart voor opslag. De ESP32 is een krachtige microcontroller met geïntegreerde Wi-Fi- en Bluetooth-mogelijkheden, waardoor deze ideaal is voor IoT-toepassingen. De cameramodule legt beelden vast, die vervolgens door de ESP32 worden verwerkt.

De micro-SD-kaart fungeert als opslagmedium voor de vastgelegde afbeeldingen. In deze opstelling communiceert de ESP32 met de cameramodule via specifieke GPIO-pinnen, en worden de afbeeldingen in JPEG-formaat op de SD-kaart opgeslagen. Dit maakt het later eenvoudig om foto's op te halen en te bekijken.

• Zorg ervoor dat de camera correct is georiënteerd bij het plaatsen in de ESP32-kaart.
• Gebruik een micro-SD-kaart met een capaciteit van 32 GB of minder om compatibiliteitsproblemen te voorkomen.
• Verbind GPIO 0 met GND voor de programmeermodus.
• Let op de voeding om brownout-problemen te voorkomen.
• Houd de camera stabiel tijdens het maken van foto's om onscherpe beelden te voorkomen.

Bekabelingsinstructies

Om de ESP32-cameramodule te bedraden, zorg je eerst dat de ESP32 is uitgeschakeld. Verbind de micro-SD-kaartmodule met de ESP32 met behulp van de volgende pinnen: verbind de CS-pin van de SD-kaart met GPIO 5 van de ESP32, MOSI met GPIO 23, MISO met GPIO 19 en SCK met GPIO 18. Verbind vervolgens de pinnen van de cameramodule als volgt: PWDN met GPIO 32, XCLK met GPIO 0, SIOD met GPIO 26 en SIOC met GPIO 27. De pixelgegevenspinnen Y2 tot en met Y9 moeten worden verbonden met GPIO 5 tot en met GPIO 39 zoals gedefinieerd in je code.

Zorg ervoor dat je de aard- en voedingspinnen op de juiste manier aansluit. De ESP32 kan worden gevoed door de batterij die in de kit zit. Controleer na het bedraden of alle verbindingen stevig zijn voordat je het apparaat inschakelt. Als je de instructies nauwkeurig volgt, zou je moeten zien dat de camera correct initialiseert wanneer je de code uploadt.

Codevoorbeelden & Uitleg

In de code beginnen we met het opnemen van de benodigde bibliotheken en het definiëren van de camerapinconfiguraties. De variabele pictureNumber wordt geïnitialiseerd om het aantal gemaakte foto's bij te houden.

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Brownout-detector uitschakelen
  Serial.begin(115200);
  camera_config_t config;
  // Configuratie-instellingen voor de camera
  config.ledc_channel = LEDC_CHANNEL_0;
  // Extra camera-instellingen...
}

De setup-functie initialiseert de seriële communicatie en configureert de camera-instellingen. De configuratie omvat parameters zoals ledc_channel, pin_d0 en xclk_freq_hz voor optimale prestaties.

Vervolgens behandelen we het beeldopnameproces door een lus te gebruiken om meerdere foto's te maken. De beeldgegevens worden opgeslagen op de SD-kaart met een bestandsnaam op basis van pictureNumber.

for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = esp_camera_fb_get(); // Foto maken
    String path = "/picture" + String(pictureNumber) + ".jpg"; // Bestandspad
    File file = fs.open(path.c_str(), FILE_WRITE); // Bestand openen om te schrijven
    // Beeldgegevens naar bestand schrijven
    file.write(fb->buf, fb->len);
    // Fotnummer bijwerken in EEPROM
    EEPROM.write(0, pictureNumber);
}

Deze lus maakt maximaal vijf afbeeldingen, waarbij elke afbeelding wordt opgeslagen met een unieke bestandsnaam. Het gebruik van EEPROM stelt het programma in staat om het laatste fotnummer te onthouden, zodat elke nieuwe afbeelding een unieke identificatie heeft.

Demonstratie / Wat te Verwachten

Wanneer u de code uitvoert, initialiseert de ESP32 de camera en de SD-kaart. Nadat u op de resetknop op de ESP32 hebt gedrukt, maakt het een reeks foto's, die opeenvolgend worden genummerd van 0 tot 255 op basis van de EEPROM-waarde. Na het vastleggen van de afbeeldingen kunt u de micro SD-kaart verwijderen en de foto's op uw computer bekijken.

Veelvoorkomende valkuilen zijn onder meer ervoor zorgen dat de micro SD-kaart correct is geformatteerd en geplaatst, en het handhaven van een stabiele camerapositie om onscherpe afbeeldingen te voorkomen. Als u problemen ondervindt waarbij de camera geen afbeeldingen vastlegt, controleer dan de bedrading en configuraties die in de code zijn ingesteld (in de video op 06:45).

Videotijdstempels

• 00:00 Start
• 1:39 Introductie
• 5:19 ESP32 Camera-code uitgelegd
• 11:10 ESP32-board en COM-poort selecteren in Arduino IDE
• 12:52 Foto's maken binnen- en buitentest

Afbeeldingen

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
  Complete project details at https://RandomNerdTutorials.com/esp32-cam-take-photo-save-microsd-card
  
  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

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

  // 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");
  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;
  }

  // initialize EEPROM with predefined size
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;

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

    // Take Picture with Camera
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

    // 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: %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);  // Write image data to file
      if (shoot == 4) {
        Serial.printf("Saved file to path: %s\n", path.c_str());
      }else{
        Serial.printf("Shooting... \n");
      }
      EEPROM.write(0, pictureNumber);  // Update the picture number in EEPROM
      EEPROM.commit();
    }
    file.close();                      // Close the file
    esp_camera_fb_return(fb);          // Return the frame buffer back to the camera driver
    delay(200);                        // Short delay between shots
  }
  // 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);

  // Put the ESP32-CAM to deep sleep
  delay(2000);
  Serial.println("Going to sleep now");
  delay(2000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop() {
  // Empty loop as we are putting the ESP32-CAM to deep sleep
}