ESP32 Battery Life Optimization: Deep Sleep Techniques

// Basic deep sleep example - wake after 10 seconds
#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  Serial.println("Starting ESP32 Deep Sleep Demo");
  
  // Get wake-up reason
  esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
  Serial.printf("Wake-up reason: %d\n", wakeup_reason);
  
  // Deep sleep for 10 seconds (10,000,000 microseconds)
  esp_sleep_enable_timer_wakeup(10000000);
  esp_deep_sleep_start();
}

void loop() {
  // This won't execute in deep sleep
}

#include <WiFi.h>
#include <esp_sleep.h>

// Define RTC memory area
RTC_DATA_ATTR int counter = 0;

void setup() {
  Serial.begin(115200);
  
  // Read and increment counter
  counter++;
  Serial.printf("Wake #%d\n", counter);
  
  // WiFi reconnection logic
  connectWiFi();
  
  // Send data if needed
  sendSensorData();
  
  // Prepare for next wake cycle
  prepareForSleep();
}

void loop() {}

void connectWiFi() {
  WiFi.begin("YourSSID", "YourPassword");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");
}

void sendSensorData() {
  // Implement your sensor reading and sending logic
  // Consider using MQTT or HTTP for data transmission
}

void prepareForSleep() {
  // Disable peripherals to save power
  WiFi.mode(WIFI_OFF);
  
  // Configure wake-up source (timer in this case)
  esp_sleep_enable_timer_wakeup(5000000); // 5 seconds
  
  // Optional: Set GPIO for wake-up on touch
  // esp_sleep_enable_touchpad_wakeup();
  
  // Deep sleep
  esp_deep_sleep_start();
}

#include <WiFi.h>
#include <esp_sleep.h>
#include <esp_timer.h>
#include <driver/rtc_io.h>

RTC_DATA_ATTR struct {
  float sensor_value;
  unsigned long last_transmission;
} rtc_data;

void ultra_low_power_setup() {
  // Configure pins as RTC GPIO (low power)
  rtc_gpio_init(RTC_GPIO_NUM_4);
  rtc_gpio_set_direction(RTC_GPIO_NUM_4, RTC_GPIO_MODE_INPUT);
  
  // Disable all non-essential peripherals
  WiFi.mode(WIFI_OFF);
  
  // Configure brownout detector for lowest voltage
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 3);
  
  // Set minimum sleep duration
  esp_sleep_enable_timer_wakeup(1000000);
}

void optimized_main() {
  // Power measurement setup
  WiFi.begin("test");
  
  // Your application logic here
  readSensor();
  processData();
  
  if (shouldTransmit()) {
    transmitData();
  }
  
  ultra_low_power_setup();
}

void readSensor() {
  // Use RTC timer for sensor readings
  rtc_data.sensor_value = readADC();
}

void processData() {
  // Process sensor data
  if (rtc_data.sensor_value > threshold) {
    triggerAlert();
  }
}

void transmitData() {
  // Implement efficient data transmission
  // Use MQTT with QoS 0 for minimal overhead
}

// Include power monitoring code
#include <WiFi.h>
#include <esp_sleep.h>

void measurePowerConsumption() {
  Serial.println("Measuring active power consumption...");
  
  // Disable sleep for measurement period
  esp_sleep_enable_timer_wakeup(0);
  
  unsigned long startTime = millis();
  float voltage = 3.3; // Measured battery voltage
  
  // Read current (requires external current sensor)
  float current = readCurrentSensor();
  
  Serial.printf("Active power: %.2f mW (%.2f mA)\n", 
                current * voltage * 1000, current * 1000);
  
  esp_deep_sleep_start();
}

// Add to your main code for periodic power checks
void periodicPowerCheck() {
  static unsigned long lastCheck = 0;
  if (millis() - lastCheck > 3600000) { // Every hour
    measurePowerConsumption();
    lastCheck = millis();
  }
}

void debugDeepSleep() {
  // Verify wake-up source
  esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
  
  switch(cause) {
    case ESP_SLEEP_WAKEUP_TIMER:
      Serial.println("Timer wake-up");
      break;
    case ESP_SLEEP_WAKEUP_EXT0:
      Serial.println("External wake-up pin 0");
      break;
    case ESP_SLEEP_WAKEUP_EXT1:
      Serial.println("External wake-up pins");
      break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD:
      Serial.println("Touchpad wake-up");
      break;
    case ESP_SLEEP_WAKEUP_ULP:
      Serial.println("ULP wake-up");
      break;
    default:
      Serial.println("Unknown wake-up cause");
  }
  
  // Check RTC memory
  Serial.printf("RTC counter: %d\n", rtc_data.counter);
}

struct PowerProfile {
  float active_current;
  float deep_sleep_current;
  unsigned long active_time;
  unsigned long sleep_time;
};

PowerProfile profileBatteryUsage() {
  PowerProfile profile = {0};
  
  // Measure active current
  profile.active_current = measureActiveCurrent();
  
  // Measure deep sleep current
  profile.deep_sleep_current = measureDeepSleepCurrent();
  
  // Calculate duty cycle
  profile.active_time = getActiveDuration();
  profile.sleep_time = getSleepDuration();
  
  return profile;
}