Tutorial ESP32 42/55 - Realizarea unei fotografii cu camera și salvarea pe Micro SD CAM-1 | Kitul ESP32 de la SunFounder
În acest tutorial, vom folosi microcontrolerul ESP32 împreună cu placa sa de extensie de la SunFounder pentru a captura fotografii folosind o cameră și a le salva direct pe un card micro SD. Acest proiect utilizează capacitățile integrate ale ESP32, inclusiv Wi-Fi și Bluetooth, pentru a crea un dispozitiv compact de fotografiat. Până la sfârșitul acestui tutorial, vei avea o configurație funcțională care poate face și stoca imagini, care pot fi accesate ulterior pe un computer.
Pentru cei care sunt noi în ecosistemul ESP32, acest kit oferă o platformă versatilă pentru diverse proiecte, inclusiv acesta. Camera folosită în acest proiect este OV2640, care oferă o rezoluție de 1600x1200 pixeli. Deși poate să nu se ridice la nivelul smartphone-urilor moderne, este suficientă pentru sarcini de bază de capturare a imaginilor. Pentru a clarifica orice pași, asigură-te că verifici videoclipul care însoțește acest tutorial (în videoclip la 00:00).
Hardware Explicat
Componentele principale din acest proiect includ microcontrolerul ESP32, modulul camerei (OV2640) și un card micro SD pentru stocare. ESP32 este un microcontroler puternic cu capacități integrate Wi-Fi și Bluetooth, fiind ideal pentru aplicații IoT. Modulul camerei capturează imagini, care sunt apoi procesate de ESP32.
Cardul micro SD acționează ca mediu de stocare pentru imaginile capturate. În această configurație, ESP32 comunică cu modulul camerei folosind pini GPIO specifici, iar imaginile sunt salvate în format JPEG pe cardul SD. Acest lucru permite recuperarea și vizualizarea ușoară a fotografiilor ulterior.
- Asigură-te că camera este orientată corect atunci când o introduci în placa ESP32.
- Folosește un card micro SD cu o capacitate de 32 GB sau mai mică pentru a evita problemele de compatibilitate.
- Conectează GPIO 0 la GND pentru modul de programare.
- Acordă atenție alimentării pentru a evita problemele de cădere de tensiune.
- Ține camera stabilă în timp ce faci fotografii pentru a evita imaginile neclare.
Instrucțiuni de Cablare
Pentru a cabla modulul camerei ESP32, asigură-te mai întâi că ESP32 este oprit. Conectează modulul cardului micro SD la ESP32 folosind următorii pini: conectează pinul CS al cardului SD la GPIO 5 al ESP32, MOSI la GPIO 23, MISO la GPIO 19 și SCK la GPIO 18. Apoi, conectează pinii modulului camerei astfel: PWDN la GPIO 32, XCLK la GPIO 0, SIOD la GPIO 26 și SIOC la GPIO 27. Pinii de date pentru pixeli Y2 până la Y9 ar trebui conectați la GPIO 5 până la GPIO 39 așa cum este definit în codul tău.
Asigură-te că conectezi pinii de masă și de alimentare în mod corespunzător. ESP32 poate fi alimentat de bateria inclusă în kit. După cablare, asigură-te că conexiunile sunt sigure înainte de a porni dispozitivul. Dacă urmezi instrucțiunile îndeaproape, ar trebui să vezi camera inițializându-se corect atunci când încarci codul.
Exemple de Cod și Ghid Pas cu Pas
În cod, începem prin a include bibliotecile necesare și a defini configurațiile pinilor camerei. Variabila pictureNumber este inițializată pentru a ține evidența numărului de fotografii făcute.
int pictureNumber = 0;
void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // Dezactivează detectorul de cădere de tensiune
Serial.begin(115200);
camera_config_t config;
// Setări de configurare pentru cameră
config.ledc_channel = LEDC_CHANNEL_0;
// Setări suplimentare pentru cameră...
}Funcția setup inițializează comunicarea serială și configurează setările camerei. Configurația include parametri precum ledc_channel, pin_d0 și xclk_freq_hz pentru performanță optimă.
În continuare, gestionăm procesul de capturare a imaginilor folosind o buclă pentru a face mai multe fotografii. Datele imaginii sunt salvate pe cardul SD cu un nume de fișier bazat pe pictureNumber.
for (int shoot = 0; shoot < 5; shoot++) {
camera_fb_t *fb = esp_camera_fb_get(); // Face o fotografie
String path = "/picture" + String(pictureNumber) + ".jpg"; // Calea fișierului
File file = fs.open(path.c_str(), FILE_WRITE); // Deschide fișierul pentru scriere
// Scrie datele imaginii în fișier
file.write(fb->buf, fb->len);
// Actualizează numărul fotografiei în EEPROM
EEPROM.write(0, pictureNumber);
}Această buclă capturează până la cinci imagini, fiecare imagine fiind salvată cu un nume de fișier unic. Utilizarea EEPROM permite programului să-și amintească ultimul număr de fotografie, asigurând că fiecare imagine nouă are un identificator unic.
Demonstrație / Ce să Te Aștepți
Când rulați codul, ESP32 va inițializa camera și cardul SD. După apăsarea butonului de reset de pe ESP32, acesta va face o serie de fotografii, care vor fi numerotate secvențial de la 0 la 255 pe baza valorii EEPROM. După capturarea imaginilor, puteți scoate cardul micro SD și puteți vizualiza fotografiile pe computer.
Capcanele frecvente includ asigurarea că cardul micro SD este formatat și introdus corect, precum și menținerea unei poziții stabile a camerei pentru a evita imaginile neclare. Dacă întâmpinați probleme cu camera care nu captează imagini, verificați din nou conexiunile și configurațiile setate în cod (în videoclip la 06:45).
Marcaje temporale video
- 00:00 Start
- 1:39 Introducere
- 5:19 Codul camerei ESP32 explicat
- 11:10 Selectarea plăcii ESP32 și a portului COM în Arduino IDE
- 12:52 Test de fotografiere în interior și exterior
Imagini
/*********
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
}Common Course Links
Common Course Files
Resurse și referințe
-
DocumentațieESP32 Tutorial 42/55- SunFounder doc page taking photodocs.sunfounder.com
Fișiere📁
Nu sunt disponibile fișiere.
