Sepuluh tahun lalu, membangun perangkat yang bisa "mengirim data sensor ke internet" adalah proyek mahal yang dikerjakan tim insinyur dengan anggaran puluhan juta rupiah. Hari ini, seorang pelajar SMK bisa melakukannya di meja belajar dengan modul seharga semangkuk bakso. Itulah revolusi yang sedang kita jalani: Internet of Things (IoT) telah turun dari menara gading industri ke tangan siapa saja yang penasaran.

Yang membuat momen ini istimewa bukan sekadar murahnya perangkat keras. Yang membuatnya berbeda adalah kehadiran kecerdasan buatan (AI). Dulu sensor hanya melaporkan angka mentah — suhu 31°C, kelembapan 78%, getaran 0,4g. Kini, model AI bisa membaca ribuan angka itu dan berkata: "Pompa ini akan rusak dalam 9 hari, ganti bearing sekarang." Inilah pernikahan dua teknologi yang saling menyempurnakan: IoT menjadi indra, AI menjadi otak.

Buku ini ditulis untuk Anda yang ingin ikut serta — entah sebagai hobiis, mahasiswa, pengembang, pemilik UMKM, petani, atau pengambil keputusan di perusahaan. Saya menulisnya dengan satu keyakinan: teknologi yang hebat tidak ada gunanya bila tetap rumit. Maka setiap bab dirancang berangkat dari masalah nyata, lalu menuntun Anda langkah demi langkah — lengkap dengan tabel komponen, harga rupiah, skema rangkaian, dan kode yang benar-benar bisa di-upload ke perangkat.

Selamat datang di era ketika benda-benda di sekitar kita mulai bisa mendengar, melihat, dan berpikir. Mari kita bangun bersama.

Janji buku ini. Setiap konsep disertai contoh konkret yang bisa Anda rakit sendiri. Bila sebuah produk atau platform berganti nama saat Anda membaca, prinsipnya tetap berlaku — dan prinsip itulah yang kami utamakan.

Buku ini tebal, tetapi tidak harus dibaca berurutan. Bagian 1 dan 2 adalah fondasi — sebaiknya dibaca semua pembaca. Setelah itu, lompatlah ke bagian yang paling relevan dengan kebutuhan Anda: rumah pintar, pertanian, industri, kesehatan, kota cerdas, ritel, logistik, energi, keamanan, atau bisnis IoT.

Agar mudah dinavigasi, setiap bab memakai penanda visual yang konsisten. Berikut artinya:

Setiap bab juga menyertakan minimal satu skema/diagram, satu tabel (komponen atau perbandingan), dan satu blok kode (Arduino/ESP32, MQTT, atau Python untuk AI). Istilah teknis dijelaskan saat pertama muncul, dan dirangkum di Glosarium pada Lampiran D.

Tips. Siapkan satu papan ESP32 (sekitar Rp 45.000–60.000) sebelum membaca Bagian 2. Belajar IoT paling cepat dengan langsung mencoba — bukan sekadar membaca.

Sebelum menyentuh solder dan papan rangkaian, kita perlu memahami mengapa momen ini begitu istimewa. Bagian pertama ini adalah peta besar: apa itu IoT, mengapa AI mengubah segalanya, berapa modal sebenarnya yang dibutuhkan, komponen apa saja yang akan sering Anda jumpai, di mana kecerdasan sebaiknya diletakkan, dan ke mana arah teknologi ini bergerak. Kuasai lima bab ini, dan sisa buku akan terasa seperti menyusun balok di atas fondasi yang kokoh.

Ada pertanyaan yang pantas diajukan sebelum membeli satu pun komponen: jika Internet of Things sudah digadang-gadang sejak 1999, mengapa baru sekarang ia benar-benar meledak? Jawabannya bukan satu hal tunggal, melainkan empat kurva biaya yang turun nyaris bersamaan — perangkat keras, konektivitas, penyimpanan awan, dan kecerdasan buatan. Ketika keempatnya menyentuh titik "cukup murah untuk dicoba siapa saja", terjadilah ledakan.

1.1 Definisi yang Jujur: Apa Itu IoT?

Internet of Things adalah gagasan sederhana yang sering dibungkus istilah rumit. Intinya: benda fisik yang biasanya "bisu" diberi kemampuan mengindra, berkomunikasi, dan kadang bertindak — lalu dihubungkan ke jaringan agar datanya bisa dipakai dari jarak jauh. Sebuah termometer biasa hanya menunjukkan angka pada layarnya. Termometer IoT mengirim angka itu ke ponsel Anda, ke basis data, dan ke model yang bisa memperingatkan sebelum kulkas vaksin terlalu hangat.

Setiap sistem IoT, sekecil apa pun, selalu memiliki empat lapis yang sama. Mengenali keempat lapis ini sejak awal akan menyelamatkan Anda dari kebingungan di bab-bab teknis nanti.

Lapis pertama, perangkat (edge), adalah tempat dunia fisik bertemu silikon: sensor membaca besaran (suhu, cahaya, getaran), mikrokontroler mengolahnya, dan aktuator (relay, motor, LED) bertindak. Lapis kedua, konektivitas, memindahkan data — bisa WiFi di rumah, LoRa di ladang, atau 4G di truk. Lapis ketiga, platform, menampung, menyimpan, dan merapikan data. Lapis keempat, aplikasi dan AI, mengubah data menjadi keputusan: grafik, peringatan, atau prediksi.

1.2 Empat Kurva Biaya yang Bertemu

Mengapa "sekarang"? Karena empat hal yang dulu mahal kini nyaris gratis. Tabel berikut merangkum penurunan yang mengubah IoT dari proyek korporasi menjadi proyek akhir pekan.

Biaya. Sebuah node IoT lengkap — ESP32, sensor suhu-kelembapan, kabel, dan catu daya — kini bisa dirakit di bawah Rp 100.000. Bandingkan dengan satu termohigrometer industri bermerek yang harganya bisa sepuluh kali lipat dan tetap tidak terhubung internet.

1.3 Pergeseran Besar: dari Data Mentah ke Keputusan

Selama dua dekade, IoT terjebak pada satu masalah: ia menghasilkan terlalu banyak data dan terlalu sedikit makna. Sebuah pabrik bisa memasang seribu sensor getaran, lalu tenggelam dalam jutaan baris angka yang tak sempat dibaca siapa pun. Di sinilah AI mengubah permainan. Model pembelajaran mesin bisa membaca pola yang luput dari mata manusia dan menerjemahkannya menjadi kalimat yang dapat ditindaklanjuti.

Perhatikan tiga kategori kecerdasan yang paling sering dipakai pada data IoT, karena ketiganya akan muncul berulang sepanjang buku ini:

• Deteksi anomali — "nilai ini tidak normal". Mendeteksi kebocoran, kerusakan, atau penyusup tanpa perlu aturan kaku.
• Prediksi (forecasting) — "ini akan terjadi". Memperkirakan kapan bearing aus, kapan tanah perlu disiram, atau kapan beban listrik memuncak.
• Klasifikasi — "ini termasuk jenis apa". Mengenali suara mesin yang sehat vs rusak, atau membedakan manusia dari hewan di rekaman kamera.

1.4 Contoh Konkret: Pompa Air yang "Bercerita"

Bayangkan sebuah pompa air di gedung bertingkat. Tanpa IoT, pompa ini bisu sampai ia mati total dan air berhenti mengalir — barulah teknisi datang panik. Dengan satu sensor getaran murah dan ESP32, kita bisa membaca "denyut" pompa setiap detik. Berikut kode minimal yang membaca getaran dan mengirim sinyal ketika melewati ambang. Ini sengaja sederhana — kita akan menyempurnakannya di bab-bab lanjut.

// Bab 1 — Pembaca getaran pompa paling sederhana (ESP32 + sensor SW-420)
// Tujuan: kenalkan pola baca-sensor → ambil keputusan kecil di edge.

const int PIN_GETAR = 34;      // pin ADC ESP32
const float AMBANG  = 2.5;     // ambang "tidak normal" (volt, hasil kalibrasi)

void setup() {
  Serial.begin(115200);
  analogReadResolution(12);    // ESP32: 0..4095
}

void loop() {
  int raw = analogRead(PIN_GETAR);
  float volt = raw * (3.3 / 4095.0);

  Serial.printf("getaran=%.2f V\n", volt);

  if (volt > AMBANG) {
    // Keputusan kecil langsung di perangkat — belum perlu cloud.
    Serial.println("PERINGATAN: getaran di atas normal!");
  }
  delay(1000);                 // 1 sampel / detik
}

Kode di atas baru "level termometer": ia bereaksi pada satu ambang tetap. AI masuk ketika kita menyadari bahwa pompa yang sehat punya pola getaran tertentu, dan pola itu bergeser perlahan sebelum kerusakan. Daripada satu ambang kaku, model belajar bentuk normal dan berteriak ketika bentuk itu berubah — itulah deteksi anomali, dan kita akan membangunnya di Bab 11 dan Bab 26.

Awas. Pin ADC2 pada ESP32 (mis. GPIO 0, 2, 4, 12–15, 25–27) tidak dapat dipakai saat WiFi aktif. Untuk node yang terhubung WiFi, selalu pakai pin ADC1 (GPIO 32–39). Salah pilih pin adalah penyebab nomor satu pembacaan "macet di 0" yang membingungkan pemula.

1.5 Konteks Indonesia: Mengapa Ini Relevan Sekarang

Indonesia punya kombinasi yang langka: pasar besar, masalah nyata yang berlimpah, dan biaya tenaga teknis yang kompetitif. Petani yang gagal panen karena telat menyiram, gudang dingin yang merusak vaksin saat listrik padam, pabrik yang berhenti karena mesin jebol tanpa peringatan — semua ini adalah masalah yang bisa dijawab perangkat seharga ratusan ribu rupiah. Justru karena infrastruktur belum sempurna, dampak satu sensor yang dipasang tepat sasaran terasa jauh lebih besar dibanding di negara yang sudah serba otomatis.

Tantangannya pun khas: listrik yang tidak selalu stabil (sehingga manajemen daya dan baterai jadi penting — Bab 13), jangkauan internet yang tidak merata (sehingga LoRa dan 4G fallback jadi relevan — Bab 28 dan 52), serta kebutuhan akan komponen yang mudah didapat di pasar lokal dan marketplace. Buku ini menulis dengan kenyataan itu, bukan dengan asumsi laboratorium di negara empat musim.

1.6 Apa yang Akan Anda Bisa Setelah Buku Ini

Di akhir perjalanan, Anda diharapkan mampu: merakit node sensor dari nol, memilih protokol komunikasi yang tepat untuk situasi, menampung data di cloud gratis, membangun dashboard sendiri, menambahkan lapisan AI sederhana, dan — yang paling penting — menilai kapan sebuah ide IoT layak diteruskan menjadi produk. Bab ini menanam pohonnya; bab-bab berikutnya menumbuhkan cabangnya.

Resep ringkas bab ini. (1) Pahami empat lapis IoT. (2) Sadari empat kurva biaya yang turun. (3) Ingat tiga peran AI: anomali, prediksi, klasifikasi. (4) Mulai berpikir dalam "masalah → sensor → keputusan", bukan "gawai keren → cari kegunaan".

Hambatan terbesar untuk mulai belajar IoT bukan kecerdasan, melainkan rasa takut bahwa "ini pasti mahal dan rumit". Bab ini meruntuhkan ketakutan itu dengan angka yang jujur. Kita akan menyusun tiga tingkat anggaran — dari satu lembar uang seratus ribu hingga setengah juta — dan melihat persis apa yang bisa dibangun di setiap tingkat.

2.1 Tiga Tingkat Anggaran

Tidak ada satu "harga IoT". Yang ada adalah pilihan: seberapa jauh Anda ingin melangkah pada percobaan pertama. Berikut tiga paket yang sengaja disusun bertingkat, semuanya memakai komponen yang mudah ditemukan di marketplace lokal.

Tips. Untuk percobaan pertama, beli paket Hemat saja. Menyelesaikan satu proyek kecil sampai tuntas mengajarkan lebih banyak daripada menumpuk komponen mahal yang akhirnya menganggur di laci. Belanja bertahap mengikuti proyek, bukan sekaligus mengikuti nafsu.

2.2 Rincian Paket Hemat — Apa Saja dan Untuk Apa

Mari bongkar paket Rp 95.000 agar Anda tahu setiap rupiah pergi ke mana. Daftar ini sekaligus mengenalkan nama-nama komponen yang akan terus muncul.

Itu saja yang dibutuhkan untuk proyek "Hello, World!" versi IoT: alat yang membaca suhu ruangan dan menampilkannya — bahkan mengirimnya ke ponsel. Rangkaiannya hanya tiga kabel.

2.3 Proyek Pertama: Termometer yang Terhubung

Berikut program lengkap yang membaca DHT22 dan menampilkan hasil ke Serial Monitor. Belum ke internet — itu Bab 7 dan 8 — tapi inilah pondasi yang akan kita kembangkan. Pasang pustaka DHT sensor library (Adafruit) lebih dulu lewat Library Manager.

// Bab 2 — Termometer terhubung, langkah pertama (ESP32 + DHT22)
#include <DHT.h>

#define PIN_DHT  4
#define TIPE_DHT DHT22

DHT dht(PIN_DHT, TIPE_DHT);

void setup() {
  Serial.begin(115200);
  dht.begin();
  Serial.println("Termometer IoT siap.");
}

void loop() {
  float suhu     = dht.readTemperature();   // derajat Celsius
  float lembap   = dht.readHumidity();       // persen

  if (isnan(suhu) || isnan(lembap)) {
    Serial.println("Gagal baca sensor — cek kabel data & VCC.");
  } else {
    Serial.printf("Suhu: %.1f C  |  Kelembapan: %.1f %%\n", suhu, lembap);
  }
  delay(2000);   // DHT22 maksimal ~0.5 Hz, jangan lebih cepat dari 2 detik
}

Awas. DHT22 lambat — ia hanya bisa dibaca sekali tiap dua detik. Membaca lebih cepat menghasilkan nan (not-a-number). Jika hasil Anda berkedip antara angka dan "gagal baca", perlambat delay() sebelum menyalahkan sensornya.

2.4 Biaya Tersembunyi yang Sering Dilupakan

Harga komponen hanyalah puncak gunung es. Pemula sering kaget oleh biaya yang tidak tampak di daftar belanja. Mengenalinya sejak awal membuat anggaran Anda jujur.

• Waktu belajar — biaya terbesar dan paling sering diremehkan. Anggap ini investasi, bukan pemborosan.
• Komponen yang terbakar — salah pasang tegangan akan mengorbankan satu-dua modul. Sediakan cadangan untuk komponen kritis.
• Catu daya yang layak — banyak proyek gagal bukan karena kode, melainkan adaptor murah yang tegangannya jatuh. Bab 13 membahas ini tuntas.
• Casing & pemasangan — untuk proyek nyata di luar meja, kotak tahan air dan dudukan bisa lebih mahal dari elektroniknya.

Biaya. Sisihkan kira-kira 20% dari anggaran komponen untuk "ongkos belajar" — komponen rusak, kabel tambahan, adaptor pengganti. Anggaran yang menyediakan ruang gagal adalah anggaran yang realistis.

2.5 Peta Jalan Belanja Mengikuti Buku

Daripada membeli semuanya sekarang, ikuti irama buku. Setiap bagian punya "belanja minimum" yang masuk akal, sehingga uang Anda mengalir seiring keterampilan tumbuh.

Dengan pola ini, total pengeluaran tersebar dan setiap pembelian langsung terpakai pada proyek yang sedang Anda kerjakan — bukan menumpuk sebagai "akan dipakai nanti" yang tak pernah tiba.

Sebelum membangun rumah, tukang mengenal batu bata, semen, dan kayunya. Begitu pula IoT. Bab ini adalah katalog kerja: kita berkenalan dengan keluarga komponen yang akan Anda pakai berulang kali — apa kekuatannya, kapan dipilih, berapa harganya, dan jebakan apa yang menanti. Simpan bab ini sebagai rujukan; Anda akan kembali ke sini sepanjang buku.

3.1 Otak: Memilih Mikrokontroler

Mikrokontroler adalah komputer kecil dalam satu chip — punya prosesor, memori, dan kaki (pin) untuk berbicara dengan dunia luar. Untuk IoT pemula hingga menengah, tiga keluarga mendominasi pasar Indonesia. Memilih yang tepat menghemat uang dan frustrasi.

Tips. Jika ragu, pilih ESP32. Ia cukup kuat untuk hampir semua proyek di buku ini, punya banyak pin ADC, mendukung WiFi dan Bluetooth sekaligus, dan dokumentasinya melimpah. ESP8266 menjadi masuk akal hanya ketika Anda membuat banyak node sekaligus dan setiap rupiah dihitung.

3.2 Indra: Keluarga Sensor

Sensor mengubah besaran fisik menjadi sinyal listrik yang bisa dibaca mikrokontroler. Mereka terbagi kasar menjadi dua: analog (mengeluarkan tegangan yang berubah halus, dibaca lewat pin ADC) dan digital (mengirim angka lewat protokol seperti I2C, SPI, atau one-wire). Tabel berikut adalah "sensor sejuta umat" yang menutup mayoritas kebutuhan.

Awas. Banyak sensor murah dirancang untuk 5V, sementara pin ESP32 hanya tahan 3,3V. Memberi 5V langsung ke pin data ESP32 bisa merusaknya permanen. Periksa lembar data, dan gunakan level shifter atau pembagi tegangan bila perlu. Ini kesalahan klasik yang menewaskan papan pertama banyak orang.

3.3 Tangan: Aktuator

Jika sensor adalah indra, aktuator adalah tangan — bagian yang membuat IoT bertindak, bukan sekadar mengamati. Inilah yang membedakan "pemantauan" dari "otomasi".

• Relay — saklar elektronik untuk menyalakan/mematikan perangkat tegangan tinggi (lampu, pompa, AC). Tersedia 1, 2, 4, 8 channel.
• Motor & servo — menggerakkan tirai, katup, pintu, atau lengan. Servo untuk sudut presisi; motor DC untuk putaran kontinu.
• Solenoid valve — katup elektrik untuk membuka/menutup aliran air atau gas. Jantung sistem irigasi otomatis.
• Buzzer & LED — keluaran paling sederhana: alarm suara dan indikator visual.

Awas — listrik tegangan tinggi. Begitu proyek menyentuh 220V (lampu, pompa, peralatan rumah), risiko bukan lagi "papan terbakar" tetapi "manusia tersengat". Jangan bekerja pada rangkaian 220V dalam keadaan hidup, gunakan relay dengan isolasi optocoupler, dan bila ragu, libatkan teknisi listrik. Tidak ada proyek yang sepadan dengan nyawa.

3.4 Contoh: Menyalakan Relay dari Logika Sensor

Berikut kode yang menggabungkan indra dan tangan: jika suhu melewati ambang, kipas (lewat relay) menyala. Inilah otomasi sejati dalam bentuk paling sederhana.

// Bab 3 — Termostat mini: sensor → keputusan → aktuator
#include <DHT.h>
#define PIN_DHT   4
#define PIN_RELAY 26
DHT dht(PIN_DHT, DHT22);

const float SUHU_NYALA = 30.0;   // kipas nyala di atas 30 C
const float SUHU_MATI  = 28.0;   // mati di bawah 28 C (histeresis)

void setup() {
  Serial.begin(115200);
  dht.begin();
  pinMode(PIN_RELAY, OUTPUT);
  digitalWrite(PIN_RELAY, LOW);
}

void loop() {
  float suhu = dht.readTemperature();
  if (!isnan(suhu)) {
    if (suhu > SUHU_NYALA) digitalWrite(PIN_RELAY, HIGH);  // kipas ON
    else if (suhu < SUHU_MATI) digitalWrite(PIN_RELAY, LOW); // kipas OFF
    Serial.printf("Suhu %.1f C — kipas %s\n", suhu,
                  digitalRead(PIN_RELAY) ? "ON" : "OFF");
  }
  delay(2000);
}

Tips — histeresis. Perhatikan dua ambang (30 dan 28), bukan satu. Tanpa jeda ini, relay akan "berkedip" gila-gilaan saat suhu menggantung tepat di ambang — bunyi klik-klik yang memperpendek umur relay. Histeresis adalah trik kecil yang membedakan kode amatir dari kode yang awet di lapangan.

3.5 Penghubung dan Awan

Komponen terakhir bukan benda fisik, melainkan layanan. Setelah perangkat membaca dan bertindak, datanya perlu tempat berkumpul. Pilihan "awan" untuk pemula sangat ramah: banyak yang gratis untuk skala belajar. Kita akan membahasnya tuntas di Bagian 2, tetapi kenali namanya sekarang.

Dengan empat kategori ini — otak, indra, tangan, dan awan — Anda memegang seluruh kosakata material IoT. Sisanya hanyalah variasi: sensor yang lebih khusus, mikrokontroler yang lebih kuat, atau platform yang lebih besar. Polanya tetap sama.

Pertanyaan yang akan terus muncul begitu Anda menambahkan kecerdasan: di mana otaknya berpikir? Apakah model AI berjalan di chip kecil di dalam perangkat (edge), atau di server raksasa nun jauh di sana (cloud)? Tidak ada jawaban tunggal yang benar — ada pertukaran (trade-off), dan bab ini mengajari Anda membaca pertukaran itu seperti membaca peta.

4.1 Spektrum, Bukan Saklar

Banyak pemula mengira pilihannya hitam-putih: semua di perangkat, atau semua di cloud. Kenyataannya adalah spektrum. Kebanyakan sistem matang menempatkan kecerdasan secara berlapis — sedikit di edge untuk reaksi cepat, banyak di cloud untuk analisis berat. Memahami spektrum ini mencegah Anda membayar mahal untuk hal yang seharusnya murah.

4.2 Tabel Pertukaran yang Menentukan

Keputusan edge vs cloud bermuara pada lima dimensi. Letakkan kebutuhan proyek Anda di samping tabel ini, dan jawabannya biasanya muncul sendiri.

Aturan praktis. Letakkan di edge hal yang harus cepat, privat, atau tetap jalan offline (rem darurat, deteksi wajah di pintu, sensor di ladang tanpa sinyal). Letakkan di cloud hal yang butuh model besar, riwayat panjang, atau sering diperbarui (prediksi tren, analisis lintas-perangkat, dashboard manajemen).

4.3 TinyML: AI yang Muat dalam Chip Seharga Bakso

Kejutan terbesar dekade ini adalah TinyML — teknik menjalankan model pembelajaran mesin pada mikrokontroler dengan RAM hanya ratusan kilobita. Sebuah ESP32 kini bisa mengenali kata "nyala/mati" dari suara, membedakan getaran mesin sehat dari rusak, atau mendeteksi gerakan jatuh — semua tanpa internet. Modelnya dilatih di komputer, dikompresi (quantization), lalu ditanam sebagai array di dalam firmware.

# Bab 4 — Melatih model kecil di komputer, lalu ekspor untuk edge
# (Python, TensorFlow) — kelak dikonversi ke TensorFlow Lite Micro

import tensorflow as tf

# Model mungil: cocok untuk anomali getaran 1-dimensi
model = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation='relu', input_shape=(50,)),
    tf.keras.layers.Dense(8,  activation='relu'),
    tf.keras.layers.Dense(1,  activation='sigmoid')   # 0=normal, 1=anomali
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=30, validation_split=0.2)

# Konversi + kuantisasi ke 8-bit → muat di ESP32 (< 50 KB)
conv = tf.lite.TFLiteConverter.from_keras_model(model)
conv.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = conv.convert()
open('anomali.tflite', 'wb').write(tflite_model)
print('Ukuran model:', len(tflite_model), 'byte')

File anomali.tflite lalu diubah menjadi array C dan disertakan dalam sketsa Arduino, dijalankan oleh pustaka TensorFlow Lite for Microcontrollers. Inilah keajaiban edge: kecerdasan yang dulu butuh server kini hidup di benda seukuran kotak korek api, tanpa pernah menyentuh internet.

Awas. TinyML bukan sihir tanpa batas. Model di mikrokontroler harus kecil dan sederhana — jangan harap menjalankan pengenalan wajah penuh atau model bahasa besar di ESP32. Untuk tugas berat, gabungkan: edge menyaring (deteksi ada-tidaknya peristiwa), cloud menganalisis (apa peristiwanya). Pola "saring di edge, analisis di cloud" ini menghemat bandwidth sekaligus biaya.

4.4 Pola Hibrida: yang Terbaik dari Dua Dunia

Sistem produksi yang matang jarang murni edge atau murni cloud. Mereka hibrida. Contoh CCTV cerdas: ESP32-CAM mendeteksi gerakan di edge (cepat, hemat data), lalu hanya mengirim potongan gambar saat ada gerakan ke cloud, yang menjalankan pengenalan wajah berat dan menyimpan riwayat. Hasilnya: bandwidth turun drastis, respons tetap cepat, dan analisis tetap canggih.

Inilah cara berpikir yang ingin kami tanamkan: jangan tanya "edge atau cloud", tanya "tugas mana di edge, tugas mana di cloud". Setiap bab solusi di buku ini akan menerapkan pembagian ini secara eksplisit.

Menutup Bagian 1, kita menengok ke depan. Tren bukan ramalan kosong — ia memberi tahu ke mana investasi waktu Anda akan paling berbuah. Lima arus besar berikut sedang membentuk IoT, dan masing-masing membuka pintu untuk pembuat individu, bukan hanya korporasi.

5.1 Lima Arus Besar

5.2 Mengapa "Generative AI" Mengubah IoT Juga

Gelombang model bahasa besar (LLM) tampak jauh dari sensor dan relay, tetapi dampaknya nyata. Pertama, ia mempermudah pembuatan: pemula kini bisa meminta bantuan menulis kode firmware atau query data dengan bahasa sehari-hari. Kedua, ia membuka antarmuka baru: bayangkan bertanya ke rumah Anda, "kenapa tagihan listrik bulan ini naik?" dan sistem menjawab dengan menafsirkan data sensor energi. IoT memberi data dunia nyata; AI generatif memberi bahasa untuk berdialog dengan data itu.

Tips. Jangan kejar setiap tren. Kuasai dasar (Bagian 1–2) dulu sampai mahir, lalu pilih satu tren yang paling cocok dengan masalah yang ingin Anda pecahkan. Penguasaan mendalam pada satu hal mengalahkan pengetahuan dangkal pada sepuluh hal.

5.3 Yang Tidak Berubah

Di tengah hiruk-pikuk tren, ada yang abadi. Fondasi tidak pernah usang: cara membaca sensor dengan benar, memilih protokol yang tepat, mengamankan perangkat, dan mengelola daya. Produk yang berganti nama, platform yang tutup, chip generasi baru — semua datang dan pergi. Tetapi pembuat yang menguasai prinsip akan selalu bisa berpindah ke alat baru dalam hitungan hari. Itulah sebabnya buku ini menekankan prinsip di atas merek, dan mengapa keterampilan yang Anda bangun di sini akan tetap berharga lama setelah edisi ini dicetak.

Dengan ini, fondasi selesai. Anda kini tahu apa itu IoT, berapa modalnya, komponen apa yang dipakai, di mana kecerdasan diletakkan, dan ke mana arah angin bertiup. Bagian 2 akan mengubah pengetahuan ini menjadi keterampilan: kita mulai benar-benar merakit, memrogram, dan menghubungkan perangkat ke dunia.

Bagian satu menanam fondasi pemikiran; bagian dua mengotori tangan Anda. Mulai halaman ini kita berhenti bicara teori dan mulai merakit, memrogram, dan menghubungkan perangkat ke dunia nyata. Setiap bab berangkat dari satu kebutuhan konkret — "saya ingin tahu suhu gudang dari ponsel", "saya ingin lampu menyala otomatis saat gelap" — lalu menuntun Anda sampai perangkat itu benar-benar berjalan. Siapkan satu papan ESP32, kabel data, dan secangkir kopi. Kita akan banyak mencoba, sesekali gagal, dan belajar dari keduanya.

Sebuah starter kit yang baik bukan yang paling lengkap, melainkan yang paling sering dipakai. Tiga komponen berikut — ESP32-CAM untuk mata, DHT22 untuk indra lingkungan, dan modul relay untuk tangan — menutup mayoritas proyek pemula: pemantauan, otomasi, dan pengawasan visual. Bab ini menyusun kit itu rupiah demi rupiah, lalu menunjukkan cara menyatukannya menjadi satu perangkat yang berfungsi.

6.1 Apa Isi Kit Termurah yang Masuk Akal

Banyak "starter kit" di marketplace dijual seharga ratusan ribu dengan puluhan komponen yang separuhnya tak pernah disentuh. Kita membalik logikanya: beli sedikit, tetapi pilih yang menutup paling banyak skenario. Tabel berikut adalah kit Rp 200 ribuan yang bisa membuat empat proyek berbeda.

Tips. ESP32-CAM tidak punya port USB bawaan — Anda butuh modul FTDI (USB-TTL) terpisah untuk mengunggah program, atau papan "ESP32-CAM-MB" yang sudah menyertakannya. Banyak pemula frustrasi karena tidak tahu ini dan mengira papannya rusak. Belilah versi dengan papan pemrogram bila ragu.

6.2 Mengenal ESP32-CAM Lebih Dekat

ESP32-CAM adalah keajaiban harga: kamera 2 megapiksel, WiFi, slot microSD, dan prosesor dual-core — semua di papan seukuran perangko seharga semangkuk mi ayam. Tetapi ia punya kepribadian yang rewel: pin terbatas, butuh catu daya yang kuat, dan mode unggah yang khusus.

Awas — brownout ESP32-CAM. Gejala paling umum: papan terus me-restart dengan pesan Brownout detector was triggered. Penyebabnya hampir selalu catu daya kurang arus (kabel USB tipis atau port laptop). Solusi: pakai adaptor 5V minimal 2A dengan kabel pendek dan tebal. Jangan menyalakan ESP32-CAM dari pin 3V3 papan lain.

6.3 Diagram Koneksi: ESP32 + DHT22 + Relay

Mari satukan indra dan tangan dalam satu rangkaian. ESP32 membaca suhu dari DHT22 di GPIO 4, dan mengendalikan relay di GPIO 26. Perhatikan jalur catu daya: DHT22 dan modul relay sama-sama mengambil 3V3 dan GND dari ESP32.

6.4 Kode Gabungan: Baca, Putuskan, Bertindak

Berikut sketsa lengkap yang menyatukan ketiga komponen: membaca suhu, menyalakan relay bila panas, dan mencetak status. Inilah "perangkat IoT pertama yang utuh" — masih lokal, tetapi sudah otonom.

// Bab 6 — Node serbaguna: DHT22 + Relay (ESP32)
// Membaca suhu, menyalakan kipas/pompa via relay dengan histeresis.
#include <DHT.h>

#define PIN_DHT    4
#define PIN_RELAY  26
#define TIPE_DHT   DHT22

DHT dht(PIN_DHT, TIPE_DHT);

const float SUHU_NYALA = 31.0;   // relay ON di atas 31 C
const float SUHU_MATI  = 29.0;   // relay OFF di bawah 29 C
bool relayAktif = false;

void setup() {
  Serial.begin(115200);
  dht.begin();
  pinMode(PIN_RELAY, OUTPUT);
  digitalWrite(PIN_RELAY, LOW);  // mulai dalam keadaan mati
  Serial.println("Node DHT22 + Relay siap.");
}

void loop() {
  float suhu   = dht.readTemperature();
  float lembap = dht.readHumidity();

  if (isnan(suhu) || isnan(lembap)) {
    Serial.println("Gagal baca DHT22 — periksa kabel data.");
    delay(2000);
    return;
  }

  // Keputusan dengan histeresis (cegah relay berkedip)
  if (!relayAktif && suhu > SUHU_NYALA) {
    relayAktif = true;
    digitalWrite(PIN_RELAY, HIGH);
  } else if (relayAktif && suhu < SUHU_MATI) {
    relayAktif = false;
    digitalWrite(PIN_RELAY, LOW);
  }

  Serial.printf("Suhu %.1f C | Lembap %.1f %% | Relay %s\n",
                suhu, lembap, relayAktif ? "ON" : "OFF");
  delay(2000);
}

Awas. Relay murah ada dua tipe: active-HIGH (nyala saat pin HIGH) dan active-LOW (nyala saat pin LOW). Jika relay Anda menyala terbalik dari kode, balikkan logika HIGH/LOW. Periksa lewat suara "klik" dan LED indikator pada modul relay sebelum menyambung beban 220V.

6.5 Studi Kasus: Pemantau Suhu Gudang Logistik Kecil

Sebuah toko bahan pangan beku di Bandung kehilangan stok senilai jutaan rupiah karena freezer mati semalaman tanpa diketahui. Dengan kit Rp 200 ribuan ini, pemiliknya memasang node sederhana: DHT22 di dalam ruang pendingin, relay menyalakan lampu indikator merah dan buzzer bila suhu naik di atas ambang, dan — di bab berikutnya — notifikasi ke ponsel.

Biaya. Satu node pemantau freezer ini menelan modal di bawah Rp 150.000 — lebih murah dari nilai satu kantong daging beku yang terselamatkan. Inilah pola "ROI satu insiden" yang membuat IoT mudah dijual ke pemilik usaha kecil: bukan fitur canggih, melainkan kerugian yang dicegah.

Perangkat yang membaca sensor tetapi datanya hanya muncul di Serial Monitor belum benar-benar "IoT" — ia masih buta dari jarak jauh. Bab ini menghubungkan node Anda ke dunia: platform yang menampung data, menampilkannya di dashboard, dan mengirim notifikasi ke ponsel. Kabar baiknya, ketiga platform terbaik untuk pemula punya tier gratis yang sangat memadai.

7.1 Memilih Platform: Tiga Filosofi Berbeda

Ketiga platform populer ini bukan saling menggantikan — mereka melayani kebutuhan berbeda. Blynk mengejar kecepatan ("dari nol ke app dalam 10 menit"), ThingsBoard mengejar kelengkapan (dashboard industri, aturan, multi-tenant), dan Home Assistant mengejar integrasi rumah (menyatukan ratusan merek perangkat).

Tips. Untuk proyek pertama, mulai dengan Blynk. Anda akan melihat suhu dari node Bab 6 di layar ponsel dalam waktu kurang dari setengah jam — kemenangan kecil yang penting untuk menjaga semangat. Pindah ke ThingsBoard atau Home Assistant ketika kebutuhan tumbuh.

7.2 Resep: Mengirim Suhu ke Blynk

Blynk bekerja dengan konsep "virtual pin" — slot data bernomor (V0, V1, ...) yang menghubungkan kode di perangkat dengan widget di app. Berikut langkah ringkas dan kodenya.

1. Buat akun di Blynk, buat Template baru, salin BLYNK_TEMPLATE_ID dan BLYNK_AUTH_TOKEN.
2. Di app mobile, tambahkan widget Gauge ke virtual pin V0 (suhu) dan V1 (kelembapan).
3. Unggah kode berikut ke ESP32.

// Bab 7 — Kirim suhu & kelembapan ke Blynk Cloud (ESP32 + DHT22)
#define BLYNK_TEMPLATE_ID   "TMPLxxxxxx"
#define BLYNK_TEMPLATE_NAME "Monitor Suhu"
#define BLYNK_AUTH_TOKEN    "token-rahasia-anda"

#include <WiFi.h>
#include <BlynkSimpleEsp32.h>
#include <DHT.h>

#define PIN_DHT 4
DHT dht(PIN_DHT, DHT22);

char ssid[] = "NamaWiFiAnda";
char pass[] = "PasswordWiFi";

BlynkTimer timer;

void kirimSensor() {
  float suhu   = dht.readTemperature();
  float lembap = dht.readHumidity();
  if (isnan(suhu) || isnan(lembap)) return;

  Blynk.virtualWrite(V0, suhu);     // tampil di Gauge V0
  Blynk.virtualWrite(V1, lembap);   // tampil di Gauge V1

  if (suhu > 35.0) {
    Blynk.logEvent("suhu_tinggi", "Suhu melewati 35 C!");  // notifikasi
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
  timer.setInterval(5000L, kirimSensor);   // tiap 5 detik
}

void loop() {
  Blynk.run();
  timer.run();
}

Awas. Jangan pernah meng-commit token Blynk atau password WiFi ke repositori publik (GitHub). Token adalah kunci ke perangkat Anda; siapa pun yang memilikinya bisa mengendalikannya. Untuk proyek serius, simpan kredensial di file terpisah yang di-ignore, atau gunakan WiFiManager agar password dimasukkan saat pemasangan, bukan ditulis di kode.

7.3 ThingsBoard dan Home Assistant Secara Singkat

Ketika kebutuhan melampaui "lihat angka di ponsel", dua platform ini mengambil alih. ThingsBoard menerima data lewat MQTT atau HTTP, menyimpannya sebagai telemetri deret-waktu, dan memungkinkan Anda membangun dashboard kaya dengan grafik, peta, dan tabel — plus rule engine yang memicu aksi (kirim email, panggil API) saat kondisi terpenuhi. Home Assistant berfokus pada rumah: ia menyatukan lampu Philips Hue, colokan pintar, kamera, dan perangkat ESP buatan sendiri (lewat ESPHome) di satu antarmuka, dengan otomasi berbasis "jika-maka" yang ramah non-programmer.

7.4 Studi Kasus: Dashboard Multi-Sensor Kos-Kosan

Seorang pemilik kos 12 kamar ingin memantau penggunaan air dan listrik tiap lantai. Ia memasang empat node ESP32 (sensor arus + flow meter) yang mengirim ke ThingsBoard self-host di Raspberry Pi. Dashboard menampilkan grafik per lantai, dan rule engine mengirim email bila konsumsi melonjak tak wajar — indikasi keran bocor atau pemakaian berlebih.

Bagaimana sebenarnya data berpindah dari sensor ke server? Lewat protokol — kesepakatan tentang cara dua mesin berbicara. Tiga protokol mendominasi IoT, masing-masing dengan watak sendiri. Memahami kapan memakai yang mana adalah salah satu keputusan paling menentukan dalam desain sistem Anda: salah pilih, dan perangkat boros baterai atau dashboard Anda lambat.

8.1 Tiga Protokol, Tiga Watak

MQTT seperti kantor pos berlangganan: perangkat "menerbitkan" pesan ke topik, dan siapa pun yang "berlangganan" topik itu menerimanya. HTTP seperti mengirim surat dan menunggu balasan: cocok untuk permintaan sesekali. WebSocket seperti saluran telepon yang tetap terbuka: ideal untuk data dua arah yang terus-menerus.

Tips. Untuk 90% proyek IoT, jawabannya adalah MQTT. Ia ringan, hemat daya, tahan jaringan buruk (pesan diantre saat putus), dan punya pola pub/sub yang elegan untuk banyak perangkat. Gunakan HTTP hanya untuk pengiriman jarang atau integrasi dengan API yang menuntutnya.

8.2 Anatomi MQTT: Broker, Topik, QoS

Jantung MQTT adalah broker — server perantara (mis. Mosquitto, HiveMQ) yang menerima semua pesan dan meneruskannya. Perangkat tidak pernah bicara langsung satu sama lain; semua lewat broker. Pesan diberi label topik hierarkis seperti rumah/dapur/suhu, sehingga pelanggan bisa memilih persis apa yang ingin didengar.

MQTT juga punya QoS (Quality of Service) bertingkat: QoS 0 ("kirim sekali, tak peduli sampai"), QoS 1 ("pasti sampai, mungkin ganda"), QoS 2 ("pasti sampai persis sekali"). Pilih sesuai kepentingan data: pembacaan suhu rutin cukup QoS 0; perintah membuka pintu pantas QoS 1 atau 2.

8.3 Kode: ESP32 Mengirim via MQTT

Berikut sketsa lengkap memakai pustaka PubSubClient — node yang menerbitkan suhu ke topik dan sekaligus berlangganan topik perintah untuk menyalakan relay dari jarak jauh.

// Bab 8 — Node MQTT dua-arah (ESP32 + PubSubClient)
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

const char* ssid     = "NamaWiFi";
const char* password = "PasswordWiFi";
const char* mqttHost = "broker.hivemq.com";   // broker publik untuk uji coba
const int   mqttPort = 1883;

#define PIN_DHT   4
#define PIN_RELAY 26
DHT dht(PIN_DHT, DHT22);

WiFiClient   wifiClient;
PubSubClient mqtt(wifiClient);

void onPesan(char* topik, byte* payload, unsigned int len) {
  String pesan;
  for (unsigned int i = 0; i < len; i++) pesan += (char)payload[i];
  // Topik perintah: "rumah/dapur/relay" dengan isi "ON" / "OFF"
  if (String(topik) == "rumah/dapur/relay") {
    digitalWrite(PIN_RELAY, pesan == "ON" ? HIGH : LOW);
  }
}

void sambungUlang() {
  while (!mqtt.connected()) {
    String idKlien = "esp32-" + String((uint32_t)ESP.getEfuseMac(), HEX);
    if (mqtt.connect(idKlien.c_str())) {
      mqtt.subscribe("rumah/dapur/relay");   // dengarkan perintah
    } else {
      delay(2000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  pinMode(PIN_RELAY, OUTPUT);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  mqtt.setServer(mqttHost, mqttPort);
  mqtt.setCallback(onPesan);
}

void loop() {
  if (!mqtt.connected()) sambungUlang();
  mqtt.loop();

  static unsigned long terakhir = 0;
  if (millis() - terakhir > 5000) {     // publish tiap 5 detik
    terakhir = millis();
    float suhu = dht.readTemperature();
    if (!isnan(suhu)) {
      char buf[8];
      dtostrf(suhu, 4, 1, buf);
      mqtt.publish("rumah/dapur/suhu", buf);   // terbitkan ke topik
    }
  }
}

Awas. Broker publik seperti broker.hivemq.com hanya untuk belajar — siapa pun bisa membaca topik Anda. Untuk produksi, jalankan broker sendiri (Mosquitto di VPS/Pi) dengan autentikasi username-password dan TLS, atau pakai broker berbayar dengan kontrol akses. Jangan kirim data sensitif lewat broker publik.

8.4 Alternatif HTTP: Ketika MQTT Berlebihan

Tidak setiap proyek butuh broker. Bila perangkat hanya mengirim satu pembacaan tiap beberapa menit ke sebuah API, HTTP POST lebih sederhana — tanpa menjaga koneksi persisten. Berikut versi ringkasnya.

// Bab 8 — Kirim data sekali via HTTP POST (ESP32)
#include <WiFi.h>
#include <HTTPClient.h>

void kirimHTTP(float suhu) {
  if (WiFi.status() != WL_CONNECTED) return;
  HTTPClient http;
  http.begin("https://contoh-api.com/telemetry");
  http.addHeader("Content-Type", "application/json");

  String body = "{\"suhu\":" + String(suhu, 1) + "}";
  int kode = http.POST(body);
  Serial.printf("HTTP %d\n", kode);   // 200/201 = sukses
  http.end();
}

8.5 Studi Kasus: Jaringan 50 Sensor Tambak Udang

Sebuah tambak udang di pesisir Lampung memasang 50 node pengukur kadar oksigen terlarut dan suhu air. Karena jumlah besar dan jaringan 4G yang naik-turun, MQTT dipilih: setiap node menerbitkan ke topik tambak/kolamN/oksigen dengan QoS 1. Saat sinyal putus, pesan diantre di node dan terkirim saat tersambung lagi — tidak ada data hilang. Aerator dikendalikan balik lewat topik perintah ketika oksigen turun di bawah ambang.

Platform jadi seperti Blynk cepat, tetapi suatu saat Anda ingin dashboard yang benar-benar milik sendiri — bebas batasan tier gratis, bisa dikustomisasi, dan berjalan di server Anda. Dua alat open-source menjadi pasangan klasik: Node-RED untuk merangkai alur data secara visual, dan Grafana untuk memvisualkannya dengan indah. Bab ini menyusun "stack dashboard" yang banyak dipakai profesional.

9.1 Stack Klasik: MQTT → Node-RED → Database → Grafana

Pola yang sudah teruji: perangkat menerbitkan ke broker MQTT; Node-RED menangkap, mengolah, dan menyimpannya ke database deret-waktu (InfluxDB); Grafana membaca database itu dan menggambar grafik. Tiap bagian melakukan satu hal dengan baik — prinsip yang membuat sistem mudah dirawat.

9.2 Node-RED: Memrogram dengan Menyambung Kotak

Node-RED mengubah pemrograman alur data menjadi menyambung "node" di kanvas. Sebuah node mqtt in menerima pesan, node function mengolahnya, dan node influxdb out menyimpannya — tanpa satu baris kode pun untuk kasus dasar. Untuk logika khusus, node function menerima JavaScript singkat.

// Bab 9 — Node "function" di Node-RED: parse & beri label data MQTT
// msg.payload berisi angka suhu dari topik MQTT.
const suhu = parseFloat(msg.payload);

// Buang pembacaan tak masuk akal (sensor error)
if (isNaN(suhu) || suhu < -40 || suhu > 125) {
    return null;   // hentikan alur, jangan simpan sampah
}

// Bentuk ulang untuk InfluxDB: nilai + tag lokasi
msg.payload = [{ suhu: suhu }, { lokasi: "gudang-A", perangkat: "esp32-01" }];
return msg;

Tips. Selalu pasang "penjaga" yang membuang pembacaan tak masuk akal sebelum disimpan, seperti baris validasi di atas. Sensor sesekali mengirim nilai liar (saat boot, gangguan listrik, kabel longgar). Satu titik −999°C bisa merusak skala grafik Anda seharian. Membersihkan di hulu jauh lebih murah daripada di hilir.

9.3 Grafana: Dari Angka ke Wawasan

Grafana membaca InfluxDB dan menggambar dashboard yang bisa dibekukan, di-zoom, dan diberi alert. Anda bisa menetapkan ambang ("kirim notifikasi bila suhu > 35°C selama 5 menit") langsung di Grafana, lengkap dengan grafik historis untuk menelusuri kapan dan mengapa sebuah anomali terjadi. Inilah lompatan dari "melihat angka sekarang" ke "memahami pola sepanjang waktu".

9.4 Studi Kasus: Monitoring Ruang Server UMKM

Sebuah penyedia hosting kecil memantau suhu dan kelembapan ruang servernya dengan tiga node ESP32. Datanya mengalir lewat stack MQTT→Node-RED→InfluxDB→Grafana di satu Raspberry Pi. Grafana menampilkan tren 30 hari dan mengirim alert Telegram bila AC mulai gagal mendinginkan — terlihat dari suhu yang merangkak naik perlahan sebelum mencapai batas kritis.

Self-host punya pesona kemandirian, tetapi cloud menawarkan jangkauan: data Anda dapat diakses dari mana saja, skalanya nyaris tak terbatas, dan tak ada server yang perlu Anda jaga pukul tiga pagi. Bab ini menempatkan tiga pilihan cloud populer berdampingan dan menunjukkan kode untuk yang paling ramah pemula: Firebase.

10.1 Memilih Cloud: Sederhana, Lengkap, atau Industri

Awas — jebakan biaya cloud. Tier gratis menggoda, tetapi cloud industri (AWS/GCP/Azure) menagih per pesan, per GB, per eksekusi. Satu perangkat yang "ngambek" mengirim ribuan pesan per menit bisa menghasilkan tagihan mengejutkan. Selalu pasang batas (rate limit) di perangkat, dan aktifkan billing alert sejak hari pertama.

10.2 Resep: ESP32 ke Firebase Realtime Database

Firebase menyimpan data sebagai pohon JSON yang ter-sinkron secara real-time ke semua klien. Berikut node yang mengirim suhu ke path /sensor/gudang/suhu memakai pustaka Firebase ESP Client (oleh Mobizt).

// Bab 10 — Kirim ke Firebase Realtime Database (ESP32)
#include <WiFi.h>
#include <Firebase_ESP_Client.h>
#include <DHT.h>

#define API_KEY      "API_KEY_FIREBASE_ANDA"
#define DATABASE_URL "https://proyek-anda.firebaseio.com/"
#define PIN_DHT 4

DHT dht(PIN_DHT, DHT22);
FirebaseData   fbdo;
FirebaseAuth   auth;
FirebaseConfig config;

void setup() {
  Serial.begin(115200);
  dht.begin();
  WiFi.begin("NamaWiFi", "PasswordWiFi");
  while (WiFi.status() != WL_CONNECTED) delay(500);

  config.api_key      = API_KEY;
  config.database_url = DATABASE_URL;
  Firebase.signUp(&config, &auth, "", "");  // auth anonim untuk uji
  Firebase.begin(&config, &auth);
  Firebase.reconnectWiFi(true);
}

void loop() {
  static unsigned long t = 0;
  if (millis() - t > 10000) {   // tiap 10 detik
    t = millis();
    float suhu = dht.readTemperature();
    if (!isnan(suhu)) {
      if (Firebase.RTDB.setFloat(&fbdo, "/sensor/gudang/suhu", suhu)) {
        Serial.printf("Terkirim: %.1f C\n", suhu);
      } else {
        Serial.println("Gagal: " + fbdo.errorReason());
      }
    }
  }
}

10.3 Studi Kasus: Cold Chain Apotek Jaringan

Sebuah jaringan apotek dengan 30 cabang harus menjaga obat dan vaksin pada 2–8°C, dengan bukti audit untuk regulator. Tiap kulkas dipasang node ESP32 + DS18B20 (probe tahan air) yang mengirim suhu tiap menit ke AWS IoT Core, disimpan ke database, dan ditampilkan di dashboard pusat. Bila suhu keluar rentang, manajer cabang dan pusat menerima notifikasi seketika, dan riwayat tersimpan sebagai bukti kepatuhan.

Inilah bab tempat IoT bertemu kecerdasan secara konkret. Setelah data sensor mengalir ke cloud atau database, pertanyaannya berubah: bukan lagi "berapa nilainya", tetapi "apa artinya". Tiga jenis pertanyaan AI yang kita kenalkan di Bab 1 — anomali, prediksi, klasifikasi — kini kita ubah menjadi kode Python yang bisa dijalankan di atas data IoT nyata.

11.1 Tiga Pertanyaan, Tiga Keluarga Algoritma

11.2 Deteksi Anomali Tanpa Label: Isolation Forest

Keunggulan deteksi anomali adalah ia tidak butuh contoh "rusak" untuk belajar — cukup data normal. Isolation Forest bekerja dengan prinsip sederhana: titik aneh lebih mudah "diisolasi" dari kerumunan. Berikut contoh menemukan pembacaan getaran abnormal dari data sensor.

# Bab 11 — Deteksi anomali pada data getaran IoT (Python, scikit-learn)
import numpy as np
import pandas as pd
from sklearn.ensemble import IsolationForest

# Misal: data getaran (g) dari MQTT, sudah tersimpan di CSV
df = pd.read_csv("getaran_pompa.csv")        # kolom: timestamp, getaran
X = df[["getaran"]].values

# contamination = perkiraan proporsi anomali (mis. 1%)
model = IsolationForest(contamination=0.01, random_state=42)
df["skor"]   = model.fit_predict(X)          # -1 = anomali, 1 = normal
df["anomali"] = df["skor"] == -1

n = int(df["anomali"].sum())
print(f"Ditemukan {n} pembacaan anomali dari {len(df)} sampel")
print(df[df["anomali"]][["timestamp", "getaran"]].head())

Tips. Parameter contamination adalah tebakan awal seberapa sering anomali muncul. Mulai kecil (0,5–1%) lalu sesuaikan dengan kenyataan lapangan. Terlalu besar → banyak alarm palsu (orang berhenti percaya); terlalu kecil → melewatkan masalah nyata. Kalibrasi ambang adalah seni yang dipelajari dari data Anda sendiri, bukan dari angka ajaib.

11.3 Prediksi Deret-Waktu Sederhana

Untuk "apa yang akan terjadi", model deret-waktu mempelajari pola berulang (harian, mingguan, musiman). Berikut prediksi beban dengan pendekatan rata-rata bergerak sebagai dasar, yang bisa ditingkatkan ke ARIMA atau LSTM.

# Bab 11 — Prediksi sederhana beban listrik harian (Python)
import pandas as pd

df = pd.read_csv("beban_listrik.csv", parse_dates=["waktu"], index_col="waktu")
# Rata-rata bergerak 7 hari sebagai prediksi dasar (baseline)
df["prediksi"] = df["watt"].rolling(window=24*7).mean()

# Selisih besar antara aktual dan prediksi = lonjakan tak biasa
df["deviasi"] = (df["watt"] - df["prediksi"]).abs()
lonjakan = df[df["deviasi"] > df["deviasi"].std() * 3]
print(f"{len(lonjakan)} jam dengan beban tak biasa terdeteksi")

11.4 Studi Kasus: Predictive Maintenance Genset Tower BTS

Operator menara telekomunikasi memantau genset cadangan di lokasi terpencil. Sensor getaran, suhu oli, dan arus mengirim data tiap menit. Sebuah model anomali (Isolation Forest) berjalan di cloud menandai pola getaran yang menyimpang dari "tanda tangan normal" genset, sementara model prediksi memperkirakan kapan oli perlu diganti berdasarkan jam operasi dan suhu. Hasilnya: kunjungan teknisi dijadwalkan berdasarkan kondisi nyata, bukan kalender — menekan biaya perjalanan dan mencegah genset mati saat dibutuhkan.

Bayangkan Anda memasang 200 sensor di gedung-gedung yang tersebar, lalu menemukan bug di firmware. Mendatangi tiap perangkat dengan kabel USB adalah mimpi buruk. OTA (Over-The-Air) update memecahkan ini: perangkat memperbarui firmware-nya sendiri lewat jaringan. Bab ini menunjukkan cara membuat node yang bisa "menyembuhkan diri" dari jarak jauh.

12.1 Mengapa OTA Bukan Kemewahan, Tapi Kebutuhan

Begitu jumlah perangkat melewati segelintir, OTA berubah dari fitur bagus menjadi syarat kewarasan. Tanpa OTA, setiap perbaikan keamanan, penyesuaian ambang, atau penambahan fitur menuntut akses fisik. Dengan OTA, satu perintah memperbarui seluruh armada.

12.2 Kode: OTA Dasar dengan ArduinoOTA

Untuk perangkat di jaringan lokal yang sama, pustaka ArduinoOTA adalah jalan termudah: setelah ditanam, perangkat muncul sebagai target unggah nirkabel di Arduino IDE.

// Bab 12 — Aktifkan OTA update via WiFi (ESP32)
#include <WiFi.h>
#include <ArduinoOTA.h>

void setup() {
  Serial.begin(115200);
  WiFi.begin("NamaWiFi", "PasswordWiFi");
  while (WiFi.status() != WL_CONNECTED) delay(500);

  ArduinoOTA.setHostname("sensor-gudang-01");
  ArduinoOTA.setPassword("ota-rahasia");   // lindungi dari unggahan liar

  ArduinoOTA
    .onStart([]() { Serial.println("OTA mulai..."); })
    .onEnd([]()   { Serial.println("\nOTA selesai, reboot."); })
    .onProgress([](unsigned int p, unsigned int t) {
      Serial.printf("Progres: %u%%\r", (p * 100) / t);
    })
    .onError([](ota_error_t e) {
      Serial.printf("Error OTA [%u]\n", e);
    });
  ArduinoOTA.begin();
  Serial.println("Siap menerima OTA.");
}

void loop() {
  ArduinoOTA.handle();   // wajib dipanggil terus agar OTA responsif
  // ... logika sensor Anda di sini ...
}

Awas. Selalu pasang password OTA. Tanpa proteksi, siapa pun di jaringan yang sama bisa mengunggah firmware sembarang ke perangkat Anda — mengubahnya jadi alat penyerang. Untuk armada di internet (bukan LAN), gunakan OTA berbasis HTTPS dengan verifikasi tanda tangan firmware, agar perangkat menolak update yang tidak Anda tandatangani.

12.3 OTA Skala Armada: HTTP/HTTPS dari Server

Untuk perangkat tersebar di internet, polanya berbeda: perangkat secara berkala menanyakan ke server "apakah ada versi baru?", mengunduh binary bila ada, memverifikasinya, lalu mem-flash dirinya. Platform seperti ThingsBoard dan AWS IoT punya layanan OTA bawaan yang melacak versi tiap perangkat dan menggulirkan update secara bertahap (staged rollout) — sehingga bila firmware baru bermasalah, hanya sebagian kecil armada yang terdampak.

12.4 Studi Kasus: 200 Lampu Jalan Pintar Sekota

Sebuah pemerintah kota memasang 200 tiang lampu jalan ber-IoT yang meredup otomatis saat sepi. Tiga bulan setelah peluncuran, mereka ingin menambahkan fitur pelaporan kegagalan lampu. Tanpa OTA, ini berarti menaikkan teknisi ke 200 tiang. Dengan OTA berbasis HTTPS dan staged rollout, firmware baru diuji dulu di 10 tiang, dipantau semalam, lalu digulirkan ke 190 sisanya keesokan harinya — tanpa satu pun tangga dinaikkan.

Sebuah sensor di ladang atau di dinding tak selalu punya colokan listrik. Maka pertanyaan menentukan: berapa lama ia bertahan dengan baterai? Jawabannya bisa berkisar dari beberapa jam (kalau ceroboh) hingga beberapa tahun (kalau cermat). Bab ini membongkar seni menghemat setiap mikroamp, karena di dunia IoT bertenaga baterai, daya adalah mata uang yang sesungguhnya.

13.1 Ke Mana Daya Pergi?

Pembunuh baterai nomor satu adalah radio WiFi. Sebuah ESP32 yang menyala terus dengan WiFi aktif bisa menghabiskan baterai dalam sehari. Rahasianya: tidur sebanyak mungkin, bangun sebentar untuk membaca dan mengirim, lalu tidur lagi. Tabel berikut menunjukkan betapa dramatis perbedaannya.

Tips. Strategi emas perangkat bertenaga baterai: deep sleep selama mungkin, bangun hanya untuk satu siklus baca-kirim, lalu tidur lagi. Sebuah sensor tanah yang mengirim sekali tiap 30 menit bisa hidup lebih dari setahun dengan baterai 18650 tunggal. Membaca tiap detik akan menghabiskannya dalam hitungan hari. Frekuensi pengiriman adalah tuas terkuat untuk umur baterai.

13.2 Kode: Deep Sleep dengan Timer Bangun

ESP32 mendukung deep sleep di mana hampir seluruh chip dimatikan kecuali timer kecil yang membangunkannya. Trik penting: kode di setup() berjalan sekali tiap bangun, lalu chip tidur lagi — tidak ada loop() yang berputar.

// Bab 13 — Baca sensor, kirim, lalu tidur dalam (ESP32 deep sleep)
#include <WiFi.h>
#include <DHT.h>

#define PIN_DHT 4
#define uS_PER_S 1000000ULL
#define TIDUR_MENIT 30          // bangun tiap 30 menit

DHT dht(PIN_DHT, DHT22);

void setup() {
  Serial.begin(115200);
  dht.begin();

  // 1) Baca sensor secepat mungkin
  delay(2000);                  // DHT22 butuh waktu stabil
  float suhu = dht.readTemperature();

  // 2) Nyalakan WiFi, kirim, lalu matikan
  if (!isnan(suhu)) {
    WiFi.begin("NamaWiFi", "PasswordWiFi");
    unsigned long mulai = millis();
    while (WiFi.status() != WL_CONNECTED && millis() - mulai < 8000) delay(200);
    if (WiFi.status() == WL_CONNECTED) {
      // ... kirim via MQTT/HTTP/Firebase di sini ...
      Serial.printf("Terkirim: %.1f C\n", suhu);
    }
    WiFi.disconnect(true);
    WiFi.mode(WIFI_OFF);
  }

  // 3) Tidur dalam — chip hampir mati, bangun otomatis nanti
  esp_sleep_enable_timer_wakeup(TIDUR_MENIT * 60 * uS_PER_S);
  Serial.println("Tidur dalam...");
  esp_deep_sleep_start();       // setelah ini, setup() jalan lagi saat bangun
}

void loop() {
  // Kosong — semua terjadi di setup() karena chip reboot tiap bangun.
}

Awas. Saat deep sleep, isi variabel RAM biasa hilang — chip seperti reboot tiap bangun. Bila Anda perlu menyimpan nilai antar-tidur (mis. penghitung), gunakan memori khusus RTC_DATA_ATTR yang bertahan selama deep sleep. Salah memahami ini membuat banyak pemula bingung mengapa "variabelnya kereset terus".

13.3 Menghitung Umur Baterai

Umur baterai bisa diperkirakan, bukan ditebak. Rumus kasarnya: bagi kapasitas baterai dengan rata-rata konsumsi. Tabel berikut memperlihatkan estimasi untuk node yang bangun 10 detik tiap 30 menit (sisanya deep sleep), memakai baterai 18650 (~2500 mAh).

Biaya. Menambahkan panel surya kecil 5V/1W (sekitar Rp 25.000–40.000) plus modul pengisian TP4056 (sekitar Rp 5.000–10.000) mengubah node "ganti baterai tiap 4 bulan" menjadi "pasang lalu lupakan" selama bertahun-tahun. Untuk sensor di lokasi sulit dijangkau, investasi kecil ini hampir selalu sepadan.

13.4 Studi Kasus: Sensor Ketinggian Air Sungai Anti-Banjir

Sebuah komunitas di bantaran sungai memasang sensor ultrasonik HC-SR04 untuk memantau ketinggian air dan memberi peringatan dini banjir. Karena lokasi di pinggir sungai tanpa listrik, perangkat harus mandiri energi. Solusinya: ESP32 deep sleep yang bangun tiap 15 menit (lebih sering saat hujan), ditenagai baterai 18650 + panel surya 2W, mengirim via LoRa ke gateway di balai desa. Sistem bertahan tanpa perawatan sepanjang musim hujan — dan beberapa kali memberi warga waktu berharga untuk mengungsi.

Bagian 2 selesai. Bagian 3 — "IoT Rumah & Smart Living" — dilanjutkan pada sesi berikutnya.