// Light Sleep Mode Example
#include "esp_sleep.h"

void setup() {
  Serial.begin(115200);
  
  // กำหนด wake-up source
  esp_sleep_enable_timer_wakeup(10 * 1000000); // 10 วินาที (microseconds)
  
  Serial.println("Going to Light Sleep...");
  Serial.flush();
  
  // เข้า Light Sleep Mode
  esp_light_sleep_start();
  
  // ตื่นขึ้นมาแล้ว
  Serial.println("Woke up from Light Sleep!");
}

void loop() {
  // โค้ดหลังตื่นขึ้น
  Serial.println("Running normal code...");
  delay(5000);
  
  // เข้า Light Sleep อีกครั้ง
  Serial.println("Going back to Light Sleep...");
  esp_light_sleep_start();
  Serial.println("Woke up again!");
}

// Deep Sleep Mode Example
#include "esp_sleep.h"

// RTC Memory สำหรับเก็บข้อมูลข้าม Deep Sleep
RTC_DATA_ATTR int bootCount = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  // เพิ่มจำนวนครั้งที่ Boot
  ++bootCount;
  Serial.println("Boot number: " + String(bootCount));
  
  // แสดงสาเหตุที่ตื่นขึ้น
  print_wakeup_reason();
  
  // กำหนด wake-up source
  esp_sleep_enable_timer_wakeup(20 * 1000000); // 20 วินาที
  
  Serial.println("Going to Deep Sleep for 20 seconds...");
  Serial.flush();
  
  // เข้า Deep Sleep Mode
  esp_deep_sleep_start();
  
  // โค้ดหลังจากนี้จะไม่ทำงาน
  Serial.println("This will never be printed");
}

void loop() {
  // ใน Deep Sleep Mode, loop() จะไม่ทำงาน
}

void print_wakeup_reason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wakeup caused by external signal using RTC_IO");
      break;
    case ESP_SLEEP_WAKEUP_EXT1:
      Serial.println("Wakeup caused by external signal using RTC_CNTL");
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wakeup caused by timer");
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Wakeup caused by touchpad");
      break;
    case ESP_SLEEP_WAKEUP_ULP:
      Serial.println("Wakeup caused by ULP program");
      break;
    default:
      Serial.printf("Wakeup was not caused by deep sleep: %d\n", wakeup_reason);
      break;
  }
}

// Hibernation Mode Example
#include "esp_sleep.h"

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  Serial.println("ESP32 will enter Hibernation Mode");
  Serial.println("Wake up only by pressing RESET button");
  Serial.flush();
  
  // ปิด RTC Peripherals ทั้งหมด
  esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
  esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_SLOW_MEM, ESP_PD_OPTION_OFF);
  esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_FAST_MEM, ESP_PD_OPTION_OFF);
  
  // เข้า Deep Sleep โดยไม่มี wake-up source (Hibernation)
  esp_deep_sleep_start();
}

void loop() {
  // จะไม่ทำงาน
}

// ตัวอย่างการใช้ External Wake-up สำหรับ Hibernation
void setupExternalWakeup() {
  // ใช้ GPIO 33 เป็น wake-up source
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_33, 0); // Wake เมื่อ GPIO 33 เป็น LOW
  
  Serial.println("Going to Hibernation...");
  Serial.println("Press button on GPIO 33 to wake up");
  
  esp_deep_sleep_start();
}

// Pin Connections for Deep Sleep Testing

// Wake-up Buttons
#define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex (GPIO 33)
#define EXT_WAKEUP_PIN_1 33  // External wake-up pin 1
#define EXT_WAKEUP_PIN_2 32  // External wake-up pin 2

// LED Indicators
#define LED_RED    25   // Red LED - Active Mode
#define LED_GREEN  26   // Green LED - Light Sleep
#define LED_BLUE   27   // Blue LED - Deep Sleep

// Touch Pins (if using touch wake-up)
#define TOUCH_PIN_1 T0  // GPIO 4
#define TOUCH_PIN_2 T3  // GPIO 15

// Connection Details:
// GPIO 33 -> Button 1 -> GND (with 10kΩ pull-up to 3.3V)
// GPIO 32 -> Button 2 -> GND (with 10kΩ pull-up to 3.3V)
// GPIO 25 -> 220Ω -> Red LED -> GND
// GPIO 26 -> 220Ω -> Green LED -> GND
// GPIO 27 -> 220Ω -> Blue LED -> GND

/*
  ESP32 Deep Sleep Timer Wake-up Example
  ตื่นจาก Deep Sleep ทุก 20 วินาที
*/

#include "esp_sleep.h"

// RTC Memory สำหรับนับจำนวนครั้งที่ตื่น
RTC_DATA_ATTR int bootCount = 0;

// Pin definitions
#define LED_PIN 2
#define SLEEP_TIME_SECONDS 20

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  // เพิ่มจำนวนครั้งที่ Boot
  ++bootCount;
  
  // ตั้งค่า LED
  pinMode(LED_PIN, OUTPUT);
  
  // แสดงข้อมูลการตื่น
  Serial.println("=================================");
  Serial.println("ESP32 Deep Sleep Timer Wake-up");
  Serial.println("=================================");
  Serial.println("Boot count: " + String(bootCount));
  
  // แสดงสาเหตุที่ตื่น
  print_wakeup_reason();
  
  // กระพริบ LED เพื่อแสดงว่าตื่นแล้ว
  for(int i = 0; i < 5; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
    delay(200);
  }
  
  // ทำงานปกติ 5 วินาที
  Serial.println("Running for 5 seconds...");
  for(int i = 5; i > 0; i--) {
    Serial.println("Countdown: " + String(i));
    delay(1000);
  }
  
  // เตรียมเข้า Deep Sleep
  Serial.println("Going to Deep Sleep for " + String(SLEEP_TIME_SECONDS) + " seconds");
  
  // กำหนด Timer Wake-up
  esp_sleep_enable_timer_wakeup(SLEEP_TIME_SECONDS * 1000000ULL);
  
  Serial.println("Deep Sleep starting...");
  Serial.flush();
  
  // เข้า Deep Sleep
  esp_deep_sleep_start();
  
  // โค้ดหลังจากนี้จะไม่ทำงาน
}

void loop() {
  // ใน Deep Sleep Mode, loop() จะไม่ทำงาน
}

void print_wakeup_reason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wakeup: External signal (RTC_IO)");
      break;
    case ESP_SLEEP_WAKEUP_EXT1:
      Serial.println("Wakeup: External signal (RTC_CNTL)");
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wakeup: Timer");
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Wakeup: Touchpad");
      break;
    case ESP_SLEEP_WAKEUP_ULP:
      Serial.println("Wakeup: ULP program");
      break;
    default:
      Serial.println("Wakeup: Power on or reset");
      break;
  }
}

/*
  ESP32 Deep Sleep External Wake-up (EXT0) Example
  ตื่นเมื่อกดปุ่มที่ GPIO 33
*/

#include "esp_sleep.h"

// Pin definitions
#define BUTTON_PIN 33  // RTC GPIO สำหรับ wake-up
#define LED_PIN 2

RTC_DATA_ATTR int bootCount = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  ++bootCount;
  
  // ตั้งค่า pins
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  
  Serial.println("=================================");
  Serial.println("ESP32 External Wake-up (EXT0)");
  Serial.println("=================================");
  Serial.println("Boot count: " + String(bootCount));
  
  // แสดงสาเหตุที่ตื่น
  print_wakeup_reason();
  
  // กระพริบ LED
  blinkLED(3);
  
  // แสดงสถานะปุ่ม
  Serial.println("Button state: " + String(digitalRead(BUTTON_PIN)));
  
  // รอ 5 วินาที
  Serial.println("Running for 5 seconds...");
  delay(5000);
  
  // เตรียมเข้า Deep Sleep
  Serial.println("Going to Deep Sleep...");
  Serial.println("Press button on GPIO 33 to wake up");
  
  // กำหนด External Wake-up (EXT0)
  // ตื่นเมื่อ GPIO 33 เป็น LOW (กดปุ่ม)
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_33, 0);
  
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
  // ไม่ทำงาน
}

void blinkLED(int times) {
  for(int i = 0; i < times; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(300);
    digitalWrite(LED_PIN, LOW);
    delay(300);
  }
}

void print_wakeup_reason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wakeup: Button pressed (EXT0)");
      break;
    case ESP_SLEEP_WAKEUP_EXT1:
      Serial.println("Wakeup: External signal (EXT1)");
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wakeup: Timer");
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Wakeup: Touchpad");
      break;
    case ESP_SLEEP_WAKEUP_ULP:
      Serial.println("Wakeup: ULP program");
      break;
    default:
      Serial.println("Wakeup: Power on or reset");
      break;
  }
}

/*
  ESP32 Deep Sleep External Wake-up (EXT1) Example
  ตื่นเมื่อกดปุ่มใดปุ่มหนึ่งใน GPIO 32 หรือ 33
*/

#include "esp_sleep.h"

// Pin definitions
#define BUTTON_PIN_1 32  // ปุ่มที่ 1
#define BUTTON_PIN_2 33  // ปุ่มที่ 2
#define LED_RED 25
#define LED_GREEN 26

// Bitmask สำหรับ EXT1 wake-up
#define BUTTON_PIN_BITMASK 0x300000000 // 2^32 + 2^33 in hex

RTC_DATA_ATTR int bootCount = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  ++bootCount;
  
  // ตั้งค่า pins
  pinMode(BUTTON_PIN_1, INPUT_PULLUP);
  pinMode(BUTTON_PIN_2, INPUT_PULLUP);
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  
  Serial.println("=================================");
  Serial.println("ESP32 External Wake-up (EXT1)");
  Serial.println("=================================");
  Serial.println("Boot count: " + String(bootCount));
  
  // แสดงสาเหตุที่ตื่น
  print_wakeup_reason();
  
  // ตรวจสอบปุ่มไหนที่ถูกกด
  checkWakeupButton();
  
  // รอ 5 วินาที
  Serial.println("Running for 5 seconds...");
  delay(5000);
  
  // เตรียมเข้า Deep Sleep
  Serial.println("Going to Deep Sleep...");
  Serial.println("Press any button (GPIO 32 or 33) to wake up");
  
  // กำหนด External Wake-up (EXT1)
  // ตื่นเมื่อ GPIO ใดใน bitmask เป็น HIGH
  esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK, ESP_EXT1_WAKEUP_ANY_HIGH);
  
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
  // ไม่ทำงาน
}

void checkWakeupButton() {
  if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_EXT1) {
    uint64_t wakeup_pin_mask = esp_sleep_get_ext1_wakeup_status();
    
    if (wakeup_pin_mask != 0) {
      int pin = __builtin_ffsll(wakeup_pin_mask) - 1;
      Serial.printf("Wake up from GPIO %d\n", pin);
      
      if (pin == BUTTON_PIN_1) {
        Serial.println("Button 1 pressed!");
        blinkLED(LED_RED, 3);
      } else if (pin == BUTTON_PIN_2) {
        Serial.println("Button 2 pressed!");
        blinkLED(LED_GREEN, 3);
      }
    }
  } else {
    // First boot หรือ wake-up จากสาเหตุอื่น
    blinkLED(LED_RED, 1);
    blinkLED(LED_GREEN, 1);
  }
}

void blinkLED(int ledPin, int times) {
  for(int i = 0; i < times; i++) {
    digitalWrite(ledPin, HIGH);
    delay(300);
    digitalWrite(ledPin, LOW);
    delay(300);
  }
}

void print_wakeup_reason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wakeup: External signal (EXT0)");
      break;
    case ESP_SLEEP_WAKEUP_EXT1:
      Serial.println("Wakeup: External signal (EXT1)");
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wakeup: Timer");
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Wakeup: Touchpad");
      break;
    case ESP_SLEEP_WAKEUP_ULP:
      Serial.println("Wakeup: ULP program");
      break;
    default:
      Serial.println("Wakeup: Power on or reset");
      break;
  }
}

/*
  ESP32 Deep Sleep Touch Wake-up Example
  ตื่นเมื่อสัมผัส Touch Sensor
*/

#include "esp_sleep.h"

// Touch pins
#define TOUCH_PIN T0  // GPIO 4
#define LED_PIN 2

RTC_DATA_ATTR int bootCount = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  ++bootCount;
  
  pinMode(LED_PIN, OUTPUT);
  
  Serial.println("=================================");
  Serial.println("ESP32 Touch Wake-up Example");
  Serial.println("=================================");
  Serial.println("Boot count: " + String(bootCount));
  
  // แสดงสาเหตุที่ตื่น
  print_wakeup_reason();
  
  // กระพริบ LED
  blinkLED(3);
  
  // อ่านค่า Touch Sensor
  int touchValue = touchRead(TOUCH_PIN);
  Serial.println("Touch value: " + String(touchValue));
  
  // รอ 5 วินาที
  Serial.println("Running for 5 seconds...");
  delay(5000);
  
  // เตรียมเข้า Deep Sleep
  Serial.println("Going to Deep Sleep...");
  Serial.println("Touch GPIO 4 to wake up");
  
  // กำหนด Touch Wake-up
  // ตื่นเมื่อค่า touch น้อยกว่า threshold (สัมผัส)
  touchSleepWakeUpEnable(TOUCH_PIN, 40);
  
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
  // ไม่ทำงาน
}

void blinkLED(int times) {
  for(int i = 0; i < times; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(300);
    digitalWrite(LED_PIN, LOW);
    delay(300);
  }
}

void print_wakeup_reason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wakeup: External signal (EXT0)");
      break;
    case ESP_SLEEP_WAKEUP_EXT1:
      Serial.println("Wakeup: External signal (EXT1)");
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wakeup: Timer");
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Wakeup: Touch sensor");
      // แสดงว่า touch pad ไหนที่ตื่น
      touch_pad_t touchPin = esp_sleep_get_touchpad_wakeup_status();
      Serial.println("Touch detected on pad: " + String(touchPin));
      break;
    case ESP_SLEEP_WAKEUP_ULP:
      Serial.println("Wakeup: ULP program");
      break;
    default:
      Serial.println("Wakeup: Power on or reset");
      break;
  }
}

/*
  ESP32 Complete Deep Sleep Example
  รวม Wake-up Sources ทั้งหมด: Timer, External, Touch
*/

#include "esp_sleep.h"

// Pin definitions
#define BUTTON_PIN 33
#define TOUCH_PIN T0  // GPIO 4
#define LED_RED 25
#define LED_GREEN 26
#define LED_BLUE 27

// Sleep settings
#define SLEEP_TIME_SECONDS 30
#define TOUCH_THRESHOLD 40

// RTC Memory
RTC_DATA_ATTR int bootCount = 0;
RTC_DATA_ATTR int timerWakeups = 0;
RTC_DATA_ATTR int buttonWakeups = 0;
RTC_DATA_ATTR int touchWakeups = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  ++bootCount;
  
  // ตั้งค่า pins
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_BLUE, OUTPUT);
  
  Serial.println("=========================================");
  Serial.println("ESP32 Complete Deep Sleep Example");
  Serial.println("=========================================");
  Serial.println("Boot count: " + String(bootCount));
  
  // แสดงสถิติการตื่น
  Serial.println("Wake-up Statistics:");
  Serial.println("- Timer wakeups: " + String(timerWakeups));
  Serial.println("- Button wakeups: " + String(buttonWakeups));
  Serial.println("- Touch wakeups: " + String(touchWakeups));
  
  // แสดงสาเหตุที่ตื่นและนับสถิติ
  handleWakeupReason();
  
  // ทำงานปกติ 10 วินาที
  Serial.println("Running active mode for 10 seconds...");
  for(int i = 10; i > 0; i--) {
    Serial.println("Countdown: " + String(i));
    
    // กระพริบ LED ตามสาเหตุที่ตื่น
    blinkStatusLED();
    
    delay(1000);
  }
  
  // เตรียมเข้า Deep Sleep
  setupDeepSleep();
  
  Serial.println("Entering Deep Sleep...");
  Serial.flush();
  
  esp_deep_sleep_start();
}

void loop() {
  // ไม่ทำงาน
}

void handleWakeupReason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wakeup: Button pressed!");
      buttonWakeups++;
      blinkLED(LED_GREEN, 3);
      break;
      
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wakeup: Timer expired");
      timerWakeups++;
      blinkLED(LED_RED, 2);
      break;
      
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Wakeup: Touch detected!");
      touchWakeups++;
      touch_pad_t touchPin = esp_sleep_get_touchpad_wakeup_status();
      Serial.println("Touch pad: " + String(touchPin));
      blinkLED(LED_BLUE, 4);
      break;
      
    default:
      Serial.println("Wakeup: Power on or reset");
      // กระพริบทุก LED
      blinkLED(LED_RED, 1);
      blinkLED(LED_GREEN, 1);
      blinkLED(LED_BLUE, 1);
      break;
  }
}

void setupDeepSleep() {
  Serial.println("Setting up Deep Sleep wake-up sources:");
  
  // 1. Timer Wake-up (30 วินาที)
  esp_sleep_enable_timer_wakeup(SLEEP_TIME_SECONDS * 1000000ULL);
  Serial.println("- Timer: " + String(SLEEP_TIME_SECONDS) + " seconds");
  
  // 2. External Wake-up (Button)
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_33, 0);
  Serial.println("- Button: GPIO 33 (press to wake)");
  
  // 3. Touch Wake-up
  touchSleepWakeUpEnable(TOUCH_PIN, TOUCH_THRESHOLD);
  Serial.println("- Touch: GPIO 4 (touch to wake)");
  
  Serial.println("Wake up using any of the above methods!");
}

void blinkLED(int ledPin, int times) {
  for(int i = 0; i < times; i++) {
    digitalWrite(ledPin, HIGH);
    delay(200);
    digitalWrite(ledPin, LOW);
    delay(200);
  }
}

void blinkStatusLED() {
  // กระพริบ LED ตามสาเหตุที่ตื่นล่าสุด
  esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      digitalWrite(LED_GREEN, HIGH);
      delay(100);
      digitalWrite(LED_GREEN, LOW);
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      digitalWrite(LED_RED, HIGH);
      delay(100);
      digitalWrite(LED_RED, LOW);
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      digitalWrite(LED_BLUE, HIGH);
      delay(100);
      digitalWrite(LED_BLUE, LOW);
      break;
    default:
      // กระพริบทุก LED
      digitalWrite(LED_RED, HIGH);
      digitalWrite(LED_GREEN, HIGH);
      digitalWrite(LED_BLUE, HIGH);
      delay(100);
      digitalWrite(LED_RED, LOW);
      digitalWrite(LED_GREEN, LOW);
      digitalWrite(LED_BLUE, LOW);
      break;
  }
}

/*
  ESP32 Active Mode Power Consumption Test
  วัดการใช้พลังงานใน Active Mode
*/

#include "WiFi.h"
#include "BluetoothSerial.h"

// WiFi credentials
const char* ssid = "YourWiFiName";
const char* password = "YourWiFiPassword";

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  Serial.println("=================================");
  Serial.println("ESP32 Active Mode Power Test");
  Serial.println("=================================");
  
  // Test 1: CPU Only
  Serial.println("Test 1: CPU Only (No WiFi/Bluetooth)");
  testCPUOnly();
  
  // Test 2: WiFi Active
  Serial.println("Test 2: WiFi Active");
  testWiFiActive();
  
  // Test 3: Bluetooth Active
  Serial.println("Test 3: Bluetooth Active");
  testBluetoothActive();
  
  // Test 4: WiFi + Bluetooth
  Serial.println("Test 4: WiFi + Bluetooth");
  testWiFiAndBluetooth();
}

void loop() {
  // ทำงานต่อเนื่องเพื่อวัดกระแส
  Serial.println("Active Mode - Measure current now!");
  
  // ทำงานหนักๆ เพื่อให้ CPU ใช้พลังงานเต็มที่
  for(int i = 0; i < 1000000; i++) {
    float result = sin(i) * cos(i) * sqrt(i);
  }
  
  delay(5000);
}

void testCPUOnly() {
  Serial.println("CPU running at full speed...");
  Serial.println("Measure current consumption now!");
  
  unsigned long startTime = millis();
  while(millis() - startTime < 10000) { // 10 วินาที
    // ทำงานหนัก
    for(int i = 0; i < 100000; i++) {
      volatile float calc = i * 3.14159;
    }
  }
  
  Serial.println("Expected: 30-50mA");
  Serial.println("------------------------");
}

void testWiFiActive() {
  WiFi.begin(ssid, password);
  
  Serial.println("Connecting to WiFi...");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("");
  Serial.println("WiFi connected!");
  Serial.println("IP address: " + WiFi.localIP().toString());
  Serial.println("Measure current consumption now!");
  
  // ส่งข้อมูลผ่าน WiFi
  for(int i = 0; i < 20; i++) {
    Serial.println("WiFi active - sending data...");
    delay(1000);
  }
  
  Serial.println("Expected: 160-260mA");
  Serial.println("------------------------");
}

void testBluetoothActive() {
  SerialBT.begin("ESP32test");
  Serial.println("Bluetooth started!");
  Serial.println("Measure current consumption now!");
  
  for(int i = 0; i < 20; i++) {
    SerialBT.println("Bluetooth test message " + String(i));
    Serial.println("Bluetooth active...");
    delay(1000);
  }
  
  Serial.println("Expected: 100-150mA");
  Serial.println("------------------------");
}

void testWiFiAndBluetooth() {
  Serial.println("WiFi + Bluetooth both active!");
  Serial.println("Measure current consumption now!");
  
  for(int i = 0; i < 20; i++) {
    SerialBT.println("BT: " + String(i));
    Serial.println("WiFi + BT active...");
    delay(1000);
  }
  
  Serial.println("Expected: 200-300mA");
  Serial.println("------------------------");
}

/*
  ESP32 Deep Sleep Mode Power Consumption Test
  วัดการใช้พลังงานใน Deep Sleep Mode
*/

#include "esp_sleep.h"

#define LED_PIN 2
#define SLEEP_TIME_SECONDS 60  // Sleep 1 นาที

RTC_DATA_ATTR int bootCount = 0;
RTC_DATA_ATTR unsigned long totalSleepTime = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  ++bootCount;
  pinMode(LED_PIN, OUTPUT);
  
  Serial.println("=================================");
  Serial.println("ESP32 Deep Sleep Power Test");
  Serial.println("=================================");
  Serial.println("Boot count: " + String(bootCount));
  Serial.println("Total sleep time: " + String(totalSleepTime) + " seconds");
  
  // แสดงสาเหตุที่ตื่น
  print_wakeup_reason();
  
  // กระพริบ LED เพื่อแสดงว่าตื่นแล้ว
  blinkLED(3);
  
  // ทำงาน Active Mode สั้นๆ (5 วินาที)
  Serial.println("Active mode for 5 seconds...");
  Serial.println("Measure ACTIVE current now!");
  
  for(int i = 5; i > 0; i--) {
    Serial.println("Active countdown: " + String(i));
    digitalWrite(LED_PIN, HIGH);
    delay(500);
    digitalWrite(LED_PIN, LOW);
    delay(500);
  }
  
  // เตรียมเข้า Deep Sleep
  Serial.println("Preparing for Deep Sleep...");
  Serial.println("MEASURE DEEP SLEEP CURRENT IN 3 SECONDS!");
  
  delay(3000);
  
  // บันทึกเวลา Sleep
  totalSleepTime += SLEEP_TIME_SECONDS;
  
  // กำหนด Timer Wake-up
  esp_sleep_enable_timer_wakeup(SLEEP_TIME_SECONDS * 1000000ULL);
  
  Serial.println("Entering Deep Sleep for " + String(SLEEP_TIME_SECONDS) + " seconds...");
  Serial.println("Expected current: ~10µA");
  Serial.flush();
  
  // เข้า Deep Sleep
  esp_deep_sleep_start();
}

void loop() {
  // ไม่ทำงาน
}

void blinkLED(int times) {
  for(int i = 0; i < times; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
    delay(200);
  }
}

void print_wakeup_reason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  
  switch(wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("Wakeup: External signal (RTC_IO)");
      break;
    case ESP_SLEEP_WAKEUP_EXT1:
      Serial.println("Wakeup: External signal (RTC_CNTL)");
      break;
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Wakeup: Timer");
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Wakeup: Touchpad");
      break;
    case ESP_SLEEP_WAKEUP_ULP:
      Serial.println("Wakeup: ULP program");
      break;
    default:
      Serial.println("Wakeup: Power on or reset");
      break;
  }
}