Tutorial ESP32 42/55 - Mengambil Foto dengan Kamera simpan di Micro SD CAM-1 | Kit ESP32 SunFounder
Dalam tutorial ini, kita akan menggunakan mikrokontroler ESP32 beserta papan ekstensinya dari SunFounder untuk mengambil foto menggunakan kamera dan menyimpannya langsung ke kartu micro SD. Proyek ini memanfaatkan kemampuan bawaan ESP32, termasuk Wi-Fi dan Bluetooth, untuk membuat perangkat pengambil foto yang ringkas. Di akhir tutorial ini, Anda akan memiliki pengaturan yang berfungsi untuk mengambil dan menyimpan gambar, yang nantinya dapat diakses di komputer.
Bagi Anda yang baru mengenal ekosistem ESP32, kit ini menyediakan platform serbaguna untuk berbagai proyek, termasuk proyek ini. Kamera yang digunakan dalam proyek ini adalah OV2640, yang menawarkan resolusi 1600x1200 piksel. Meskipun mungkin tidak sebanding dengan kualitas ponsel pintar modern, kamera ini cukup untuk tugas pengambilan gambar dasar. Untuk memperjelas setiap langkah, pastikan untuk menonton video yang menyertai tutorial ini (di video pada 00:00).
Penjelasan Perangkat Keras
Komponen utama dalam proyek ini meliputi mikrokontroler ESP32, modul kamera (OV2640), dan kartu micro SD untuk penyimpanan. ESP32 adalah mikrokontroler yang kuat dengan kemampuan Wi-Fi dan Bluetooth terintegrasi, menjadikannya ideal untuk aplikasi IoT. Modul kamera menangkap gambar, yang kemudian diproses oleh ESP32.
Kartu micro SD berfungsi sebagai media penyimpanan untuk gambar yang ditangkap. Dalam pengaturan ini, ESP32 berkomunikasi dengan modul kamera menggunakan pin GPIO tertentu, dan gambar disimpan dalam format JPEG di kartu SD. Ini memungkinkan pengambilan dan penampilan foto dengan mudah nantinya.
- Pastikan kamera terorientasi dengan benar saat memasangnya ke papan ESP32.
- Gunakan kartu micro SD dengan kapasitas 32 GB atau kurang untuk menghindari masalah kompatibilitas.
- Hubungkan GPIO 0 ke GND untuk mode pemrograman.
- Perhatikan catu daya untuk menghindari masalah brownout.
- Jaga kamera tetap stabil saat mengambil foto untuk menghindari gambar buram.
Instruksi Pengkabelan
Untuk mengkabel modul kamera ESP32, pertama pastikan ESP32 dalam keadaan mati. Hubungkan modul kartu micro SD ke ESP32 menggunakan pin berikut: hubungkan pin CS kartu SD ke GPIO 5 ESP32, MOSI ke GPIO 23, MISO ke GPIO 19, dan SCK ke GPIO 18. Selanjutnya, hubungkan pin modul kamera sebagai berikut: PWDN ke GPIO 32, XCLK ke GPIO 0, SIOD ke GPIO 26, dan SIOC ke GPIO 27. Pin data piksel Y2 hingga Y9 harus dihubungkan ke GPIO 5 hingga GPIO 39 seperti yang didefinisikan dalam kode Anda.
Pastikan untuk menghubungkan pin ground dan daya dengan benar. ESP32 dapat diberi daya oleh baterai yang disertakan dalam kit. Setelah pengkabelan, pastikan koneksi aman sebelum menyalakan perangkat. Jika Anda mengikuti instruksi dengan cermat, Anda akan melihat kamera melakukan inisialisasi dengan benar saat Anda mengunggah kode.
Contoh Kode & Penjelasan
Dalam kode, kita mulai dengan menyertakan pustaka yang diperlukan dan mendefinisikan konfigurasi pin kamera. Variabel pictureNumber diinisialisasi untuk melacak jumlah foto yang diambil.
int pictureNumber = 0;
void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // Nonaktifkan detektor brownout
Serial.begin(115200);
camera_config_t config;
// Pengaturan konfigurasi untuk kamera
config.ledc_channel = LEDC_CHANNEL_0;
// Pengaturan kamera tambahan...
}Fungsi setup menginisialisasi komunikasi serial dan mengonfigurasi pengaturan kamera. Konfigurasi mencakup parameter seperti ledc_channel, pin_d0, dan xclk_freq_hz untuk kinerja optimal.
Selanjutnya, kita menangani proses pengambilan gambar dengan menggunakan loop untuk mengambil beberapa foto. Data gambar disimpan ke kartu SD dengan nama file berdasarkan pictureNumber.
for (int shoot = 0; shoot < 5; shoot++) {
camera_fb_t *fb = esp_camera_fb_get(); // Ambil Gambar
String path = "/picture" + String(pictureNumber) + ".jpg"; // Jalur file
File file = fs.open(path.c_str(), FILE_WRITE); // Buka file untuk menulis
// Tulis data gambar ke file
file.write(fb->buf, fb->len);
// Perbarui nomor gambar di EEPROM
EEPROM.write(0, pictureNumber);
}Loop ini menangkap hingga lima gambar, di mana setiap gambar disimpan dengan nama file yang unik. Penggunaan EEPROM memungkinkan program untuk mengingat nomor gambar terakhir, memastikan bahwa setiap gambar baru memiliki pengidentifikasi unik.
Demonstrasi / Apa yang Diharapkan
Saat Anda menjalankan kode tersebut, ESP32 akan menginisialisasi kamera dan kartu SD. Setelah menekan tombol reset pada ESP32, kamera akan mengambil serangkaian foto, yang akan diberi nomor secara berurutan dari 0 hingga 255 berdasarkan nilai EEPROM. Setelah mengambil gambar, Anda dapat melepas kartu micro SD dan melihat foto-foto tersebut di komputer Anda.
Kesalahan umum yang sering terjadi meliputi memastikan kartu micro SD diformat dengan benar dan dimasukkan dengan baik, serta menjaga posisi kamera tetap stabil untuk menghindari gambar buram. Jika Anda mengalami masalah dengan kamera yang tidak mengambil gambar, periksa kembali kabel dan konfigurasi yang diatur dalam kode (di video pada menit 06:45).
Stempel Waktu Video
- 00:00 Mulai
- 1:39 Pendahuluan
- 5:19 Penjelasan Kode Kamera ESP32
- 11:10 Memilih papan ESP32 dan port COM di Arduino IDE
- 12:52 Mengambil foto uji di dalam dan luar ruangan
Gambar
/*********
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
Sumber daya & referensi
-
DokumentasiESP32 Tutorial 42/55 - SunFounder doc page for taking photodocs.sunfounder.com
Berkas📁
Tidak ada file tersedia.
