ESP32 Deep Sleep: Hemat Baterai Hingga Setahun

// Membaca konsumsi daya ESP32 menggunakan INA219
// BeebaneLabs - https://beebanelabs.pages.dev

#include <Wire.h>
#include <Adafruit_INA219.h>

Adafruit_INA219 ina219;

void setup() {
  Serial.begin(115200);
  Serial.println("=== INA219 Power Monitor ===");

  if (!ina219.begin()) {
    Serial.println("ERROR: INA219 tidak terdeteksi!");
    while (1) { delay(1000); }
  }

  Serial.println("INA219 siap!");
  Serial.println();
}

void loop() {
  // Baca tegangan bus (tegangan baterai)
  float teganganBus = ina219.getBusVoltage_V();

  // Baca tegangan shunt (untuk hitung arus)
  float teganganShunt = ina219.getShuntVoltage_mV();

  // Baca arus dalam mA
  float arus = ina219.getCurrent_mA();

  // Hitung daya dalam mW
  float daya = ina219.getPower_mW();

  // Tampilkan hasil
  Serial.println("--- Pembacaan Daya ---");
  Serial.print("Tegangan Bus  : ");
  Serial.print(teganganBus, 3);
  Serial.println(" V");

  Serial.print("Tegangan Shunt: ");
  Serial.print(teganganShunt, 3);
  Serial.println(" mV");

  Serial.print("Arus          : ");
  Serial.print(arus, 1);
  Serial.println(" mA");

  Serial.print("Daya          : ");
  Serial.print(daya, 1);
  Serial.println(" mW");
  Serial.println();

  delay(2000);
}

// Fungsi shutdown yang benar untuk WiFi & MQTT
// BeebaneLabs - https://beebanelabs.pages.dev

#include <WiFi.h>
#include <PubSubClient.h>

// Konfigurasi WiFi
const char* ssid     = "WiFi_Indonesia";
const char* password  = "password123";

// Konfigurasi MQTT
const char* mqttServer = "broker.hivemq.com";
const int   mqttPort   = 1883;
const char* mqttTopic  = "iothub/sensor/suhu";

WiFiClient wifiClient;
PubSubClient mqttClient(wifiClient);

// --- Fungsi Terhubung WiFi ---
void sambungWifi() {
  Serial.print("Menghubungkan WiFi");
  WiFi.begin(ssid, password);

  int percobaan = 0;
  while (WiFi.status() != WL_CONNECTED && percobaan < 20) {
    delay(500);
    Serial.print(".");
    percobaan++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nWiFi terhubung!");
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("\nGagal terhubung WiFi!");
  }
}

// --- Fungsi Terhubung MQTT ---
void sambungMQTT() {
  mqttClient.setServer(mqttServer, mqttPort);

  int percobaan = 0;
  while (!mqttClient.connected() && percobaan < 3) {
    Serial.print("Menghubungkan MQTT...");
    if (mqttClient.connect("ESP32DeepSleep")) {
      Serial.println("OK!");
    } else {
      Serial.print("Gagal, rc=");
      Serial.println(mqttClient.state());
      delay(1000);
      percobaan++;
    }
  }
}

// --- Fungsi Kirim Data ---
bool kirimData(float suhu, float kelembaban) {
  if (!mqttClient.connected()) return false;

  // Format data sebagai JSON
  char payload[128];
  snprintf(payload, sizeof(payload),
    "{\"suhu\":%.1f,\"kelembaban\":%.1f,\"uptime\":%lu}",
    suhu, kelembaban, millis());

  // Kirim data
  bool berhasil = mqttClient.publish(mqttTopic, payload);

  if (berhasil) {
    Serial.print("Data terkirim: ");
    Serial.println(payload);
  } else {
    Serial.println("Gagal mengirim data!");
  }

  return berhasil;
}

// --- Fungsi Shutdown Aman ---
void shutdownAman() {
  Serial.println("=== Memulai Shutdown ===");

  // Langkah 1: Pastikan semua paket MQTT terkirim
  Serial.println("[1/6] Flush MQTT...");
  mqttClient.loop();  // Proses callback & pending
  delay(500);         // Tunggu TX buffer kosong

  // Langkah 2: Putuskan MQTT
  Serial.println("[2/6] Disconnect MQTT...");
  if (mqttClient.connected()) {
    mqttClient.disconnect();
    delay(100);
  }

  // Langkah 3: Disconnect WiFi
  Serial.println("[3/6] Disconnect WiFi...");
  WiFi.disconnect(true);
  delay(100);

  // Langkah 4: Matikan modul WiFi
  Serial.println("[4/6] WiFi OFF...");
  WiFi.mode(WIFI_OFF);
  delay(100);

  // Langkah 5: Putuskan radio WiFi
  Serial.println("[5/6] WiFi radio OFF...");
  esp_wifi_disconnect();
  delay(100);

  // Langkah 6: Flush serial
  Serial.println("[6/6] Serial flush...");
  Serial.flush();

  Serial.println("=== Shutdown Selesai ===");
  delay(100);
}

// Sensor Suhu Battery-Powered 1 Tahun
// ESP32 Deep Sleep + MQTT + DHT22
// BeebaneLabs - https://beebanelabs.pages.dev

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

// ===== KONFIGURASI =====
#define SLEEP_DURATION   900LL          // 15 menit (dalam detik)
#define DHT_PIN          4              // GPIO4
#define DHT_TYPE         DHT22          // Gunakan DHT22 untuk akurasi
#define LED_INDICATOR    2              // GPIO2 (LED internal)
#define BAT_ADC_PIN      34             // GPIO34 untuk baca tegangan baterai
#define BAT_VOLT_DIV     2.0            // Rasio voltage divider

// WiFi credentials
const char* WIFI_SSID     = "WiFi_Indonesia";
const char* WIFI_PASS     = "password123";

// MQTT credentials
const char* MQTT_SERVER   = "broker.hivemq.com";
const int   MQTT_PORT     = 1883;
const char* MQTT_USER     = "";
const char* MQTT_PASS_MQTT = "";
const char* MQTT_TOPIC    = "iothub/suhu/esp32-01";
const char* MQTT_CLIENT   = "ESP32-Suhu-01";

// ===== OBJEK GLOBAL =====
DHT dht(DHT_PIN, DHT_TYPE);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);

// ===== RTC MEMORY =====
RTC_DATA_ATTR int wakeCount     = 0;
RTC_DATA_ATTR int errConnect    = 0;
RTC_DATA_ATTR float lastSuhu    = 0.0;
RTC_DATA_ATTR float lastHumidity = 0.0;

// ===== FUNGSI SETUP =====
void setup() {
  Serial.begin(115200);
  Serial.flush();

  wakeCount++;

  // LED indikator
  pinMode(LED_INDICATOR, OUTPUT);
  digitalWrite(LED_INDICATOR, HIGH);

  Serial.println();
  Serial.println("╔══════════════════════════════════════╗");
  Serial.println("║  Sensor Suhu Battery-Powered 1 Tahun ║");
  Serial.println("║  ESP32 Deep Sleep + MQTT             ║");
  Serial.println("╚══════════════════════════════════════╝");
  Serial.print("Wake-up ke-: ");
  Serial.println(wakeCount);

  // Baca tegangan baterai
  float teganganBaterai = bacaTeganganBaterai();
  Serial.print("Tegangan baterai: ");
  Serial.print(teganganBaterai, 2);
  Serial.println(" V");

  // Cek apakah baterai masih cukup (minimum 3.3V)
  if (teganganBaterai < 3.3) {
    Serial.println("PERINGATAN: Baterai lemah! Interval diperpanjang.");
    // Jika baterai lemah, sleep lebih lama (30 menit)
    sleepDanBangun(SLEEP_DURATION * 2);
  }

  // Baca sensor suhu
  dht.begin();
  delay(2000);  // Tunggu sensor stabil

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

  if (isnan(suhu) || isnan(kelembaban)) {
    Serial.println("ERROR: Gagal baca sensor DHT22!");
    // Gunakan data terakhir dari RTC memory
    suhu       = lastSuhu;
    kelembaban = lastHumidity;
    Serial.println("Menggunakan data terakhir dari RTC memory.");
  } else {
    Serial.print("Suhu      : ");
    Serial.print(suhu, 1);
    Serial.println(" °C");
    Serial.print("Kelembaban: ");
    Serial.print(kelembaban, 1);
    Serial.println(" %");
    lastSuhu     = suhu;
    lastHumidity = kelembaban;
  }

  // Kirim data via MQTT
  if (suhu != 0.0 || kelembaban != 0.0) {
    bool terkirim = kirimDataMQTT(suhu, kelembaban, teganganBaterai);
    if (terkirim) {
      Serial.println("Data berhasil dikirim!");
    } else {
      Serial.println("Gagal mengirim data.");
      errConnect++;
    }
  }

  // Shutdown dan masuk Deep Sleep
  shutdownAman();
  Serial.print("Tidur selama ");
  Serial.print(SLEEP_DURATION);
  Serial.println(" detik...");
  sleepDanBangun(SLEEP_DURATION);
}

// ===== FUNGSI LOOP =====
void loop() {
  // Tidak digunakan — ESP32 selalu bangun dari setup()
}

// ===== FUNGSI-FUNGSI PEMBANTU =====

float bacaTeganganBaterai() {
  // Baca ADC dan konversi ke tegangan
  int adcValue = analogRead(BAT_ADC_PIN);
  float tegangan = (adcValue / 4095.0) * 3.3 * BAT_VOLT_DIV;
  return tegangan;
}

bool kirimDataMQTT(float suhu, float kelembaban, float tegangan) {
  // Sambung WiFi
  Serial.print("Menghubungkan WiFi...");
  WiFi.begin(WIFI_SSID, WIFI_PASS);

  int coba = 0;
  while (WiFi.status() != WL_CONNECTED && coba < 20) {
    delay(500);
    Serial.print(".");
    coba++;
  }

  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("\nWiFi gagal!");
    return false;
  }
  Serial.println(" OK!");

  // Sambung MQTT
  mqtt.setServer(MQTT_SERVER, MQTT_PORT);
  coba = 0;
  while (!mqtt.connected() && coba < 3) {
    Serial.print("MQTT...");
    if (mqtt.connect(MQTT_CLIENT, MQTT_USER, MQTT_PASS_MQTT)) {
      Serial.println("OK!");
    } else {
      Serial.print("Gagal (");
      Serial.print(mqtt.state());
      Serial.println(")");
      delay(1000);
      coba++;
    }
  }

  if (!mqtt.connected()) {
    Serial.println("MQTT tidak terhubung!");
    return false;
  }

  // Siapkan payload JSON
  char payload[256];
  snprintf(payload, sizeof(payload),
    "{"
    "\"device\":\"ESP32-01\","
    "\"suhu\":%.1f,"
    "\"kelembaban\":%.1f,"
    "\"baterai\":%.2f,"
    "\"wake\":%d,"
    "\"uptime\":%lu"
    "}",
    suhu, kelembaban, tegangan, wakeCount, millis()
  );

  // Publish
  bool hasil = mqtt.publish(MQTT_TOPIC, payload);
  mqtt.loop();
  delay(200);

  return hasil;
}

void shutdownAman() {
  Serial.println("Shutdown...");
  mqtt.loop();
  delay(500);
  if (mqtt.connected()) mqtt.disconnect();
  delay(100);
  WiFi.disconnect(true);
  delay(100);
  WiFi.mode(WIFI_OFF);
  delay(100);
  Serial.flush();
  digitalWrite(LED_INDICATOR, LOW);
  delay(100);
}

void sleepDanBangun(long long detikTidur) {
  esp_sleep_enable_timer_wakeup(detikTidur * 1000000ULL);
  esp_deep_sleep_start();
}