Návod ESP32 42/55 – Fotografovanie fotoaparátom a uloženie na Micro SD CAM-1 | SunFounder ESP32 kit

Návod ESP32 42/55 – Fotografovanie fotoaparátom a uloženie na Micro SD CAM-1 | SunFounder ESP32 kit

V tomto návode budeme používať mikrokontrolér ESP32 spolu s jeho rozširujúcou doskou od SunFounder na snímanie fotografií pomocou kamery a ich priame ukladanie na micro SD kartu. Tento projekt využíva vstavané funkcie ESP32, vrátane Wi-Fi a Bluetooth, na vytvorenie kompaktného zariadenia na fotografovanie. Na konci tohto návodu budete mať funkčné zariadenie, ktoré dokáže snímať a ukladať obrázky, ktoré môžete neskôr otvoriť na počítači.

Pre tých, ktorí sú noví v ekosystéme ESP32, táto súprava poskytuje všestrannú platformu pre rôzne projekty, vrátane tohto. Kamera použitá v tomto projekte je OV2640, ktorá ponúka rozlíšenie 1600x1200 pixelov. Hoci nemusí dosahovať kvalitu moderných smartfónov, je dostatočná na základné snímanie obrázkov. Ak potrebujete objasniť niektoré kroky, pozrite si video sprevádzajúce tento návod (vo videu o 00:00).

Vysvetlenie hardvéru

Hlavné komponenty v tomto projekte zahŕňajú mikrokontrolér ESP32, modul kamery (OV2640) a micro SD kartu na ukladanie. ESP32 je výkonný mikrokontrolér s integrovanými funkciami Wi-Fi a Bluetooth, čo ho robí ideálnym pre IoT aplikácie. Modul kamery sníma obrázky, ktoré potom spracúva ESP32.

Micro SD karta slúži ako úložisko pre nasnímané obrázky. V tomto zapojení ESP32 komunikuje s modulom kamery pomocou špecifických GPIO pinov a obrázky sa ukladajú vo formáte JPEG na SD kartu. To umožňuje neskoršie jednoduché vybratie a prezeranie fotografií.

• Uistite sa, že kamera je správne orientovaná pri vkladaní do dosky ESP32.
• Použite micro SD kartu s kapacitou 32 GB alebo menej, aby ste predišli problémom s kompatibilitou.
• Pripojte GPIO 0 na GND pre programovací režim.
• Venujte pozornosť napájaniu, aby ste predišli problémom s poklesom napätia.
• Pri fotografovaní držte kameru stabilne, aby ste predišli rozmazaným obrázkom.

Pokyny na zapojenie

Na zapojenie modulu kamery ESP32 najprv uistite sa, že ESP32 je vypnutý. Pripojte modul micro SD karty k ESP32 pomocou nasledujúcich pinov: pripojte pin CS SD karty na GPIO 5 ESP32, MOSI na GPIO 23, MISO na GPIO 19 a SCK na GPIO 18. Potom pripojte piny modulu kamery nasledovne: PWDN na GPIO 32, XCLK na GPIO 0, SIOD na GPIO 26 a SIOC na GPIO 27. Piny pixelových dát Y2 až Y9 by mali byť pripojené na GPIO 5 až GPIO 39, ako je definované vo vašom kóde.

Uistite sa, že správne pripojíte uzemňovacie a napájacie piny. ESP32 môže byť napájaný batériou, ktorá je súčasťou súpravy. Po zapojení skontrolujte, či sú spojenia pevné, pred zapnutím zariadenia. Ak budete presne postupovať podľa pokynov, po nahraní kódu by ste mali vidieť, že sa kamera správne inicializuje.

Príklady kódu a vysvetlenie

V kóde začneme zahrnutím potrebných knižníc a definovaním konfigurácie pinov kamery. Premenná pictureNumber je inicializovaná na sledovanie počtu nasnímaných fotografií.

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Vypnutie detektora poklesu napätia
  Serial.begin(115200);
  camera_config_t config;
  // Nastavenia konfigurácie pre kameru
  config.ledc_channel = LEDC_CHANNEL_0;
  // Ďalšie nastavenia kamery...
}

Funkcia setup inicializuje sériovú komunikáciu a konfiguruje nastavenia kamery. Konfigurácia zahŕňa parametre ako ledc_channel, pin_d0 a xclk_freq_hz pre optimálny výkon.

Ďalej spracúvame proces snímania obrázkov pomocou cyklu na nasnímanie viacerých fotografií. Dáta obrázka sa ukladajú na SD kartu s názvom súboru založeným na pictureNumber.

for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = esp_camera_fb_get(); // Nasnímanie fotografie
    String path = "/picture" + String(pictureNumber) + ".jpg"; // Cesta k súboru
    File file = fs.open(path.c_str(), FILE_WRITE); // Otvorenie súboru na zápis
    // Zápis dát obrázka do súboru
    file.write(fb->buf, fb->len);
    // Aktualizácia čísla obrázka v EEPROM
    EEPROM.write(0, pictureNumber);
}

Tento cyklus nasníma až päť obrázkov, pričom každý obrázok sa uloží s jedinečným názvom súboru. Použitie EEPROM umožňuje programu zapamätať si posledné číslo obrázka, čím sa zabezpečí, že každý nový obrázok bude mať jedinečný identifikátor.

Demonštrácia / Čo očakávať

Keď spustíte kód, ESP32 inicializuje kameru a SD kartu. Po stlačení resetovacieho tlačidla na ESP32 nasníma sériu obrázkov, ktoré budú očíslované postupne od 0 do 255 na základe hodnoty EEPROM. Po nasnímaní obrázkov môžete vybrať micro SD kartu a prezrieť si obrázky na počítači.

Medzi časté chyby patrí zabezpečenie správneho naformátovania a vloženia micro SD karty, ako aj udržiavanie stabilnej polohy kamery, aby ste sa vyhli rozmazaným obrázkom. Ak narazíte na problémy s tým, že kamera nezachytáva obrázky, skontrolujte zapojenie a konfigurácie nastavené v kóde (vo videu v čase 06:45).

Časové značky videa

• 00:00 Začiatok
• 1:39 Úvod
• 5:19 Vysvetlenie kódu ESP32 Camera
• 11:10 Výber dosky ESP32 a COM portu v Arduino IDE
• 12:52 Fotografovanie – test v interiéri a exteriéri

Obrázky

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
}