ESP32 & Arduino: Sahabat Meja, Kendali Grid, Dunia di Tanganmu!
Disclaimer kecil dulu, biar artikel ini nggak jadi hoaks berlapis HTML. Tiga rujukan yang saya pegang di artikel ini adalah: pemberitaan XDA soal ClawPal, desk buddy berbasis ESP32 yang memantau statistik PC, catatan penelitian di Bioengineer.org soal baseline persistence yang mengalahkan neural network di mikrokontroler untuk nowcasting biogas harian, dan entri Hackaday berjudul “Follow The Grid With An Arduino Uno”. Untuk proyek-proyek berita ini, klaim saya batasi pada judul dan deskripsi resminya. Detail arsitektur, kode, dan angka di bawah adalah rekomendasi desain dan pengetahuan teknik umum dari saya, bukan kutipan dari artikel-artikel itu. Saya tandai mana yang mana. Deal? Oke, lanjut.
Bayangkan meja kerja lo. Ada kopi yang udah dingin sejak hari Selasa, kabel USB numpuk kayak sarang ular, dan sebuah makhluk plastik kecil yang sesekali menggerakkan cakarnya sambil nampilin grafik CPU. Itu bukan sihir. Itu embedded engineering yang gampang diremehin karena biayanya lebih murah dari sekali makan siang di mall.
Di satu sisi ada Arduino Uno: si pekerja keras jadul, satu inti, nggak banyak mikir, stabil kayak pegawai ASN. Di sisi lain ada ESP32: dual-core, punya Wi-Fi dan Bluetooth, bisa nge-render OLED sambil nge-tweet suhu ruangan, dan tetap ngambek (brownout) kalau lo kasih kabel USB murahan. Artikel ini bedah dua-duanya sampai ke lapisan power rail. Siapin kopi yang baru, yang lama udah nggak bisa dipercaya.
1. Anatomi Dua Karakter yang Beda Kelas
Sebelum lo nulis satu baris kode, lo harus tahu lo sedang ngomong sama siapa. Ini ringkasan spesifikasi inti dari dokumentasi resmi Espressif dan Arduino, bukan dari ingatan samar-samar:
- Arduino Uno R3: MCU ATmega328P, 16 MHz, 32 KB Flash, 2 KB SRAM, 1 KB EEPROM. 14 pin digital (6 di antaranya PWM), 6 input analog dengan ADC 10-bit. Logika 5 V. Satu alur eksekusi:
setup()sekali,loop()berulang. Nggak ada sistem operasi, nggak ada Wi-Fi, nggak ada drama. - Arduino Uno R4 (Minima / WiFi): MCU Renesas RA4M1 (Arm Cortex-M4 48 MHz, 32 KB RAM, 256 KB Flash), ADC 14-bit, DAC, CAN bus, op-amp internal, input tegangan lebih toleran, USB-C. Versi WiFi menambahkan modul konektivitas berbasis ESP32-S3 plus matriks LED. Jadi Uno R4 WiFi itu literally “Uno yang dinikahkan dengan ESP32”.
- ESP32 (WROOM-32 generasi pertama): dual-core Xtensa LX6 sampai 240 MHz, 520 KB SRAM, Wi-Fi 802.11 b/g/n 2.4 GHz, Bluetooth Classic 4.2 dan BLE, ADC SAR 12-bit, DAC 8-bit di GPIO25/26, sentuh kapasitif, plus peripheral kaya: LEDC PWM, RMT, PCNT, MCPWM, TWAI (CAN 2.0), Ethernet MAC. Logika 3,3 V. Tegangan modul 3,0–3,6 V.
- Keluarga turunannya: ESP32-S3 (LX7 dual-core dengan instruksi vektor untuk akselerasi AI, USB-OTG, PSRAM), ESP32-C3 (RISC-V satu inti 160 MHz, hemat biaya), ESP32-C6 (Wi-Fi 6 + 802.15.4 untuk Thread/Zigbee), ESP32-H2 (802.15.4 + BLE, tanpa Wi-Fi), ESP32-P4 (dual-core RISC-V kencang, RAM besar, antarmuka kamera/display, Wi-Fi-nya eksternal).
Konsekuensi praktis yang sering bikin orang nangis
- Level logika 3,3 V vs 5 V. Pin ESP32 bukan 5 V tolerant. Sensor atau modul yang nge-output 5 V bisa merusaknya. Pakai level shifter (misalnya TXS0108E) atau pembagi tegangan untuk jalur input.
- ADC 12-bit itu “12-bit di atas kertas”. Noise, non-linearitas integral, dan kalibrasi eFuse bikin performa efektifnya sering setara 9–10 bit. Untuk sensor suhu, sensor digital (DS18B20, SHT3x, INA219) hampir selalu lebih masuk akal daripada
analogRead()di modul murah. - ADC2 bermasalah dengan Wi-Fi. Di ESP32, ADC2 berbagi domain daya dengan radio, jadi pembacaan ADC2 jadi ngawur begitu Wi-Fi aktif. Solusi waras: pakai ADC1 (GPIO32–39), atau pindah ke sensor digital.
- Arus per pin Uno dibatasi. ATmega328P aman di sekitar 20 mA per pin (maksimum absolut lebih tinggi, tapi jangan main-main). Motor, relay, LED strip: pakai transistor/MOSFET dan driver, jangan langsung dari pin.
Kesimpulan bagian ini: kalau proyek lo butuh jaringan, filesystem, HTTPS, atau dua tugas yang jalan barengan, Uno R3 adalah pilihan yang salah. Kalau lo butuh mikrokontroler yang naik-boot dalam milidetik tanpa ribet dan cukup baca sensor lalu nyalain relay, ESP32 itu overkill yang boros daya. Pilih sesuai beban, bukan sesuai hype.
2. Toolchain, Runtime, dan Real-Time: Dari Nol ke Boot Log
2.1 Alur kerja yang wajar
Jalur tercepat tetap Arduino IDE 2.x: buka Preferences, tambahkan URL board manager resmi Espressif https://espressif.github.io/arduino-esp32/package_esp32_index.json (URL lama raw.githubusercontent.com/espressif/arduino-esp32 masih beredar, tapi yang di atas adalah yang dipakai core 3.x), install “esp32 by Espressif Systems”. Perhatikan: core esp32 2.x dibangun di atas ESP-IDF 4.4, sedangkan esp32 3.x di atas ESP-IDF 5.x. Banyak error “kok library gue nggak compile” sebenarnya adalah mismatch versi core, bukan salah kode.
Untuk yang lebih suka otomasi, repo arduino-esp32 bisa dipanggil via arduino-cli, dan PlatformIO memberi manajemen dependensi serta unit test yang lebih rapi. Kalau proyeknya bakal serius dan butuh kontrol penuh (partisi flash kustom, Wi-Fi power save halus, OTA bertanda tangan), saat itu lo naik kelas ke ESP-IDF dan Arduino jadi komponen di dalamnya, bukan sebaliknya.
Kalau flashing gagal dan muncul A fatal error occurred: Failed to connect to ESP32, urutan tersangka yang wajar diperiksa: kabel USB data-capable (bukan kabel charging-only), driver USB-UART (CP2102 atau CH340 sesuai modul), mode download dengan menahan BOOT lalu tap RESET, dan pin strapping. Di ESP32 klasik, GPIO0, GPIO2, GPIO12, dan GPIO15 punya fungsi strapping saat boot; GPIO12 khususnya memengaruhi tegangan VDD_SDIO flash. Di ESP32-S3 strapping ada di GPIO0, GPIO3, GPIO45, GPIO46. Kalau ada beban eksternal yang narik pin strapping, board bisa boot ke mode yang salah dan lo bakal curiga pada kode lo sendiri selama tiga hari.
2.2 loop() itu bohong, dan FreeRTOS yang beneran kerja
Di Uno, loop() adalah satu-satunya kebenaran. Konsekuensinya, delay(1000) itu bom waktu: selama satu detik itu, MCU lo tunarungu total. Pola yang benar di Arduino adalah penjadwalan non-blocking berbasis millis():
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
static uint32_t lastToggle = 0;
const uint32_t interval = 500;
uint32_t now = millis();
if (now - lastToggle >= interval) { // bukan (now > lastToggle + interval)
lastToggle = now; // bukan lastToggle = now + interval
digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
}
// tugas lain lo jalan di sini tanpa nunggu
}
Catatan penting soal millis(): pengurangan now - lastToggle dengan tipe unsigned aman terhadap overflow 49,7 hari. Penulisan if (millis() > lastEvent + interval) akan mati tepat saat counter wrap. Ini bug klasik yang bikin perangkat “jalan mulus selama 50 hari lalu ngaco”.
Di ESP32, cerita berubah total. Arduino-esp32 menjalankan loop() di dalam sebuah task FreeRTOS (default di core 1), dan lo bisa bikin task sendiri yang di-pin ke core mana pun:
#include <Arduino.h>
TaskHandle_t hGrid = NULL;
SemaphoreHandle_t mtxStats = NULL;
volatile float g_gridHz = 0.0f;
void vTaskGrid(void *pvParameters) {
(void) pvParameters;
for (;;) {
float local = bacaSinyalGrid(); // hasil pengukuran dari ISR
if (xSemaphoreTake(mtxStats, pdMS_TO_TICKS(50)) == pdTRUE) {
g_gridHz = local; // tulis di bawah proteksi mutex
xSemaphoreGive(mtxStats);
}
vTaskDelay(pdMS_TO_TICKS(200)); // selalu ada delay di task
}
}
void setup() {
Serial.begin(115200);
mtxStats = xSemaphoreCreateMutex();
BaseType_t ok = xTaskCreatePinnedToCore(
vTaskGrid, "grid", 4096, NULL, 2, &hGrid, 0); // core 0
Serial.printf("task grid: %s, free heap: %u\n",
ok == pdPASS ? "OK" : "GAGAL",
(unsigned) ESP.getFreeHeap());
}
void loop() {
if (xSemaphoreTake(mtxStats, pdMS_TO_TICKS(10)) == pdTRUE) {
float hz = g_gridHz;
xSemaphoreGive(mtxStats);
Serial.printf("f = %.2f Hz\n", hz);
}
delay(1000);
}
Aturan main FreeRTOS yang harus lo tatu di otak:
- Jangan pernah menulis task tanpa
vTaskDelay(). Task tanpa titik blokir bikin task lain kelaparan, dan yang nangkep adalah Task Watchdog (TWDT) atau Interrupt Watchdog, dengan pesan error yang bikin lo mikir hardware-nya rusak. - Ukur stack sebelum optimasi. Pakai
uxTaskGetStackHighWaterMark(NULL). Kalau sisa watermark-nya mendekati nol, itu bukan “hemat memori”, itu kecelakaan yang menunggu jadwal. - Bagi data lewat queue, bukan variabel global telanjang. Untuk salinan satu nilai, mutex plus salinan lokal (seperti contoh di atas) sudah cukup. Untuk aliran data,
xQueueSend()dari ISR dengan prioritas...FromISR()danportYIELD_FROM_ISR()adalah pola yang benar. - ISR harus pendek. Tandai dengan
IRAM_ATTRkalau fungsinya harus jalan saat flash sedang sibuk, dan jangan panggilSerial.print(),malloc(), ataudelay()di dalam ISR. Ringan saja: bacamicros(), simpan angka, keluar. - Paketkan komunikasi antar-core. Antara task di core 0 dan core 1, jangan berbagi variabel lewat optimisme. Pakai primitif sinkronisasi; driver I2C/SPI punya lock internal, tapi state aplikasi lo tidak.
3. Proyek 1: Desk Buddy Ala ClawPal, Papan Status PC Berwajah Cakar
Menurut XDA, ClawPal adalah desk buddy berbasis ESP32 yang melacak statistik PC kamu. Sampai di situ klaim faktual saya berhenti; detail rancangannya di bawah adalah usul saya, dijelaskan sebagai pola desain, bukan sebagai isi artikel XDA.
Masalah intinya justru menarik: ESP32 tidak tahu apa-apa soal CPU usage PC lo. Dia bukan bagian dari PC. Jadi arsitekturnya wajib dua sisi:
- Sisi PC (agregator). Sebuah proses kecil di PC membaca metrik (utilisasi CPU, RAM, suhu, beban GPU) dan menyajikannya sebagai HTTP endpoint lokal. Di Windows, kelas
System.Diagnostics.PerformanceCounterdi .NET sudah cukup; alternatif yang lebih dalam adalah library seperti LibreHardwareMonitor untuk pembacaan sensor. Endpoint ini hanya boleh hidup di localhost atau LAN terpercaya, karena data telemetri mesin lo bukan sesuatu yang layak dibuka ke publik. - Sisi ESP32 (klien + renderer). ESP32 melakukan
HTTP GETperiodik, mem-parse JSON, dan menggambar ke OLED SSD1306 (I2C) atau TFT SPI. Cakar yang bergerak bisa pakai servo SG90 plus roda gigi yang dicetak 3D, dan gerakannya dipicu oleh threshold (misalnya cakar mengangkat saat CPU di atas 80%).
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_W 128
#define SCREEN_H 64
#define OLED_ADDR 0x3C
Adafruit_SSD1306 display(SCREEN_W, SCREEN_H, &Wire, -1);
const char *WIFI_SSID = "RUMAH_LORONG";
const char *WIFI_PASS = "ganti-ini-jangan-hardcode";
struct PcStats {
float cpu; // persen
float ram; // persen
float tempC; // celsius, 0 berarti tak terbaca
bool valid;
};
volatile PcStats g_stats = {0, 0, 0, false};
portMUX_TYPE g_mux = portMUX_INITIALIZER_UNLOCKED;
bool tarikStatistik(PcStats &out) {
if (WiFi.status() != WL_CONNECTED) return false;
HTTPClient http;
http.setConnectTimeout(800);
http.setTimeout(1500);
http.useHTTP10(true); // hindari chunked encoding
if (!http.begin("http://192.168.1.50:8080/stats")) return false;
int code = http.GET();
if (code != HTTP_CODE_OK) { http.end(); return false; }
String body = http.getString();
http.end();
JsonDocument doc; // ArduinoJson v7: cukup satu dokumen
if (deserializeJson(doc, body)) return false;
out.cpu = doc["cpu"] | -1.0f;
out.ram = doc["ram"] | -1.0f;
out.tempC = doc["temp"] | 0.0f;
out.valid = (out.cpu >= 0.0f) && (out.ram >= 0.0f);
return out.valid;
}
void setup() {
Serial.begin(115200);
Wire.begin(21, 22); // SDA, SCL sesuai modul
display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
display.clearDisplay();
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println("ClawPal online");
display.display();
WiFi.mode(WIFI_STA);
WiFi.setSleep(false); // konsistensi latensi polling
WiFi.begin(WIFI_SSID, WIFI_PASS);
uint32_t t0 = millis();
while (WiFi.status() != WL_CONNECTED && millis() - t0 < 8000) delay(100);
}
void loop() {
static uint32_t lastFetch = 0;
const uint32_t PERIOD = 2000;
if (millis() - lastFetch >= PERIOD) {
lastFetch = millis();
PcStats s;
if (tarikStatistik(s)) {
portENTER_CRITICAL(&g_mux);
g_stats = s;
portEXIT_CRITICAL(&g_mux);
}
}
PcStats view;
portENTER_CRITICAL(&g_mux);
view = g_stats;
portEXIT_CRITICAL(&g_mux);
if (view.valid) {
display.clearDisplay();
display.setTextSize(1);
display.setCursor(0, 0);
display.printf("CPU %3.0f%% RAM %3.0f%%", view.cpu, view.ram);
display.drawFastHLine(0, 14, SCREEN_W, SSD1306_WHITE);
int bar = (int)(view.cpu * SCREEN_W / 100.0f);
display.fillRect(0, 20, bar, 8, SSD1306_WHITE);
display.setCursor(0, 40);
display.printf("Temp %4.1f C", view.tempC);
display.display();
} else {
display.clearDisplay();
display.setCursor(0, 28);
display.println("PC offline :(");
display.display();
}
delay(60);
}
Detail yang bikin proyek ini enak dipakai harian: polling non-blocking dengan timeout pendek supaya OLED tetap responsif, portMUX_TYPE untuk melindungi snapshot data antar-context, penanganan eksplisit status invalid supaya layar nggak nampilin sampah, dan modul Wi-Fi yang tidak tidur karena latensi adalah musuh utama animasi. Kalau mau tambah cakar servo, jangan pakai delay() untuk timing servo: jalankan animasi sebagai state machine bertahap, atau pindahkan ke task terpisah dengan vTaskDelay().
Oh iya, soal kredensial: WIFI_PASS di dalam source itu utang teknis, bukan solusi. Simpan di NVS, atau sediakan captive portal provisioning, atau tulis ke arduino_secrets.h yang masuk .gitignore. Rahasia yang ada di repo publik itu bukan rahasia, itu dokumentasi.
4. Proyek 2: “Follow The Grid” dengan Arduino Uno
Entri Hackaday berjudul “Follow The Grid With An Arduino Uno” punya judul yang, harus saya akui, ambigu secara teknis. “Grid” bisa berarti kisi/garis yang diikuti robot, atau jaringan listrik yang frekuensinya dipantau. Karena saya tidak akan mengarang isi artikelnya, saya bahas dua-duanya sebagai teknik umum, dan lo silakan cek tautannya untuk versi aslinya. Dua-duanya sama-sama enak dikerjakan dengan Uno, dan justru itu poin pentingnya: Uno masih jadi alat yang tepat untuk tugas sempit dengan timing ketat.
Interpretasi A: robot pengikut kisi/garis di lantai
Sensornya biasanya array reflektansi inframerah (misalnya TCRT5000 atau modul 5–8 kanal), dibaca lewat analogRead(). Nilai mentahnya nggak bisa dipakai langsung karena ambient light dan jarak bikin threshold geser. Polanya:
- Kalibrasi saat
setup(): rekammindanmaxtiap sensor di atas garis dan di luar garis (60 iterasi cukup). - Normalisasi jadi 0–1000:
norm = (raw - min) * 1000 / (max - min), lalu clamp. - Hitung error berbobot dari posisi garis terhadap titik tengah robot.
- Suplai error itu ke controller PID yang menghasilkan koreksi kecepatan kiri/kanan motor.
float pidUpdate(float err, float dt) {
static float lastErr = 0.0f, integ = 0.0f;
const float Kp = 1.6f, Ki = 0.05f, Kd = 0.12f;
integ += err * dt;
integ = constrain(integ, -50.0f, 50.0f); // anti windup
float deriv = (err - lastErr) / dt;
lastErr = err;
return Kp * err + Ki * integ + Kd * deriv;
}
void loop() {
static uint32_t lastRun = 0;
uint32_t now = micros();
if (now - lastRun < 5000UL) return; // sampling 200 Hz
float dt = (now - lastRun) / 1000000.0f;
lastRun = now;
float err = bacaPosisiGaris(); // -1 (kiri) .. +1 (kanan)
float c = pidUpdate(err, dt);
setMotor(BASE_SPEED - c, BASE_SPEED + c);
}
Kenapa Arduino cocok di sini: loop kontrol 200–500 Hz, nol boot time, dan micros() yang cukup untuk timing presisi mikrodetik. Kalau lo bikin versi ESP32-nya, gunanya adalah telemetri nirkabel dan tuning PID dari laptop, bukan kontrol dasarnya.
Interpretasi B: memantau frekuensi jaringan listrik
Ukuran yang dimaksud adalah frekuensi jaringan (di Indonesia nominalnya 50 Hz). Teknik paling murah dan paling umum di Arduino adalah zero-crossing detection: sinyal AC diturunkan, diisolasi secara galvanis, lalu diubah jadi pulsa digital yang naik satu kali per siklus penuh. Ukur jarak antar pulsa dengan micros() di dalam ISR, dan frekuensi adalah inversnya.
volatile uint32_t lastRise = 0;
volatile uint32_t periodUs = 0;
void isrZeroCross() {
uint32_t now = micros();
periodUs = now - lastRise; // subtraksi unsigned: aman terhadap overflow
lastRise = now;
}
void setup() {
Serial.begin(115200);
pinMode(2, INPUT); // output optocoupler AC-input (mis. H11AA1)
attachInterrupt(digitalPinToInterrupt(2), isrZeroCross, RISING);
}
void loop() {
static uint32_t lastPrint = 0;
if (millis() - lastPrint < 1000) return;
lastPrint = millis();
noInterrupts();
uint32_t p = periodUs;
interrupts();
if (p > 0) {
float hz = 1000000.0f / (float)p; // 20000 us = 50,00 Hz
float deviasi = (hz - 50.0f) * 2.0f; // persen terhadap nominal
Serial.printf("f = %.3f Hz (%+.2f%%)\n", hz, deviasi);
}
}
Kalibrasi yang sering dilewati orang: presisi micros() bergantung pada kristal 16 MHz Uno, dan toleransi kristal murah bisa menghasilkan galat frekuensi beberapa per-mil. Kalau lo serius mengukur deviasi 0,01 Hz, lo butuh referensi waktu eksternal (RTC ber-kristal kalibrasi, GNSS 1PPS, atau pembanding frekuensi). Standar kualitas daya seperti EN 50160 menetapkan batas rentang frekuensi untuk sistem 50 Hz (umumnya 49,5–50,5 Hz untuk mayoritas waktu satu tahun), jadi kalau hasil ukur lo “melenceng”, pastikan dulu itu grid-nya atau jam kristal lo yang bohong.
Ambang keselamatan, jangan di-skip. Mengukur jaringan AC 230 V bukan kegiatan hobi santai. Wajib: isolasi galvanis nyata (optocoupler atau CT clamp/nursing CT dengan burden resistor yang benar), nilai resistor seri yang dihitung untuk arus LED optocoupler, enclosure tertutup, dan tidak ada bagian bertegangan yang bisa disentuh. Kalau lo belum pernah menangani mains dengan aman, beli modul terisolasi jadi atau minta bantuan orang yang kompeten. Bukan urusan “nanti aja kalau udah kena sengat”.
Dan kalau butuh ESP32 di proyek grid ini, itu justru kasih nilai tambah: lo bisa kirim frekuensi ke dashboard via MQTT, log ke SD card, dan kirim notifikasi kalau deviasi melewati ambang. Tapi tetap: pengukuran tetap di Uno atau di ADC terisolasi, radio cuma urusan transport.
5. TinyML di Mikrokontroler: Kenapa “Baseline Bodoh” Sering Menang
Ini bagian favorit saya, karena isinya pelajaran yang memalukan sekaligus menyelamatkan. Judul catatan riset di Bioengineer.org menjelaskan hasilnya dengan brutal: untuk peramalan (nowcasting) produksi biogas harian yang dijalankan di mikrokontroler, baseline persistence sederhana mengalahkan neural network.
Baseline persistence itu definisinya sesederhana mungkin: prediksi hari esok sama dengan nilai hari ini.
$$ \hat{y}_{t+1} = y_t \qquad \mathrm{RMSE} = \sqrt{\frac{1}{N} \sum_{t=1}^{N} \left(\hat{y}_t - y_t
ight)^2} $$
Kalau neural network lo, setelah kuantisasi ke INT8 dan sesi debug tiga hari, cuma menyamai atau mengalah tipis baseline itu, maka secara jujur lo belum membangun model. Lo membangun pengeluaran daya, RAM, dan waktu tidur.
Lima sebab teknis yang hampir selalu jadi biang keroknya
- Validasi yang bocor waktu. Untuk data deret waktu, split acak adalah dosa. Data masa depan bocor ke set latih, metrik jadi cantik di notebook, lalu ambruk di lapangan. Pakai walk-forward validation: latih di [t-k, t], uji di t+1, geser terus.
- Dataset terlalu kecil untuk kapasitas model. Model dengan sepuluh ribu parameter butuh ribuan sampel yang informatif. Kalau lo punya 90 hari data biogas dengan musim yang belum lengkap, model lo belajar menghafal, bukan belajar memahami.
- Non-stationarisitas dan drift. Proses biogas dipengaruhi suhu, beban organik, komposisi feedstock, usia reactor. Kalau distribusi data bergeser, bobot yang dioptimasi kemarin jadi zombi hari ini.
- Quantization bukan solusi untuk model yang salah. INT8 menghemat flash dan siklus, tapi tidak memperbaiki bias struktural. Model yang salah di level arsitektur tetap salah setelah dikomersialkan jadi tflite.
- Baseline tidak pernah dibandingkan. Inilah akar masalahnya. Kalau lo tidak menghitung RMSE persistence sebagai garis start, lo tidak punya cara tahu apakah usaha lo menghasilkan nilai.
Kalau lo tetap mau jalan di jalur TinyML, urutan yang saya rekomendasikan: (1) bangun baseline persistence dan baseline “rata-rata bergerak 7 hari”, hitung MAE dan RMSE keduanya; (2) bangun model linear/parameter kecil yang bisa dijelaskan; (3) baru naik ke jaringan saraf, dengan TensorFlow Lite Micro atau ESP-SR untuk audio, di hardware yang punya instruksi vektor seperti ESP32-S3; (4) bandingkan biaya inferensi (RAM arena, flash, energi per prediksi) terhadap peningkatan akurasi absolut dibanding baseline. Kalau modelmu menang 0,2% RMSE dengan biaya RAM 12 KB ekstra, jawaban jujurnya adalah jangan pakai model itu.
Nasihat yang lebih tidak seksi tapi lebih berguna: perbaiki sensornya, kalibrasi ulang, tambah pencatatan konteks operasional. Sering kali “model lebih pintar” sebenarnya cuma menutupi sensor yang shift.
6. Power Budget dan Brownout: Penyebab Nomor Satu ESP32 “Mati Ajaib”
Kalau ESP32 lo reboot sendiri secara acak dan serial monitor memuntahkan Brownout detector was triggered, itu bukan kutukan. Itu matematika daya. Modul Wi-Fi menarik arus jauh di atas idle saat transmit, dan modul murah dengan LDO AMS1117 tipis plus kabel USB seukuran mie instan akan mengalami drop tegangan sesaat di bawah threshold brownout, lalu chip reset. Kalau modul lo memang nggak punya brownout detector aktif, gejalanya lebih jahat lagi: crash acak tanpa jejak.
Hitung dengan sadar, bukan dengan feeling:
$$ I_{avg} = \frac{\sum_{i} I_i \cdot t_i}{T} \qquad P_{avg} = V \cdot I_{avg} $$
Checklist yang menyelesaikan 90% kasus:
- Kabel USB pendek dan tebal. Bukan yang gratis dari kemasan permen.
- Kapasitor bulk 470–1000 µF di dekat modul, plus 100 nF keramik untuk decoupling frekuensi tinggi. Ini bukan hiasan.
- Untuk baterai LiPo, gunakan charger-modul dengan proteksi (TP4056 protected), dan bagi tegangan dengan pembagi sebelum masuk ADC1. Jangan pernah masukkan 4,2 V langsung ke pin 3,3 V.
- Ukur dengan USB power meter murah atau shunt resistor plus INA219. Angka “kira-kira” bukan angka.
- Kurangi konsumsi secara sistematis: Wi-Fi modem sleep via
WiFi.setSleep(true)atauesp_wifi_set_ps(), kurangi daya TX kalau jarak dekat, dan gunakan deep sleep untuk node periodik. Deep sleep ESP32 ada di orde puluhan µA, jadi node yang bangun 1 detik setiap 10 menit bisa hidup lama di baterai kecil, asalkan lo memakaiesp_sleep_enable_timer_wakeup()dan menyimpan state di RTC memory/NVS. - Untuk Uno, ingat tegangan kerja 5 V dan arus per pin yang terbatas; motor dan relay butuh supply terpisah dengan ground bersama, plus flyback diode untuk beban induktif.
7. Security dan Produksi: Dari Mainan Meja ke Produk yang Nggak Memalukan
ESP32 itu komputer jaringan. Begitu dia menyentuh Wi-Fi, dia jadi endpoint, dan setiap endpoint yang tidak punya autentikasi adalah undangan terbuka. Kalau desk buddy lo mengekspos /stats atau /led tanpa autentikasi ke LAN, siapa pun di jaringan itu bisa mengendalikannya. Untuk proyek pribadi, batasi bind ke jaringan lokal tepercaya dan sadari risikonya. Untuk apa pun yang tembus internet, autentikasi bukan opsional: itu garis minimum.
- TLS yang benar. Pakai
WiFiClientSecuredengansetCACert()berisi root CA, atau lebih baik lagi sertifikat perangkat untuk mutual TLS. Jangan pernah pakaisetInsecure(): itu mematikan verifikasi sertifikat dan mengubah HTTPS jadi HTTP dengan langkah tambahan. - Opsi keamanan flash yang tersedia di ESP32. Secure Boot (verifikasi tanda tangan bootloader dan aplikasi) serta Flash Encryption ada di ESP-IDF. Keduanya sekali diaktifkan berisiko bikin board “batu” kalau konfigurasinya salah, jadi pelajari dulu, uji di board terpisah, dan pahami bahwa key yang hilang berarti firmware yang hilang. Namespace
NVSjuga bisa dienkripsi untuk kredensial dan kalibrasi. - OTA yang tidak bisa dipalsukan. ArduinoOTA dengan password itu kenyamanan, bukan keamanan; password-nya lemah terhadap serangan di LAN. Untuk produk nyata, gunakan skema OTA dengan verifikasi tanda tangan dan partisi A/B sehingga update gagal bisa rollback.
- Provisioning yang wajar. Jangan hardcode SSID dan password. Gunakan captive portal (WiFiManager atau implementasi sendiri) atau provisioning resmi via Bluetooth. Tambahkan mekanisme reset konfigurasi lewat tombol fisik, karena “cara recovery” adalah bagian dari desain, bukan dokumentasi.
- Jangan menyimpan rahasia di source.
arduino_secrets.hyang ter-ignore git, atau NVS, atau environment variable saat build. Rahasia di repo publik harus dianggap sudah bocor dan wajib dirotasi. - Perlakukan input sebagai musuh. Endpoint HTTP lo akan di-fuzz. Validasi panjang dan tipe, batasi ukuran body, jangan pakai
Stringyang tumbuh tak terbatas dalam loop panjang (fragmentasi heap adalah penyebab crash misterius), dan jangan menaruh nama file atau path dari request ke filesystem. - Wi-Fi WPA2/WPA3 dan mDNS yang tertutup. Aktifkan WPA3 kalau router mendukungnya, dan matikan service discovery yang tidak kamu pakai.
Kesimpulan: Checklist Ahli Sebelum Nempel Proyek ke Meja
Jadi siapa yang menang, ESP32 atau Arduino Uno? Pertanyaannya salah, dan orang yang bertanya begitu biasanya sedang memilih berdasarkan estetika board, bukan berdasarkan beban kerja.
Arduino Uno menang ketika lo butuh determinisme sederhana: satu loop, timing ketat, boot instan, tegangan 5 V dengan sensor lama yang lo punya sejak 2014. Uno R4 memperbaiki keterbatasan aritmetika dan ADC-nya tanpa mengkhianati form factor dan ekosistem shield. ESP32 menang ketika lo butuh konektivitas, filesystem, TLS, dua inti untuk memisahkan pekerjaan berat dari pekerjaan ringan, atau akselerasi inferensi kecil di S3.
Tiga hal yang saya harap lo bawa pulang dari artikel ini, dan semuanya berasal dari pola kegagalan yang benar-benar sering terjadi:
- Pisahkan pengukuran dari transport. Biarkan Uno atau ADC terisolasi mengukur; biarkan ESP32 mengirim, menyimpan, dan menampilkan. Proyek “grid” jadi jauh lebih mudah dirawat dengan pemisahan ini.
- Bandingkan selalu dengan baseline termurah. Pelajaran dari studi biogas tersebut berlaku jauh melampaui biogas: kalau neural network di mikrokontroler lo tidak mengalahkan persistence baseline, lo tidak punya sistem cerdas, lo punya sistem mahal. Tulis baseline dulu, satu baris kode, sebelum menyentuh TensorFlow.
- Anggarkan daya dan anggarkan keamanan sejak hari pertama. Brownout dan endpoint tanpa autentikasi adalah dua penyebab paling membosankan dari “proyek gue tiba-tiba rusak”. Keduanya bisa dicegah dengan rancangan, bukan dengan keberuntungan.
Nah, sekarang giliran lo. ClawPal-style desk buddy itu proyek akhir pekan yang benar: satu ESP32, satu OLED, satu servo, dan satu skrip kecil di PC. Ukur dulu konsumsi dayanya, pasang kapasitor 470 µF, bind server ke localhost saja, dan jangan lupa rotasi kredensial Wi-Fi yang tadi lo hardcode. Meja lo bakal punya penghuni baru yang lebih berguna daripada kopi dingin itu, dan yang lebih penting: lo bakal paham persis kenapa dia bekerja.