Firebase Realtime Database untuk IoT: Panduan Lengkap ESP32

const firebaseConfig = {
  apiKey: "AIzaSyBxxxxxxxxxxxxxxxxxxxxxxx",
  authDomain: "iot-monitoring-project.firebaseapp.com",
  databaseURL: "https://iot-monitoring-project-default-rtdb.firebaseio.com",
  projectId: "iot-monitoring-project",
  storageBucket: "iot-monitoring-project.appspot.com",
  messagingSenderId: "123456789012",
  appId: "1:123456789012:web:abcdef1234567890"
};

/*
 * Kirim Data Sensor DHT11 ke Firebase Realtime Database
 * ESP32 + Firebase ESP32 Client Library
 * IoTHub - Tutorial Firebase IoT
 */

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

// ===== KONFIGURASI WiFi =====
#define WIFI_SSID     "NamaWiFiKamu"
#define WIFI_PASSWORD "PasswordWiFiKamu"

// ===== KONFIGURASI Firebase =====
#define FIREBASE_HOST "iot-monitoring-project-default-rtdb.firebaseio.com"
#define FIREBASE_AUTH "AIzaSyBxxxxxxxxxxxxxxxxxxxxxxx"

// ===== KONFIGURASI SENSOR =====
#define DHT_PIN       4
#define DHT_TYPE      DHT11

// ===== INISIALISASI =====
DHT dht(DHT_PIN, DHT_TYPE);
FirebaseData firebaseData;
FirebaseConfig firebaseConfig;
FirebaseAuth firebaseAuth;

// Interval pengiriman data (dalam milidetik)
unsigned long previousMillis = 0;
const long interval = 10000; // Kirim data setiap 10 detik

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("=== Firebase IoT: Kirim Data Sensor ===");

  // Inisialisasi sensor DHT
  dht.begin();
  Serial.println("Sensor DHT11 aktif");

  // Koneksi WiFi
  Serial.print("Menghubungkan WiFi");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println();
  Serial.print("WiFi terhubung! IP: ");
  Serial.println(WiFi.localIP());

  // Konfigurasi Firebase
  firebaseConfig.database_url = FIREBASE_HOST;
  firebaseConfig.api_key = FIREBASE_AUTH;
  Firebase.begin(&firebaseConfig, &firebaseAuth);

  // Aktifkan auto-reconnect WiFi
  Firebase.reconnectWiFi(true);

  // Set ukuran buffer data rx/tx
  firebaseData.setResponseSize(1024);

  Serial.println("Firebase terhubung! Mulai mengirim data...");
}

void loop() {
  unsigned long currentMillis = millis();

  // Kirim data sesuai interval yang ditentukan
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    // Baca data dari sensor DHT11
    float suhu = dht.readTemperature();  // Celsius
    float kelembaban = dht.readHumidity();

    // Validasi pembacaan sensor
    if (isnan(suhu) || isnan(kelembaban)) {
      Serial.println("Gagal membaca sensor DHT11!");
      return;
    }

    // Tampilkan di Serial Monitor
    Serial.print("Suhu: ");
    Serial.print(suhu);
    Serial.print("°C | Kelembaban: ");
    Serial.print(kelembaban);
    Serial.println("%");

    // Kirim data suhu ke Firebase
    String path_suhu = "/devices/esp32_001/sensor/temperature";
    if (Firebase.setFloat(firebaseData, path_suhu, suhu)) {
      Serial.println("Suhu terkirim: " + String(suhu));
    } else {
      Serial.println("Gagal kirim suhu: " + firebaseData.errorReason());
    }

    // Kirim data kelembaban ke Firebase
    String path_hum = "/devices/esp32_001/sensor/humidity";
    if (Firebase.setFloat(firebaseData, path_hum, kelembaban)) {
      Serial.println("Kelembaban terkirim: " + String(kelembaban));
    } else {
      Serial.println("Gagal kirim kelembaban: " + firebaseData.errorReason());
    }

    // Kirim timestamp
    String path_time = "/devices/esp32_001/sensor/timestamp";
    if (Firebase.setInt(firebaseData, path_time, millis())) {
      Serial.println("Timestamp terkirim");
    }

    // Update status device
    String path_status = "/devices/esp32_001/info/status";
    Firebase.setString(firebaseData, path_status, "online");

    Serial.println("---");
  }
}

/*
 * Kontrol LED & Relay via Firebase Realtime Database
 * ESP32 - Stream Listener untuk perubahan data real-time
 * IoTHub - Tutorial Firebase IoT
 */

#include <WiFi.h>
#include <Firebase_ESP32.h>

// ===== KONFIGURASI WiFi =====
#define WIFI_SSID     "NamaWiFiKamu"
#define WIFI_PASSWORD "PasswordWiFiKamu"

// ===== KONFIGURASI Firebase =====
#define FIREBASE_HOST "iot-monitoring-project-default-rtdb.firebaseio.com"
#define FIREBASE_AUTH "AIzaSyBxxxxxxxxxxxxxxxxxxxxxxx"

// ===== PIN OUTPUT =====
#define LED_PIN       2    // LED bawaan ESP32
#define RELAY1_PIN    16   // Relay module channel 1
#define RELAY2_PIN    17   // Relay module channel 2

// ===== INISIALISASI =====
FirebaseData firebaseData;
FirebaseConfig firebaseConfig;
FirebaseAuth firebaseAuth;

// Path path di Firebase
const char* pathControl = "/devices/esp32_001/control";

void streamCallback(StreamData data) {
  // Dipanggil setiap kali data berubah di path yang di-listen
  Serial.println("=== DATA BERUBAH ===");
  Serial.print("Path: ");
  Serial.println(data.dataPath());
  Serial.print("Tipe data: ");
  Serial.println(data.dataType());
  Serial.print("Nilai baru: ");
  Serial.println(data.stringData());

  // Cek path yang berubah dan jalankan aksi
  String path = data.dataPath();
  String value = data.stringData();

  if (path == "/led") {
    // Kontrol LED bawaan ESP32
    if (value == "true") {
      digitalWrite(LED_PIN, HIGH);
      Serial.println("LED ON");
    } else {
      digitalWrite(LED_PIN, LOW);
      Serial.println("LED OFF");
    }
  }
  else if (path == "/relay1") {
    // Kontrol Relay Channel 1
    if (value == "true") {
      digitalWrite(RELAY1_PIN, HIGH);
      Serial.println("Relay 1 ON");
    } else {
      digitalWrite(RELAY1_PIN, LOW);
      Serial.println("Relay 1 OFF");
    }
  }
  else if (path == "/relay2") {
    // Kontrol Relay Channel 2
    if (value == "true") {
      digitalWrite(RELAY2_PIN, HIGH);
      Serial.println("Relay 2 ON");
    } else {
      digitalWrite(RELAY2_PIN, LOW);
      Serial.println("Relay 2 OFF");
    }
  }
}

void streamTimeoutCallback(bool timeout) {
  if (timeout) {
    Stream timeoutStream;
    Serial.println("Stream timeout, reconnect...");
    // Mulai ulang stream listener
    if (!Firebase.readStream(firebaseData)) {
      Serial.println("Gagal mulai ulang stream: " + firebaseData.errorReason());
    }
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("=== Firebase IoT: Kontrol LED & Relay ===");

  // Setup pin output
  pinMode(LED_PIN, OUTPUT);
  pinMode(RELAY1_PIN, OUTPUT);
  pinMode(RELAY2_PIN, OUTPUT);

  // Pastikan semua relay OFF saat awal
  digitalWrite(LED_PIN, LOW);
  digitalWrite(RELAY1_PIN, LOW);
  digitalWrite(RELAY2_PIN, LOW);

  // Koneksi WiFi
  Serial.print("Menghubungkan WiFi");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println();
  Serial.print("WiFi terhubung! IP: ");
  Serial.println(WiFi.localIP());

  // Konfigurasi Firebase
  firebaseConfig.database_url = FIREBASE_HOST;
  firebaseConfig.api_key = FIREBASE_AUTH;
  Firebase.begin(&firebaseConfig, &firebaseAuth);
  Firebase.reconnectWiFi(true);

  // Inisialisasi nilai awal di Firebase (jika belum ada)
  if (!Firebase.pathExist(firebaseData, "/devices/esp32_001/control")) {
    Serial.println("Membuat node kontrol awal...");
    FirebaseJson json;
    json.set("led", false);
    json.set("relay1", false);
    json.set("relay2", false);
    Firebase.set(firebaseData, "/devices/esp32_001/control", json);
  }

  // Mulai stream listener untuk path kontrol
  if (!Firebase.beginStream(firebaseData, pathControl)) {
    Serial.println("Gagal mulai stream: " + firebaseData.errorReason());
    return;
  }

  // Set callback untuk perubahan data
  Firebase.setStreamCallback(firebaseData, streamCallback, streamTimeoutCallback);

  Serial.println("Stream listener aktif! Menunggu perubahan data...");
}

void loop() {
  // Pastikan koneksi WiFi tetap aktif
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("WiFi terputus! Menghubungkan ulang...");
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    while (WiFi.status() != WL_CONNECTED) {
      delay(500);
    }
    Serial.println("WiFi terhubung kembali!");
  }

  // Stream listener bekerja di background, tidak perlu polling
  delay(1000);
}

{
  "rules": {
    "devices": {
      // Setiap device hanya bisa diakses dengan device ID yang benar
      "$device_id": {
        // Info device: baca semua, tulis hanya owner
        "info": {
          ".read": "auth != null",
          ".write": "auth != null && root.child('users').child(auth.uid).child('devices').child($device_id).exists()"
        },
        // Data sensor: baca semua yang terautentikasi, tulis hanya device sendiri
        "sensor": {
          ".read": "auth != null",
          ".write": "auth != null && root.child('devices').child($device_id).child('info/api_key').val() === data.parent().child('info/api_key').val()"
        },
        // Data kontrol: baca semua, tulis semua (untuk dashboard web)
        "control": {
          ".read": "auth != null",
          ".write": "auth != null"
        }
      }
    },
    // Pengaturan threshold: baca semua, tulis hanya admin
    "settings": {
      ".read": "auth != null",
      ".write": "auth != null && root.child('users').child(auth.uid).child('role').val() === 'admin'"
    },
    // Log aksi: baca semua, tulis hanya device
    "logs": {
      ".read": "auth != null",
      ".write": false,
      "$log_id": {
        ".validate": "newData.hasChildren(['timestamp', 'device', 'action'])"
      }
    },
    // Aturan default: tolak semua yang tidak didefinisikan
    "$other": {
      ".read": false,
      ".write": false
    }
  }
}

/*
 * Proyek Lengkap: Monitoring Suhu + Kontrol Relay via Firebase
 * ESP32 + DHT11 + Relay 2 Channel
 * IoTHub - Tutorial Firebase IoT
 *
 * Fitur:
 *   1. Mengirim data suhu & kelembaban ke Firebase setiap 15 detik
 *   2. Monitoring status LED (online/offline) di Firebase
 *   3. Kontrol relay real-time via Firebase stream listener
 *   4. Alert otomatis jika suhu melebihi threshold
 */

#include <WiFi.h>
#include <Firebase_ESP32.h>
#include <DHT.h>
#include <time.h>

// ===== KONFIGURASI WiFi =====
#define WIFI_SSID     "NamaWiFiKamu"
#define WIFI_PASSWORD "PasswordWiFiKamu"

// ===== KONFIGURASI Firebase =====
#define FIREBASE_HOST "iot-monitoring-project-default-rtdb.firebaseio.com"
#define FIREBASE_AUTH "AIzaSyBxxxxxxxxxxxxxxxxxxxxxxx"

// ===== PIN KONFIGURASI =====
#define DHT_PIN       4
#define DHT_TYPE      DHT11
#define LED_GREEN     2    // LED indikator online
#define LED_RED       15   // LED indikator error
#define RELAY1_PIN    16   // Relay CH1 - Kipas Angin
#define RELAY2_PIN    17   // Relay CH2 - Lampu

// ===== THRESHOLD =====
#define TEMP_HIGH     35.0 // Suhu tinggi (°C) - trigger alert
#define TEMP_LOW      18.0 // Suhu rendah (°C) - trigger alert

// ===== INISIALISASI =====
DHT dht(DHT_PIN, DHT_TYPE);
FirebaseData firebaseData;
FirebaseData streamData;
FirebaseConfig firebaseConfig;
FirebaseAuth firebaseAuth;

// Device ID unik
const String DEVICE_ID = "esp32_001";

// Timing
unsigned long prevSendTime = 0;
const long sendInterval = 15000; // 15 detik

// ===== FUNGSI CALLBACK STREAM =====
void onControlChange(StreamData data) {
  String path = data.dataPath();
  String value = data.stringData();

  Serial.printf("[KONTROL] %s = %s\n", path.c_str(), value.c_str());

  if (path == "/relay1") {
    bool state = (value == "true");
    digitalWrite(RELAY1_PIN, state ? HIGH : LOW);
    Serial.printf("  → Relay 1 (Kipas): %s\n", state ? "ON" : "OFF");
  }
  else if (path == "/relay2") {
    bool state = (value == "true");
    digitalWrite(RELAY2_PIN, state ? HIGH : LOW);
    Serial.printf("  → Relay 2 (Lampu): %s\n", state ? "ON" : "OFF");
  }
}

void onStreamTimeout(bool timeout) {
  if (timeout) {
    Serial.println("[STREAM] Timeout! Reconnecting...");
    Firebase.readStream(streamData);
  }
}

// ===== FUNGSI KIRIM ALERT =====
void sendAlert(String type, String message) {
  String path = "/alerts/" + String(millis());
  FirebaseJson alertJson;
  alertJson.set("device", DEVICE_ID);
  alertJson.set("type", type);
  alertJson.set("message", message);
  alertJson.set("timestamp", millis());
  alertJson.set("read", false);

  if (Firebase.setJSON(streamData, path, alertJson)) {
    Serial.println("[ALERT] Terkirim: " + message);
  }
}

// ===== FUNGSI KIRIM DATA SENSOR =====
void sendSensorData(float suhu, float kelembaban) {
  String basePath = "/devices/" + DEVICE_ID + "/sensor/";

  // Kirim data terkini
  Firebase.setFloat(streamData, basePath + "temperature", suhu);
  Firebase.setFloat(streamData, basePath + "humidity", kelembaban);
  Firebase.setInt(streamData, basePath + "timestamp", millis());

  // Simpan history (opsional, untuk grafik)
  String historyPath = basePath + "history/" + String(millis()) + "/";
  FirebaseJson histJson;
  histJson.set("temp", suhu);
  histJson.set("hum", kelembaban);
  Firebase.setJSON(streamData, historyPath, histJson);

  // Cek threshold dan kirim alert
  if (suhu > TEMP_HIGH) {
    sendAlert("high_temp", "Suhu " + String(suhu) + "°C melebihi batas " + String(TEMP_HIGH) + "°C");
  }
  else if (suhu < TEMP_LOW) {
    sendAlert("low_temp", "Suhu " + String(suhu) + "°C di bawah batas " + String(TEMP_LOW) + "°C");
  }
}

// ===== SETUP =====
void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("========================================");
  Serial.println("  Firebase IoT - Monitoring + Kontrol");
  Serial.println("  IoTHub Tutorial");
  Serial.println("========================================");

  // Setup pin
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_RED, OUTPUT);
  pinMode(RELAY1_PIN, OUTPUT);
  pinMode(RELAY2_PIN, OUTPUT);

  // Default: semua OFF
  digitalWrite(LED_GREEN, LOW);
  digitalWrite(LED_RED, LOW);
  digitalWrite(RELAY1_PIN, LOW);
  digitalWrite(RELAY2_PIN, LOW);

  // Mulai sensor
  dht.begin();
  Serial.println("[INIT] Sensor DHT11 aktif");

  // Koneksi WiFi
  Serial.print("[WIFI] Menghubungkan");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  int retries = 0;
  while (WiFi.status() != WL_CONNECTED && retries < 30) {
    Serial.print(".");
    delay(500);
    retries++;
  }

  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("\n[FATAL] WiFi gagal! Restart...");
    ESP.restart();
  }

  Serial.println();
  Serial.printf("[WIFI] Terhubung! IP: %s\n", WiFi.localIP().toString().c_str());
  digitalWrite(LED_GREEN, HIGH); // LED hijau ON = WiFi OK

  // Setup NTP time
  configTime(0, 0, "pool.ntp.org", "time.nist.gov");

  // Konfigurasi Firebase
  firebaseConfig.database_url = FIREBASE_HOST;
  firebaseConfig.api_key = FIREBASE_AUTH;
  Firebase.begin(&firebaseConfig, &firebaseAuth);
  Firebase.reconnectWiFi(true);
  streamData.setResponseSize(4096);

  // Update status online
  String infoPath = "/devices/" + DEVICE_ID + "/info/";
  FirebaseJson infoJson;
  infoJson.set("name", "Monitoring Ruangan");
  infoJson.set("location", "Lantai 1");
  infoJson.set("status", "online");
  infoJson.set("ip", WiFi.localIP().toString());
  Firebase.setJSON(streamData, infoPath, infoJson);

  // Inisialisasi node kontrol jika belum ada
  if (!Firebase.pathExist(streamData, "/devices/" + DEVICE_ID + "/control")) {
    FirebaseJson ctrlJson;
    ctrlJson.set("relay1", false);
    ctrlJson.set("relay2", false);
    Firebase.setJSON(streamData, "/devices/" + DEVICE_ID + "/control", ctrlJson);
  }

  // Mulai stream listener untuk kontrol
  String controlPath = "/devices/" + DEVICE_ID + "/control";
  if (!Firebase.beginStream(streamData, controlPath)) {
    Serial.println("[STREAM] Gagal mulai: " + streamData.errorReason());
  } else {
    Firebase.setStreamCallback(streamData, onControlChange, onStreamTimeout);
    Serial.println("[STREAM] Listener kontrol aktif");
  }

  Serial.println("[SYSTEM] Siap! Memulai siklus monitoring...");
  Serial.println("========================================");
}

// ===== LOOP =====
void loop() {
  unsigned long now = millis();

  // Cek WiFi
  if (WiFi.status() != WL_CONNECTED) {
    digitalWrite(LED_GREEN, LOW);
    digitalWrite(LED_RED, HIGH);
    Serial.println("[WIFI] Terputus! Menghubungkan ulang...");
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    delay(5000);
    return;
  }

  digitalWrite(LED_GREEN, HIGH);
  digitalWrite(LED_RED, LOW);

  // Kirim data sensor sesuai interval
  if (now - prevSendTime >= sendInterval) {
    prevSendTime = now;

    float suhu = dht.readTemperature();
    float kelembaban = dht.readHumidity();

    if (isnan(suhu) || isnan(kelembaban)) {
      Serial.println("[SENSOR] Gagal baca DHT11!");
      Firebase.setString(streamData, "/devices/" + DEVICE_ID + "/info/status", "sensor_error");
      return;
    }

    // Kirim ke Firebase
    sendSensorData(suhu, kelembaban);

    // Cek status relay dari Firebase
    FirebaseJson relayStatus;
    String relayPath = "/devices/" + DEVICE_ID + "/control";
    if (Firebase.getJSON(streamData, relayPath)) {
      FirebaseJson &json = streamData.jsonObject();
      FirebaseJsonData jsonData;

      if (json.get(jsonData, "relay1")) {
        Serial.printf("  Relay1: %s\n", jsonData.stringValue);
      }
      if (json.get(jsonData, "relay2")) {
        Serial.printf("  Relay2: %s\n", jsonData.stringValue);
      }
    }

    Serial.printf("[DATA] Suhu: %.1f°C | Kelembaban: %.1f%%\n", suhu, kelembaban);
    Serial.println("---");
  }

  delay(100);
}