Tutorial ESP32-CAM: Pengaturan, Pemrograman, Live Stream, dan Kartu SD

ESP32-CAM adalah board kamera Wi-Fi yang terjangkau dan, walaupun ukurannya hanya 27 × 40 mm, membawa prosesor ESP32, kamera OV2640 2 megapiksel, slot kartu microSD, dan LED flash putih. Board ini bisa bergabung sendiri ke jaringan rumahmu, mengirim video langsung ke browser, mengambil foto, lalu menyimpannya ke kartu SD atau mengirimnya lewat internet. Board ini jadi andalan untuk kamera keamanan, kamera bel pintu, time-lapse pertumbuhan tanaman, dan mobil robot berkamera, tetapi karena tidak punya soket USB, cara memulainya sedikit berbeda dari board ESP32 yang mungkin sudah biasa kamu pakai.

Di panduan ini kamu akan mempelajari pinout ESP32-CAM AI-Thinker, cara memprogramnya dengan adaptor ESP32-CAM-MB atau adaptor USB-TTL (termasuk sambungan IO0-GND), cara mendapat gambar langsung di browser dengan contoh siap pakai CameraWebServer, dan pengaturan PSRAM serta partisi yang dipakai. Setelah itu kamu akan melihat penyebab error Camera init failed with error 0x105 dan brownout yang paling sering muncul, mengendalikan LED flash, dan membuat sketch yang menyimpan foto ke kartu microSD ketika tombol ditekan.

Apa itu ESP32-CAM dan bagaimana cara kerjanya?

Jantung board ini adalah modul ESP32-S yang membawa chip ESP32 dua inti dengan Wi-Fi dan Bluetooth. Kamera dicolokkan ke konektor 24 pin di board dengan kabel pita tipis (FPC). ESP32 mengirim sinyal clock 20 MHz (XCLK) ke kamera lewat GPIO 0 dan mengonfigurasinya lewat bus SCCB yang mirip I2C di GPIO 26 dan 27. Karena sensor OV2640 bisa mengompresi gambar ke JPEG sendiri, ESP32 menerima frame JPEG kecil, bukan piksel mentah. Frame-frame ini lewat bus data paralel 8-bit ke PSRAM 4 MB di board, lalu Wi-Fi meneruskannya ke browser atau server.

Pinout ESP32-CAM AI-Thinker: pin mana yang bebas?

Ada 16 pin di sepanjang dua sisi board, tetapi hanya sedikit yang benar-benar bebas: kamera sendiri memakai 15 GPIO dan slot microSD berbagi enam lagi. Tabel di bawah merangkum pin di tepi board dan kapan kamu bisa memakainya. Fitur pin ESP32 secara umum juga bisa kamu jelajahi di alat Pinout.

Bagaimana cara memprogram ESP32-CAM? Dua cara

Chip USB-serial yang membuat board ESP32 biasa bisa berbicara dengan komputermu tidak ada di ESP32-CAM. Untuk upload kode, kamu punya dua pilihan: adaptor ESP32-CAM-MB yang dipasang di bawah board (board dasar kecil dengan chip CH340 dan soket micro USB), atau konverter USB-TTL yang sudah kamu punya (FTDI, CH340, CP2102). Apa pun pilihanmu, logikanya sama: kalau GPIO 0 LOW ketika boot, ESP32 masuk mode download dan menunggu kode; kalau HIGH, ESP32 menjalankan program di flash. Tombol IO0 di adaptor MB dan kabel IO0-GND yang kamu tambahkan pada adaptor USB-TTL melakukan persis hal ini.

Kalau adaptormu punya jumper pemilih 3,3 V / 5 V, atur ke 3,3 V agar jalur TX tetap di level yang cocok untuk pin ESP32. Namun beri daya board dari pin 5V adaptor. Output 3,3 V di kebanyakan adaptor hanya bisa memberikan sekitar 50–100 mA; begitu ESP32-CAM menyalakan Wi-Fi, catu itu ambruk dan board restart.

Pengaturan Arduino IDE: board, partition scheme, dan PSRAM

1. Buka Boards Manager di Arduino IDE dan instal paket esp32 by Espressif Systems; panduan instalasi Arduino IDE menjelaskannya secara detail.
2. Pilih board AI Thinker ESP32-CAM dari Tools > Board > esp32.
3. Pastikan Partition Scheme diatur ke Huge APP (3MB No OTA/1MB SPIFFS); contoh kamera butuh ruang aplikasi minimal 3 MB.
4. Hubungkan board ke adaptor dan pilih port baru dari Tools > Port (COMx di Windows, /dev/cu.usbserial... atau /dev/cu.wchusbserial... di macOS).
5. Kalau tidak ada port yang muncul sama sekali, instal driver CH340 atau CP2102 dan pakai kabel USB yang bisa membawa data.

Upload pertamamu, langkah demi langkah

1. Sambungkan kabelnya: pasang board ke adaptor MB dengan pin yang sejajar, atau hubungkan adaptor USB-TTL seperti di tabel di atas. Kalau memakai adaptor USB-TTL, tambahkan juga kabel pendek di antara IO0 dan GND.
2. Masukkan board ke mode download: di adaptor MB, tahan tombol IO0, tekan dan lepas RST, lalu lepaskan IO0. Dengan adaptor USB-TTL, cukup tekan RST selama kabel IO0-GND terpasang. Beberapa adaptor MB dengan rangkaian auto-reset bisa upload tanpa menekan tombol apa pun.
3. Klik Upload di Arduino IDE. Output pertama-tama menampilkan Connecting..., diikuti progres penulisan dalam persen.
4. Ketika baris Hard resetting via RTS pin... muncul, upload selesai. Kalau kamu memakai adaptor USB-TTL, lepaskan kabel IO0-GND sekarang.
5. Buka Serial Monitor di 115200 baud dan tekan RST; program baru mulai berjalan.

1// ESP32-CAM ilk yükleme testi / ESP32-CAM first upload test
2const int KIRMIZI_LED = 33;   // arkadaki kırmızı LED, ters mantık / red LED on the back, inverted logic
3
4void setup() {
5  Serial.begin(115200);
6  pinMode(KIRMIZI_LED, OUTPUT);
7  delay(500);
8
9  // PSRAM kontrolü / PSRAM check
10  if (psramFound()) {
11    Serial.print("PSRAM bulundu / PSRAM found: ");
12    Serial.print(ESP.getPsramSize());
13    Serial.println(" bayt / bytes");
14  } else {
15    Serial.println("PSRAM yok / No PSRAM");
16  }
17}
18
19void loop() {
20  digitalWrite(KIRMIZI_LED, LOW);    // LOW = yanar / LOW = on
21  delay(500);
22  digitalWrite(KIRMIZI_LED, HIGH);   // HIGH = söner / HIGH = off
23  delay(500);
24}

Kalau upload berhasil, LED merah kecil di bagian belakang board berkedip setiap setengah detik. LED ini memakai logika terbalik: menulis LOW menyalakannya dan HIGH mematikannya. Di Serial Monitor kamu seharusnya melihat sekitar 4 juta byte PSRAM; kalau tertulis No PSRAM, periksa pilihan board-mu, dan kalau tidak membantu, mungkin board-mu tidak punya chip PSRAM. Menjalankan tes singkat ini sebelum contoh kamera langsung memberi tahu apakah masalahnya ada di upload atau di kamera.

Contoh CameraWebServer: gambar langsung di browser

1. Buka File > Examples > ESP32 > Camera > CameraWebServer.
2. Pilih model kamera: di daftar pada tab board_config.h (versi baru) atau di bagian atas file utama (versi lama), tambahkan // di depan baris CAMERA_MODEL_ESP_EYE dan hapus // di depan baris CAMERA_MODEL_AI_THINKER.
3. Masukkan nama dan password jaringan Wi-Fi 2,4 GHz-mu di baris ssid dan password.
4. Masukkan board ke mode download dan upload sketch-nya; setelah itu lepaskan sambungan IO0 dan tekan RST.
5. Di Serial Monitor kamu akan melihat baris seperti Camera Ready! Use 'http://192.168.1.45' to connect; buka alamat itu di browser ponsel atau komputer yang ada di jaringan yang sama.
6. Mulai gambar langsung dengan tombol Start Stream di halaman, atau ambil satu foto dengan Get Still.

1// board_config.h (eski sürümlerde CameraWebServer.ino) / (CameraWebServer.ino in older versions)
2//#define CAMERA_MODEL_ESP_EYE      // Has PSRAM  <- kapat / comment out
3#define CAMERA_MODEL_AI_THINKER     // Has PSRAM  <- aç / enable
4
5// CameraWebServer.ino
6const char *ssid = "AgAdi";          // Wi-Fi adı / Wi-Fi name
7const char *password = "Sifre123";   // Wi-Fi şifresi / Wi-Fi password

Antarmukanya berjalan di dua server terpisah: halaman pengaturan dan alamat /capture yang mengembalikan satu foto ada di port 80, sedangkan live stream ada di /stream pada port 81 (misalnya http://192.168.1.45:81/stream). Alamat stream ini bisa kamu tambahkan ke halaman web-mu sendiri atau ke software otomasi rumah. Di menu sebelah kiri kamu bisa mengubah resolusi, kualitas JPEG, kecerahan, kontras, dan white balance, dan kalau gambarnya terbalik, pakai sakelar V-Flip dan H-Mirror; versi yang lebih baru juga punya slider LED Intensity untuk flash. Board biasanya hanya melayani satu penonton live stream dalam satu waktu, jadi stream yang dibuka di tab kedua bisa macet. Kalau halamannya sama sekali tidak mau terbuka, pastikan ponselmu dan board ada di jaringan yang sama; untuk masalah koneksi, baca ESP32 tidak mau terhubung ke Wi-Fi.

Tabel resolusi dan FPS ESP32-CAM

Di atas kertas, sensor OV2640 bisa menghasilkan 15 frame per detik di 1600×1200, 30 di 800×600, dan 60 di ukuran CIF. Dalam praktiknya, frame rate lebih banyak ditentukan oleh koneksi Wi-Fi dan ukuran frame JPEG: ketika resolusi dan kualitas naik, setiap frame makin besar dan makin lambat melintasi jaringan. Nilai di bawah adalah rentang perkiraan yang terlihat dengan CameraWebServer pada sinyal Wi-Fi yang bagus dengan kualitas JPEG 10–12. Untuk mengukur board-mu sendiri, atur Core Debug Level ke Info; selama streaming, Serial Monitor mencetak baris seperti MJPG: ... (x fps) untuk setiap frame.

Di kodemu sendiri, resolusi, kualitas, dan orientasi bisa kamu ubah lewat objek sensor begitu kamera berhasil dimulai. Kualitas JPEG adalah angka dari 0 sampai 63, dan angka yang lebih kecil berarti kualitas lebih tinggi; turun di bawah 10 membuat frame makin besar dan bisa menghasilkan gambar yang setengah jadi.

1// esp_camera_init() başarılı olduktan sonra / after esp_camera_init() succeeds
2sensor_t *s = esp_camera_sensor_get();
3s->set_framesize(s, FRAMESIZE_VGA);   // 640x480 çözünürlük / resolution
4s->set_quality(s, 12);                // 0-63: küçük = daha kaliteli, 10 altı önerilmez / lower = better, below 10 not advised
5s->set_vflip(s, 1);                   // görüntüyü dikey çevir / flip vertically
6s->set_hmirror(s, 1);                 // yatay ayna / mirror horizontally
7s->set_brightness(s, 1);              // parlaklık -2..2 / brightness -2..2

Kenapa pengaturan PSRAM ESP32-CAM sangat penting?

Memori internal ESP32 sebesar 520 KB, dan stack Wi-Fi memakai sebagian besar darinya. Sementara itu, satu frame JPEG 1600×1200 bisa memakan 100–250 KB tergantung adegan dan kualitasnya. Karena itu driver kamera menaruh frame buffer-nya di PSRAM. CameraWebServer memeriksa PSRAM dengan fungsi psramFound(): kalau ada, ia mulai di resolusi tertinggi dengan dua frame buffer; kalau tidak, ia membatasi resolusi ke SVGA (800×600) dan menyimpan satu buffer di memori internal.

Kalau kamu meminta resolusi tinggi selama PSRAM tidak aktif, Serial Monitor menampilkan frame buffer malloc failed diikuti Camera init failed with error 0xffffffff. Solusinya, pilih AI Thinker ESP32-CAM sebagai board (dengan ESP32 Dev Module, atur Tools > PSRAM: Enabled) atau turunkan resolusinya dan kurangi jumlah frame buffer menjadi 1. Beberapa klon murah mungkin sama sekali tidak punya chip PSRAM; baris PSRAM di sketch uji pertama langsung mengungkapnya.

Camera init failed with error 0x105 dan error kamera lainnya

Sebagian besar error kamera berasal dari salah satu dari tiga penyebab: model kamera yang salah di kode, kabel pita yang tidak terpasang dengan benar di konektornya, atau catu daya yang tidak memadai. Membaca kode error di Serial Monitor dengan cepat mempersempit penyebabnya:

Error brownout dan catu daya yang tepat (5 V / 2 A)

Kalau Serial Monitor menampilkan Brownout detector was triggered dan board terus restart, tegangan catu ESP32 sempat turun di bawah level aman. ESP32-CAM menarik puncak arus yang singkat tetapi tinggi pada momen ia menyalakan pemancar Wi-Fi dan kamera mulai menangkap gambar. Port USB yang lemah, kabel jumper yang tipis dan panjang, atau output 3,3 V adaptor tidak sanggup mengikuti puncak ini. Inilah solusi permanennya:

• Pakai catu daya yang memberikan 5 V dan minimal 2 A dan hubungkan ke pin 5V board; regulator di board menurunkannya ke 3,3 V.
• Buat kabel daya pendek dan tebal; breadboard dan kabel jumper yang panjang menambah penurunan tegangan.
• Tambahkan kapasitor elektrolit 470–1000 µF di antara pin 5V dan GND board, sedekat mungkin dengan board (kaki positif ke 5V).
• Kalau memberi daya dari komputer, colokkan langsung ke port di bagian belakang PC, bukan ke USB hub.
• Untuk pemakaian dengan baterai, pakai sel 18650 dengan modul boost 5 V; ini jauh lebih stabil daripada rangkaian baterai AA.

Di internet kamu akan sering menemukan baris WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0), yang mematikan detektor brownout lewat kode. Baris ini menghentikan restart, tetapi tidak menyelesaikan masalahnya: tegangannya tetap turun, dan board sekarang bisa macet, menghasilkan frame rusak, atau kehilangan data ketika menulis ke flash. Pakai hanya untuk uji sementara; daftar lengkap pesan restart ada di panduan brownout dan Guru Meditation ESP32. Ketika memperkirakan daya tahan baterai, anggap board menarik rata-rata 180 mA selama streaming terus-menerus: 18650 2600 mAh dengan konverter boost berefisiensi 85% memberi sekitar 1600 mAh di sisi 5 V, yang berarti sekitar 9 jam streaming. Angkamu sendiri bisa dihitung dengan kalkulator daya tahan baterai; ingat bahwa bahkan dalam deep sleep board menarik sekitar 6 mA karena regulator dan PSRAM.

Mengendalikan LED flash (GPIO 4)

LED putih terang di bagian depan board dikendalikan lewat transistor yang tersambung ke GPIO 4, jadi pin hanya menyalakan transistor dan arus besar LED datang dari jalur daya. digitalWrite(4, HIGH) menyalakannya dan LOW mematikannya. LED ini sangat terang, dan kalau menyala lama, LED dan board sama-sama memanas; sebaiknya flash dinyalakan hanya beberapa ratus milidetik ketika mengambil foto. GPIO 4 juga jalur DATA1 kartu microSD, jadi ketika kartu bekerja di mode 4-bit, flash berkedip sendiri di setiap pembacaan dan penulisan. Untuk mencegahnya, mulai kartu SD dalam mode 1-bit (SD_MMC.begin("/sdcard", true)); di beberapa board, LED mungkin masih menyala sangat redup.

Menyimpan foto ke kartu microSD dengan ESP32-CAM

Sketch di bawah menyalakan flash, mengambil foto di 1600×1200, lalu menyimpannya ke kartu microSD sebagai foto1.jpg, foto2.jpg... setiap kali kamu menekan tombol di GPIO 13. Format kartu microSD sebagai FAT32 di komputermu; walaupun dokumentasi resmi menyebut kartu sampai 4 GB, kartu FAT32 16–32 GB biasanya bekerja dengan baik dalam praktiknya. Hubungkan satu kaki tombol ke GPIO 13 dan kaki lainnya ke GND; sketch mengaktifkan resistor pull-up internal, jadi tidak perlu resistor tambahan. Untuk cara kerja pengkabelan tombol, baca Cara Menghubungkan Push Button ke Arduino.

1#include "esp_camera.h"
2#include "FS.h"
3#include "SD_MMC.h"
4
5// AI-Thinker ESP32-CAM kamera pinleri / AI-Thinker ESP32-CAM camera pins
6#define PWDN_GPIO_NUM     32
7#define RESET_GPIO_NUM    -1
8#define XCLK_GPIO_NUM      0
9#define SIOD_GPIO_NUM     26
10#define SIOC_GPIO_NUM     27
11#define Y9_GPIO_NUM       35
12#define Y8_GPIO_NUM       34
13#define Y7_GPIO_NUM       39
14#define Y6_GPIO_NUM       36
15#define Y5_GPIO_NUM       21
16#define Y4_GPIO_NUM       19
17#define Y3_GPIO_NUM       18
18#define Y2_GPIO_NUM        5
19#define VSYNC_GPIO_NUM    25
20#define HREF_GPIO_NUM     23
21#define PCLK_GPIO_NUM     22
22
23#define FLAS_LED  4    // beyaz flaş LED'i / white flash LED
24#define BUTON    13    // butonun diğer ucu GND'de / other button leg to GND
25
26int fotoNo = 1;        // sıradaki dosya numarası / next file number
27bool hazir = false;    // kamera ve SD hazır mı? / are camera and SD ready?
28
29bool kameraBaslat() {
30  camera_config_t config = {};
31  config.ledc_channel = LEDC_CHANNEL_0;
32  config.ledc_timer   = LEDC_TIMER_0;
33  config.pin_d0 = Y2_GPIO_NUM;
34  config.pin_d1 = Y3_GPIO_NUM;
35  config.pin_d2 = Y4_GPIO_NUM;
36  config.pin_d3 = Y5_GPIO_NUM;
37  config.pin_d4 = Y6_GPIO_NUM;
38  config.pin_d5 = Y7_GPIO_NUM;
39  config.pin_d6 = Y8_GPIO_NUM;
40  config.pin_d7 = Y9_GPIO_NUM;
41  config.pin_xclk     = XCLK_GPIO_NUM;
42  config.pin_pclk     = PCLK_GPIO_NUM;
43  config.pin_vsync    = VSYNC_GPIO_NUM;
44  config.pin_href     = HREF_GPIO_NUM;
45  config.pin_sccb_sda = SIOD_GPIO_NUM;
46  config.pin_sccb_scl = SIOC_GPIO_NUM;
47  config.pin_pwdn     = PWDN_GPIO_NUM;
48  config.pin_reset    = RESET_GPIO_NUM;
49  config.xclk_freq_hz = 20000000;           // 20 MHz kamera saati / 20 MHz camera clock
50  config.pixel_format = PIXFORMAT_JPEG;
51
52  if (psramFound()) {
53    config.frame_size   = FRAMESIZE_UXGA;   // 1600x1200
54    config.jpeg_quality = 10;               // küçük = daha kaliteli / lower = better quality
55    config.fb_count     = 2;
56    config.fb_location  = CAMERA_FB_IN_PSRAM;
57    config.grab_mode    = CAMERA_GRAB_LATEST;
58  } else {
59    config.frame_size   = FRAMESIZE_SVGA;   // PSRAM yoksa 800x600 / 800x600 without PSRAM
60    config.jpeg_quality = 12;
61    config.fb_count     = 1;
62    config.fb_location  = CAMERA_FB_IN_DRAM;
63    config.grab_mode    = CAMERA_GRAB_WHEN_EMPTY;
64  }
65
66  esp_err_t err = esp_camera_init(&config);
67  if (err != ESP_OK) {
68    Serial.printf("Camera init failed 0x%x (%s)\n", err, esp_err_to_name(err));
69    return false;
70  }
71  return true;
72}
73
74void fotoCek() {
75  digitalWrite(FLAS_LED, HIGH);              // flaşı yak / flash on
76  delay(150);                                // pozlama otursun / let exposure settle
77
78  camera_fb_t *fb = esp_camera_fb_get();     // eski kareyi at / discard the stale frame
79  if (fb) esp_camera_fb_return(fb);
80  fb = esp_camera_fb_get();                  // asıl fotoğraf / the real photo
81  digitalWrite(FLAS_LED, LOW);               // flaşı söndür / flash off
82
83  if (!fb) {
84    Serial.println("Kare alinamadi / Capture failed");
85    return;
86  }
87
88  String yol = "/foto" + String(fotoNo) + ".jpg";
89  File dosya = SD_MMC.open(yol, FILE_WRITE);
90  if (dosya) {
91    dosya.write(fb->buf, fb->len);           // JPEG verisini yaz / write the JPEG data
92    dosya.close();
93    Serial.printf("Kaydedildi / Saved: %s (%u bayt / bytes)\n", yol.c_str(), (unsigned)fb->len);
94    fotoNo++;
95  } else {
96    Serial.println("Dosya acilamadi / Could not open file");
97  }
98  esp_camera_fb_return(fb);                  // tamponu geri ver / return the buffer
99}
100
101void setup() {
102  Serial.begin(115200);
103  pinMode(BUTON, INPUT_PULLUP);
104
105  if (!kameraBaslat()) return;               // kamera yoksa dur / stop without a camera
106
107  // 1-bit mod: GPIO 4, 12 ve 13 boşta kalır / 1-bit mode keeps GPIO 4, 12 and 13 free
108  if (!SD_MMC.begin("/sdcard", true)) {
109    Serial.println("SD kart takilamadi / SD card mount failed");
110    return;
111  }
112  if (SD_MMC.cardType() == CARD_NONE) {
113    Serial.println("SD kart yok / No SD card");
114    return;
115  }
116
117  pinMode(FLAS_LED, OUTPUT);
118  digitalWrite(FLAS_LED, LOW);
119
120  // Var olan fotoğrafların üzerine yazma / don't overwrite existing photos
121  while (SD_MMC.exists("/foto" + String(fotoNo) + ".jpg")) fotoNo++;
122
123  hazir = true;
124  Serial.println("Hazir, butona bas / Ready, press the button");
125}
126
127void loop() {
128  if (!hazir) {                              // hata varsa bekle / wait if setup failed
129    delay(1000);
130    return;
131  }
132  if (digitalRead(BUTON) == LOW) {
133    delay(30);                               // buton sıçramasını (bounce) önle / debounce
134    if (digitalRead(BUTON) == LOW) {
135      fotoCek();
136      while (digitalRead(BUTON) == LOW) delay(10);   // bırakılmasını bekle / wait for release
137    }
138  }
139}

Karena sketch memulai kartu SD dalam mode 1-bit, ia hanya memakai GPIO 2, 14, dan 15, sehingga GPIO 4 tersisa untuk flash dan GPIO 13 untuk tombol. Sebelum mengambil foto, satu frame diambil lalu langsung dikembalikan: kamera menghasilkan frame terus-menerus, jadi frame pertama di buffer mungkin sudah tertangkap sebelum flash menyala, dan auto exposure butuh jeda singkat untuk menyesuaikan dengan cahaya baru. Nomor file ditentukan dengan melihat file yang sudah ada di kartu, jadi foto lama tidak tertimpa bahkan setelah restart. Untuk aturan umum mencatat data ke kartu SD, lihat panduan modul kartu SD.

MicroPython dan board kamera yang lebih baru

ESP32-CAM juga bisa diprogram dengan MicroPython, tetapi build MicroPython resmi tidak menyertakan driver kamera; kamu harus menulis firmware komunitas yang sudah ditambahi dukungan kamera. Karena itu jalur Arduino IDE jauh lebih mulus untuk pemula. Kalau kamu tidak mau repot dengan board tanpa soket USB, pertimbangkan juga board kamera berbasis ESP32-S3 dengan USB dan memori lebih besar (misalnya Seeed XIAO ESP32S3 Sense atau ESP32-S3-EYE); board ini juga muncul di daftar model CameraWebServer.

Ide proyek ESP32-CAM

• Foto ketika ada gerakan: ambil foto ketika sensor PIR mendeteksi seseorang lalu kirim ke ponselmu; panduan langkah demi langkahnya ada di foto ESP32-CAM ke Telegram.
• Rekaman time-lapse: biarkan board bangun setiap 10 menit, mengambil foto, menyimpannya ke kartu SD, lalu kembali ke deep sleep; amati tanaman tumbuh atau cuaca berubah.
• Kamera bel pintu: potret depan pintumu ketika tombol bel ditekan dan kirim notifikasi dengan bot Telegram.
• Mobil robot berkamera: kemudikan mobil sambil menonton live stream QVGA yang mulus di ponselmu.
• Kamera hewan peliharaan: tonton live stream di jaringan rumahmu dan nyalakan flash dari halaman web ketika perlu.
• Panel kontrol buatanmu sendiri: sematkan live stream di halaman web-mu sendiri dan tambahkan tampilan relay dan sensor di sampingnya; panduan WebSocket ESP32 menunjukkan caranya.

Kesalahan umum dan cara mengatasinya

ESP32-CAM adalah cara termudah untuk membuat kamera Wi-Fi di board yang terjangkau, dan hampir setiap kesulitan yang kamu temui berasal dari sambungan pemrograman atau catu daya. Begitu kedua hal itu benar, board ini mengirim video langsung dari web server-nya sendiri, mengambil foto, dan menyimpannya ke kartu SD. Di aplikasi BlueGrays ada proyek ESP32 seperti koneksi Wi-Fi, web server, mDNS, pencatatan data ke microSD, dan alarm gerak dengan notifikasi Telegram, masing-masing dengan skema rangkaian langkah demi langkah dan kode siap pakai.