ESP32 Tutorijal 42/55 - Fotografisanje kamerom i čuvanje na Micro SD CAM-1 | SunFounder's ESP32 komplet

ESP32 Tutorijal 42/55 - Fotografisanje kamerom i čuvanje na Micro SD CAM-1 | SunFounder's ESP32 komplet

U ovom tutorijalu koristit ćemo ESP32 mikrokontroler zajedno s njegovom proširujućom pločom kompanije SunFounder za snimanje fotografija pomoću kamere i njihovo direktno spremanje na micro SD karticu. Ovaj projekat koristi ugrađene mogućnosti ESP32-a, uključujući Wi-Fi i Bluetooth, za kreiranje kompaktnog uređaja za fotografisanje. Do kraja ovog tutorijala imat ćete funkcionalnu postavku koja može snimati i pohranjivati slike, kojima kasnije možete pristupiti na računaru.

Za one koji su novi u ESP32 ekosistemu, ovaj komplet pruža svestranu platformu za različite projekte, uključujući i ovaj. Kamera koja se koristi u ovom projektu je OV2640, koja nudi rezoluciju od 1600x1200 piksela. Iako možda neće dostići kvalitet modernih pametnih telefona, dovoljna je za osnovne zadatke snimanja slika. Da biste razjasnili bilo koje korake, obavezno pogledajte video koji prati ovaj tutorijal (u videu na 00:00).

Objašnjenje hardvera

Glavne komponente u ovom projektu uključuju ESP32 mikrokontroler, modul kamere (OV2640) i micro SD karticu za pohranu. ESP32 je moćan mikrokontroler s integriranim Wi-Fi i Bluetooth mogućnostima, što ga čini idealnim za IoT aplikacije. Modul kamere snima slike, koje zatim obrađuje ESP32.

Micro SD kartica služi kao medij za pohranu snimljenih slika. U ovoj postavci, ESP32 komunicira s modulom kamere koristeći specifične GPIO pinove, a slike se spremaju u JPEG formatu na SD karticu. To omogućava lako preuzimanje i pregled fotografija kasnije.

• Provjerite da je kamera pravilno orijentirana prilikom umetanja u ESP32 ploču.
• Koristite micro SD karticu kapaciteta 32 GB ili manje kako biste izbjegli probleme s kompatibilnošću.
• Spojite GPIO 0 na GND za programski način rada.
• Obratite pažnju na napajanje kako biste izbjegli probleme s nedostatkom napona.
• Držite kameru stabilnom prilikom fotografisanja kako biste izbjegli mutne slike.

Upute za povezivanje

Da biste povezali ESP32 modul kamere, prvo provjerite da je ESP32 isključen. Spojite modul micro SD kartice na ESP32 koristeći sljedeće pinove: spojite CS pin SD kartice na GPIO 5 ESP32-a, MOSI na GPIO 23, MISO na GPIO 19 i SCK na GPIO 18. Zatim spojite pinove modula kamere na sljedeći način: PWDN na GPIO 32, XCLK na GPIO 0, SIOD na GPIO 26 i SIOC na GPIO 27. Pinovi podataka piksela Y2 do Y9 trebaju biti spojeni na GPIO 5 do GPIO 39 kako je definirano u vašem kodu.

Obavezno pravilno spojite pinove za uzemljenje i napajanje. ESP32 se može napajati baterijom koja je uključena u komplet. Nakon povezivanja, provjerite da su veze sigurne prije uključivanja uređaja. Ako pažljivo slijedite upute, trebali biste vidjeti da se kamera pravilno inicijalizira kada prenesete kod.

Primjeri koda i objašnjenje

U kodu počinjemo uključivanjem potrebnih biblioteka i definiranjem konfiguracije pinova kamere. Varijabla pictureNumber se inicijalizira kako bi se pratilo koliko je fotografija snimljeno.

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Onemogući detektor smanjenog napona
  Serial.begin(115200);
  camera_config_t config;
  // Postavke konfiguracije za kameru
  config.ledc_channel = LEDC_CHANNEL_0;
  // Dodatne postavke kamere...
}

Setup funkcija inicijalizira serijsku komunikaciju i konfigurira postavke kamere. Konfiguracija uključuje parametre poput ledc_channel, pin_d0 i xclk_freq_hz za optimalne performanse.

Zatim obrađujemo proces snimanja slika koristeći petlju za snimanje više fotografija. Podaci slike se spremaju na SD karticu s imenom datoteke zasnovanim na pictureNumber.

for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = esp_camera_fb_get(); // Snimi sliku
    String path = "/picture" + String(pictureNumber) + ".jpg"; // Putanja datoteke
    File file = fs.open(path.c_str(), FILE_WRITE); // Otvori datoteku za pisanje
    // Zapiši podatke slike u datoteku
    file.write(fb->buf, fb->len);
    // Ažuriraj broj slike u EEPROM-u
    EEPROM.write(0, pictureNumber);
}

Ova petlja snima do pet slika, pri čemu se svaka slika sprema s jedinstvenim imenom datoteke. Korištenje EEPROM-a omogućava programu da zapamti posljednji broj slike, osiguravajući da svaka nova slika ima jedinstveni identifikator.

Demonstracija / Šta očekivati

Kada pokrenete kod, ESP32 će inicijalizirati kameru i SD karticu. Nakon pritiska na reset dugme na ESP32, snimit će niz slika, koje će biti numerisane redom od 0 do 255 na osnovu EEPROM vrijednosti. Nakon snimanja slika, možete izvaditi micro SD karticu i pregledati slike na računaru.

Uobičajene zamke uključuju osiguravanje da je micro SD kartica pravilno formatirana i umetnuta, kao i održavanje stabilne pozicije kamere kako biste izbjegli mutne slike. Ako naiđete na probleme s kamerom koja ne snima slike, provjerite ožičenje i konfiguracije postavljene u kodu (u videu na 06:45).

Vremenske oznake videa

• 00:00 Početak
• 1:39 Uvod
• 5:19 Objašnjen koda ESP32 kamere
• 11:10 Odabir ESP32 ploče i COM porta u Arduino IDE
• 12:52 Testiranje fotografisanja u zatvorenom i na otvorenom

Images

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
}