ESP32 Deep Sleep: Hemat Baterai Hingga Setahun

// ESP32 Deep Sleep dengan Timer Wakeup
// IoTHub - https://iothub.id

#include <Arduino.h>

// Definisikan waktu tidur dalam mikrosekon
// 1 detik  = 1000000 µs
// 5 menit  = 300000000 µs
// 15 menit = 900000000 µs
#define TIME_TO_SLEEP  300  // 300 detik = 5 menit

RTC_DATA_ATTR int jumlahBangun = 0;

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

  // Tambah jumlah wake counter di RTC Memory
  jumlahBangun++;

  Serial.println("=== ESP32 Deep Sleep Timer ===");
  Serial.print("Wake-up ke-: ");
  Serial.println(jumlahBangun);
  Serial.print("Timestamp: ");
  Serial.println(millis());
  Serial.print("Menghabiskan waktu selama: ");
  Serial.print(TIME_TO_SLEEP);
  Serial.println(" detik...");

  // --- Lakukan pekerjaan di sini ---
  // Baca sensor, kirim data, kontrol LED, dll.

  // Nyalakan LED indikator selama 1 detik
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);

  // Atur waktu sleep dan masuk Deep Sleep
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * 1000000ULL);
  Serial.println("Masuk Deep Sleep...");
  Serial.flush();  // Pastikan serial selesai terkirim
  esp_deep_sleep_start();

  // Kode di bawah TIDAK akan pernah dieksekusi
}

void loop() {
  // Tidak digunakan karena ESP32 bangun dari setup()
}

// ESP32 Deep Sleep dengan GPIO Wakeup (Tombol)
// IoTHub - https://iothub.id

#include <Arduino.h>

#define BUTTON_PIN     33    // Pin tombol untuk wake up
#define LED_PIN        2     // LED indikator
#define TIMEOUT_WAKE   300   // Auto wake setelah 5 menit

RTC_DATA_ATTR int wakeCount = 0;
RTC_DATA_ATTR int buttonWakes = 0;

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

  wakeCount++;

  // Tentukan alasan bangun
  esp_sleep_wakeup_cause_t penyebab = esp_sleep_get_wakeup_cause();

  switch (penyebab) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Bangun karena: Tombol ditekan (EXT0)!");
      buttonWakes++;
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Bangun karena: Timer timeout");
      break;
    default:
      Serial.println("Bangun karena: Boot pertama kali / reset");
      break;
  }

  Serial.print("Total wake-up: ");
  Serial.println(wakeCount);
  Serial.print("Bangun dari tombol: ");
  Serial.println(buttonWakes);

  // --- Lakukan pekerjaan ---
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, HIGH);
  delay(2000);  // Nyalakan LED selama 2 detik
  digitalWrite(LED_PIN, LOW);

  // Konfigurasi 2 wake-up source:
  // 1. GPIO 33 (tombol) — EXT0
  // 2. Timer sebagai cadangan (timeout)
  esp_sleep_enable_ext0_wakeup((gpio_num_t)BUTTON_PIN, 0);
  esp_sleep_enable_timer_wakeup(TIMEOUT_WAKE * 1000000ULL);

  Serial.println("Masuk Deep Sleep... (tekan tombol untuk bangun)");
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
  // Tidak digunakan
}

// ESP32 Deep Sleep dengan Touch Wakeup
// IoTHub - https://iothub.id

#include <Arduino.h>

// Pin touch yang mendukung wake-up dari Deep Sleep
#define TOUCH_PIN       T0    // GPIO 4 — Touch channel 0

// Threshold sensitivitas touch
#define TOUCH_THRESHOLD 40

RTC_DATA_ATTR int wakeCount = 0;

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

  wakeCount++;

  esp_sleep_wakeup_cause_t penyebab = esp_sleep_get_wakeup_cause();

  if (penyebab == ESP_SLEEP_WAKEUP_TOUCHPAD) {
    Serial.println("Bangun karena: Sentuhan pada pad!");
    // Tampilkan channel touch yang memicu wake
    touch_pad_t touchPad = esp_sleep_get_touchpad_wakeup_status();
    Serial.print("Channel: T");
    Serial.println((int)touchPad);
  } else {
    Serial.println("Bangun karena: Boot pertama kali");
  }

  Serial.print("Total wake: ");
  Serial.println(wakeCount);

  // Tampilkan nilai pembacaan touch
  uint32_t nilaiTouch;
  touch_pad_read(TOUCH_PIN, &nilaiTouch);
  Serial.print("Nilai touch saat ini: ");
  Serial.println(nilaiTouch);

  // Aktifkan touch wakeup
  touch_pad_init();
  touch_pad_set_meas_time(TOUCH_PAD_MEAS_TIME_DEFAULT,
                          TOUCH_PAD_MEAS_TIME_DEFAULT);
  touch_pad_config(TOUCH_PIN, TOUCH_THRESHOLD);
  esp_sleep_enable_touchpad_wakeup();

  Serial.println("Masuk Deep Sleep... (sentuh pad untuk bangun)");
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
  // Tidak digunakan
}

// ESP32 Deep Sleep dengan ULP Coprocessor
// Membaca sensor analog dari ADC dan membangunkan
// ESP32 saat nilai melampaui threshold
// IoTHub - https://iothub.id

#include <Arduino.h>
#include "soc/rtc_io.h"
#include "esp_sleep.h"

// Pin sensor analog
#define SENSOR_PIN    36     // GPIO 36 (VP) — ADC1_CH0
#define THRESHOLD     2000   // Threshold ADC (0-4095)

// Deklarasi fungsi assembly ULP
extern const uint8_t ulp_machine_start[] asm("_binary_ulp_program_bin_start");
extern const uint8_t ulp_machine_end[] asm("_binary_ulp_program_bin_end");

RTC_DATA_ATTR int wakeCount = 0;

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

  wakeCount++;

  // Cek alasan wake-up
  esp_sleep_wakeup_cause_t penyebab = esp_sleep_get_wakeup_cause();

  if (penyebab == ESP_SLEEP_WAKEUP_ULP) {
    Serial.println("Bangun karena: ULP Coprocessor!");

    // Baca nilai sensor terakhir dari RTC memory
    uint32_t nilaiSensor;
    rtc_gpio_isolate(GPIO_NUM_36);  // Isolasi pin setelah bangun
    Serial.println("Kondisi threshold tercapai!");
  } else {
    Serial.println("Bangun karena: Boot / Reset");
  }

  Serial.print("Wake-up ke-: ");
  Serial.println(wakeCount);

  // --- Lakukan pekerjaan utama ---
  int bacaSensor = analogRead(SENSOR_PIN);
  Serial.print("Nilai sensor: ");
  Serial.println(bacaSensor);

  // Konfigurasi ULP
  initUlpSensor();

  // Masuk Deep Sleep
  Serial.println("Masuk Deep Sleep (ULP aktif)...");
  Serial.flush();
  esp_deep_sleep_start();
}

void initUlpSensor() {
  // Load program ULP dari binary yang dikompilasi
  size_t ukuran = ulp_machine_end - ulp_machine_start;
  esp_err_t err = ulp_load_binary(0, ulp_machine_start, ukuran);

  if (err != ESP_OK) {
    Serial.print("Error loading ULP program: ");
    Serial.println(esp_err_to_name(err));
    return;
  }

  // Konfigurasi ULP untuk membaca ADC
  ulp_set_wakeup_period(0, 5000000);  // Bangun setiap 5 detik

  // Set threshold di RTC memory
  // Posisi RTC memory yang digunakan oleh ULP
  // untuk menyimpan hasil pembacaan

  // Mulai ULP
  err = ulp_run(&ulp_machine_start - (uint32_t *)rtc_get_address());

  if (err != ESP_OK) {
    Serial.print("Error starting ULP: ");
    Serial.println(esp_err_to_name(err));
  }
}

void loop() {
  // Tidak digunakan
}

// Membaca konsumsi daya ESP32 menggunakan INA219
// IoTHub - https://iothub.id

#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
// IoTHub - https://iothub.id

#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
// IoTHub - https://iothub.id

#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();
}