Guarda su YouTube

Tutorial ESP32 42/55 - Scattare foto con la fotocamera e salvarle su Micro SD CAM-1 | Kit ESP32 di SunFounder

In questo tutorial, utilizzeremo il microcontrollore ESP32 insieme alla sua scheda di estensione di SunFounder per catturare foto utilizzando una camera e salvarle direttamente su una scheda micro SD. Questo progetto sfrutta le capacità integrate dell'ESP32, inclusi Wi-Fi e Bluetooth, per creare un dispositivo compatto per la cattura di foto. Alla fine di questo tutorial, avrai un setup funzionante in grado di scattare e memorizzare immagini, accessibili successivamente su un computer.

Per coloro che sono nuovi all'ecosistema ESP32, questo kit offre una piattaforma versatile per vari progetti, incluso questo. La fotocamera utilizzata in questo progetto è la OV2640, che offre una risoluzione di 1600x1200 pixel. Anche se non può competere con la qualità degli smartphone moderni, è sufficiente per compiti di acquisizione immagini di base. Per chiarire eventuali passaggi, assicurati di controllare il video che accompagna questo tutorial (nel video alle 00:00).

Spiegazione dell'hardware

I componenti principali di questo progetto includono il microcontrollore ESP32, il modulo della fotocamera (OV2640) e una scheda micro SD per l'archiviazione. L'ESP32 è un potente microcontrollore con capacità integrate di Wi-Fi e Bluetooth, rendendolo ideale per le applicazioni IoT. Il modulo della fotocamera cattura immagini, che vengono poi elaborate dall'ESP32.

La scheda micro SD funge da supporto di memorizzazione per le immagini catturate. In questa configurazione, l'ESP32 comunica con il modulo della fotocamera utilizzando pin GPIO specifici, e le immagini vengono salvate in formato JPEG sulla scheda SD. Ciò consente un facile recupero e visualizzazione delle foto in seguito.

• Assicurati che la fotocamera sia correttamente orientata quando la inserisci nella scheda ESP32.
• Utilizzare una scheda micro SD con una capacità di 32 GB o inferiore per evitare problemi di compatibilità.
• Collegare GPIO 0 a GND per la modalità di programmazione.
• Fai attenzione all'alimentazione per evitare problemi di abbassamento di tensione.
• Tieni la macchina fotografica ferma mentre scatti foto per evitare immagini sfocate.

Istruzioni per il cablaggio

Per cablare il modulo fotocamera ESP32, assicurati innanzitutto che l'ESP32 sia spento. Collega il modulo della scheda micro SD all'ESP32 utilizzando i seguenti pin: collega ilCSpin della scheda SD all'ESP32GPIO 5,MOSIversoGPIO 23,MISOaGPIO 19, eSCKaGPIO 18Successivamente, collegare i pin del modulo della camera come segue:PWDNaGPIO 32,XCLKaGPIO 0,SIODaGPIO 26, eSIOCaGPIO 27. I pin dei dati pixelY2aY9dovrebbe essere collegato aGPIO 5attraversoGPIO 39come definito nel tuo codice.

Assicurati di collegare correttamente i pin di terra e di alimentazione. L'ESP32 può essere alimentato dalla batteria inclusa nel kit. Dopo aver effettuato il cablaggio, assicurati che le connessioni siano sicure prima di accendere il dispositivo. Se segui attentamente le istruzioni, dovresti vedere la camera inizializzarsi correttamente quando carichi il codice.

Esempi di codice e guida passo passo

Nel codice, iniziamo includendo le librerie necessarie e definendo le configurazioni dei pin della fotocamera. La variabilepictureNumberviene inizializzato per tenere traccia del numero di foto scattate.

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

La funzione di setup inizializza la comunicazione seriale e configura le impostazioni della fotocamera. La configurazione include parametri comeledc_channel,pin_d0, exclk_freq_hzper prestazioni ottimali.

Successivamente, gestiamo il processo di acquisizione delle immagini utilizzando un ciclo per scattare più foto. I dati dell'immagine vengono salvati sulla scheda SD con un nome file basato supictureNumber.

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

Questo ciclo cattura fino a cinque immagini, dove ciascuna immagine viene salvata con un nome file unico. L'uso della EEPROM consente al programma di ricordare l'ultimo numero dell'immagine, garantendo che ogni nuova immagine abbia un identificatore unico.

Dimostrazione / Cosa Aspettarsi

Quando esegui il codice, l'ESP32 inizializzerà la fotocamera e la scheda SD. Dopo aver premuto il pulsante di reset sull'ESP32, esso scatterà una serie di foto, numerate in sequenza da 0 a 255 in base al valore dell'EEPROM. Dopo aver catturato le immagini, puoi rimuovere la scheda micro SD e visualizzare le foto sul tuo computer.

Le insidie comuni includono garantire che la micro SD sia correttamente formattata e inserita, così come mantenere una posizione stabile della telecamera per evitare immagini sfocate. Se hai problemi con la telecamera che non cattura immagini, ricontrolla i cablaggi e le configurazioni impostate nel codice (nel video a 06:45).

Timestamp video

• 00:00 Inizio
• 1:39 Introduzione
• 5:19 Codice Camera ESP32 spiegato
• 11:10 Selezionare la scheda ESP32 e la porta COM nell'IDE di Arduino
• 12:52 Test di fotografia indoor e outdoor

Immagini

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
 * Dettagli completi del progetto su https://RandomNerdTutorials.com/esp32-cam-take-photo-save-microsd-card
 * 
 * IMPORTANTE!!!
 * - Seleziona la scheda "AI Thinker ESP32-CAM"
 * - GPIO 0 deve essere collegato a GND per caricare uno sketch
 * - Dopo aver collegato GPIO 0 a GND, premi il pulsante RESET sulla scheda ESP32-CAM per mettere la scheda in modalità di flashing
 * 
 * La presente autorizzazione è concessa, a titolo gratuito, a qualsiasi persona che ottenga una copia di questo software e dei relativi file di documentazione.
 * La suddetta nota di copyright e la presente autorizzazione dovranno essere incluse in tutte le copie o in porzioni sostanziali del Software.
 */
#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h" // Scheda SD ESP32
#include "SD_MMC.h" // Scheda SD ESP32
#include "soc/soc.h" // Disabilita i problemi di brunore.
#include "soc/rtc_cntl_reg.h" // Disabilita i problemi di brunore.
#include "driver/rtc_io.h"
#include <EEPROM.h> // leggere e scrivere dalla memoria flash

 // definisci il numero di byte che desideri accedere
#define EEPROM_SIZE 1

 // Definizione dei pin per 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); // disattivare il rilevatore di diminuzione di tensione

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

 // Iniziare la Fotocamera
  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("Avvio della scheda SD");
  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;
  }

 // inizializza EEPROM con dimensione predefinita
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;

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

 // Scatta foto con la fotocamera
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

 // Percorso in cui la nuova immagine sarà salvata nella scheda SD.
    String path = "/picture" + String(pictureNumber) + ".jpg";

    fs::FS &fs = SD_MMC;
 // Serial.printf("Nome del file immagine: %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); // Scrivi i dati dell'immagine su file
      if (shoot == 4) {
        Serial.printf("Saved file to path: %s\n", path.c_str());
      }else{
        Serial.printf("Shooting... \n");
      }
      EEPROM.write(0, pictureNumber); // Aggiorna il numero dell'immagine in EEPROM
      EEPROM.commit();
    }
    file.close(); // Chiudi il file
    esp_camera_fb_return(fb); // Restituisci il buffer del frame al driver della camera.
    delay(200); // Breve ritardo tra i colpi
  }
 // Disattiva il LED bianco integrato ESP32-CAM (flash) collegato a GPIO 4.
  pinMode(4, OUTPUT);
  digitalWrite(4, LOW);
  rtc_gpio_hold_en(GPIO_NUM_4);

 // Metti l'ESP32-CAM in modalità sleep profondo.
  delay(2000);
  Serial.println("Going to sleep now");
  delay(2000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop() {
 // Ciclo vuoto poiché stiamo mettendo l'ESP32-CAM in profondo sonno.
}