ESP32 Tutoriaal 42/55 - Neem 'n Foto met Kamera en stoor op Micro SD CAM-1 | SunFounder se ESP32-stel
In hierdie tutoriaal gaan ons die ESP32-mikrobeheerder saam met sy uitbreidingsbord van SunFounder gebruik om foto's met 'n kamera te neem en dit direk op 'n mikro-SD-kaart te stoor. Hierdie projek gebruik die ingeboude vermoëns van die ESP32, insluitend Wi-Fi en Bluetooth, om 'n kompakte foto-neemtoestel te skep. Teen die einde van hierdie tutoriaal sal jy 'n werkende opstelling hê wat beelde kan neem en stoor, wat later op 'n rekenaar verkry kan word.
Vir diegene wat nuut is tot die ESP32-ekosisteem, bied hierdie stel 'n veelsydige platform vir verskeie projekte, insluitend hierdie een. Die kamera wat in hierdie projek gebruik word, is die OV2640, wat 'n resolusie van 1600x1200 pixels bied. Alhoewel dit dalk nie die kwaliteit van moderne slimfone ewenaar nie, is dit voldoende vir basiese beeldvangtake. Om enige stappe te verduidelik, maak seker dat jy die video wat hierdie tutoriaal vergesel, kyk (in video by 00:00).
Hardeware Verduidelik
Die hoofkomponente in hierdie projek sluit die ESP32-mikrobeheerder, die kameramodule (OV2640), en 'n mikro-SD-kaart vir berging in. Die ESP32 is 'n kragtige mikrobeheerder met geïntegreerde Wi-Fi- en Bluetooth-vermoëns, wat dit ideaal maak vir IoT-toepassings. Die kameramodule vang beelde vas, wat dan deur die ESP32 verwerk word.
Die mikro-SD-kaart dien as 'n bergingsmedium vir die vasgevangde beelde. In hierdie opstelling kommunikeer die ESP32 met die kameramodule deur spesifieke GPIO-penne te gebruik, en die beelde word in JPEG-formaat op die SD-kaart gestoor. Dit maak maklike herwinning en besigtiging van foto's later moontlik.
- Maak seker die kamera is korrek georiënteer wanneer dit in die ESP32-bord geplaas word.
- Gebruik 'n mikro-SD-kaart met 'n kapasiteit van 32 GB of minder om versoenbaarheidskwessies te vermy.
- Koppel GPIO 0 aan GND vir programmeringsmodus.
- Let op die kragtoevoer om bruinuitvalprobleme te vermy.
- Hou die kamera stil terwyl jy foto's neem om vaag beelde te vermy.
Bedradingsinstruksies
Om die ESP32-kameramodule te bedraad, maak eers seker dat die ESP32 afgeskakel is. Koppel die mikro-SD-kaartmodule aan die ESP32 deur die volgende penne te gebruik: koppel die CS-pen van die SD-kaart aan die ESP32 se GPIO 5, MOSI aan GPIO 23, MISO aan GPIO 19, en SCK aan GPIO 18. Koppel dan die kameramodule-penne soos volg: PWDN aan GPIO 32, XCLK aan GPIO 0, SIOD aan GPIO 26, en SIOC aan GPIO 27. Die pixeldata-penne Y2 tot Y9 moet aan GPIO 5 deur GPIO 39 gekoppel word soos in jou kode gedefinieer.
Maak seker dat jy die grond- en kragpenne toepaslik koppel. Die ESP32 kan deur die battery wat in die stel ingesluit is, aangedryf word. Na bedrading, maak seker dat die verbindings veilig is voordat jy die toestel aanskakel. As jy die instruksies noukeurig volg, behoort jy te sien dat die kamera korrek initialiseer wanneer jy die kode oplaai.
Kode Voorbeelde & Deurloop
In die kode begin ons deur nodige biblioteke in te sluit en kamerapenkonfigurasies te definieer. Die veranderlike pictureNumber word geïnisialiseer om tred te hou met die aantal foto's wat geneem is.
int pictureNumber = 0;
void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // Skakel bruinuitvaldetektor af
Serial.begin(115200);
camera_config_t config;
// Konfigurasie-instellings vir die kamera
config.ledc_channel = LEDC_CHANNEL_0;
// Bykomende kamerainstellings...
}Die setup-funksie initialiseer die seriekommunikasie en konfigureer die kamerainstellings. Die konfigurasie sluit parameters soos ledc_channel, pin_d0, en xclk_freq_hz in vir optimale werkverrigting.
Volgende hanteer ons die beeldvangproses deur 'n lus te gebruik om verskeie foto's te neem. Die beelddata word op die SD-kaart gestoor met 'n lêernaam gebaseer op die pictureNumber.
for (int shoot = 0; shoot < 5; shoot++) {
camera_fb_t *fb = esp_camera_fb_get(); // Neem foto
String path = "/picture" + String(pictureNumber) + ".jpg"; // Lêerpad
File file = fs.open(path.c_str(), FILE_WRITE); // Open lêer om te skryf
// Skryf beelddata na lêer
file.write(fb->buf, fb->len);
// Dateer fotonommer in EEPROM op
EEPROM.write(0, pictureNumber);
}Hierdie lus vang tot vyf beelde vas, waar elke beeld met 'n unieke lêernaam gestoor word. Die gebruik van EEPROM laat die program toe om die laaste fotonommer te onthou, wat verseker dat elke nuwe beeld 'n unieke identifiseerder het.
Demonstrasie / Wat om te Verwacht
Wanneer jy die kode laat loop, sal die ESP32 die kamera en die SD-kaart initialiseer. Nadat jy die reset-knoppie op die ESP32 gedruk het, sal dit 'n reeks foto's neem, wat opeenvolgend van 0 tot 255 genommer sal word op grond van die EEPROM-waarde. Nadat jy die beelde vasgelê het, kan jy die mikro SD-kaart verwyder en die foto's op jou rekenaar bekyk.
Algemene slaggate sluit in om te verseker dat die mikro SD-kaart behoorlik geformateer en ingesit is, sowel as om 'n stabiele kameraposisie te handhaaf om vaag beelde te vermy. As jy probleme ondervind met die kamera wat nie beelde vaslê nie, kontroleer die bedrading en konfigurasies wat in die kode gestel is (in video by 06:45).
Video Tydstempels
- 00:00 Begin
- 1:39 Inleiding
- 5:19 ESP32 Kamera-kode verduidelik
- 11:10 Kies ESP32-bord en COM-poort in Arduino IDE
- 12:52 Neem foto's binne en buite toets
Beelde
/*********
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
Hulpbronne en verwysings
-
DokumentasieESP32 Tutorial 42/55- SunFounder doc page taking photodocs.sunfounder.com
Lêers📁
Geen lêers beskikbaar.
