Consumption States and the Autonomy of an ESP32-C6 Node

#include <esp_sleep.h>

#define uS_PER_S   1000000ULL
#define SLEEP_S    10             // how many seconds we sleep

// The RTC_DATA_ATTR attribute places the variable in the always-powered
// domain's memory. It survives deep sleep; an ordinary variable does not.
RTC_DATA_ATTR int wakeup_count = 0;
RTC_DATA_ATTR uint32_t total_active_time_ms = 0;

int ordinary_counter = 0;          // this will always be 0 after wakeup

void print_wakeup_reason() {
  switch (esp_sleep_get_wakeup_cause()) {
    case ESP_SLEEP_WAKEUP_TIMER:  Serial.println("woken by the timer");  break;
    case ESP_SLEEP_WAKEUP_GPIO:   Serial.println("woken by a pin");      break;
    case ESP_SLEEP_WAKEUP_EXT1:   Serial.println("woken by EXT1");       break;
    default:                      Serial.println("normal power-on (not from sleep)");
  }
}

void setup() {
  uint32_t t0 = millis();
  Serial.begin(115200);
  delay(200);                     // without this pause we miss the first messages

  wakeup_count++;
  ordinary_counter++;

  Serial.println("-----------------------------");
  print_wakeup_reason();
  Serial.printf("wakeups (RTC memory) : %d\n", wakeup_count);
  Serial.printf("ordinary counter     : %d   <- always 1\n", ordinary_counter);
  Serial.printf("cumulative active time : %lu ms\n", total_active_time_ms);

  // The actual work would go here: sensor reading, transmission.
  delay(500);

  total_active_time_ms += millis() - t0;

  Serial.printf("sleeping for %d seconds...\n", SLEEP_S);
  Serial.flush();                 // flush the serial buffer BEFORE sleeping

  esp_sleep_enable_timer_wakeup(SLEEP_S * uS_PER_S);
  esp_deep_sleep_start();         // nothing executes past this point
}

void loop() {
  // Never reached: esp_deep_sleep_start() does not return.
}

#include <esp_sleep.h>

#define uS_PER_S    1000000ULL
#define SLEEP_S     30
#define BUTTON_PIN  GPIO_NUM_4    // on the C6, pin wakeup requires GPIO0..GPIO7

RTC_DATA_ATTR int timer_wakeups = 0;
RTC_DATA_ATTR int button_wakeups = 0;

void setup() {
  Serial.begin(115200);
  delay(200);

  esp_sleep_wakeup_cause_t reason = esp_sleep_get_wakeup_cause();
  if (reason == ESP_SLEEP_WAKEUP_TIMER) {
    timer_wakeups++;
    Serial.println("timer - scheduled measurement");
  } else if (reason == ESP_SLEEP_WAKEUP_GPIO) {
    button_wakeups++;
    Serial.println("BUTTON - unexpected event!");
  } else {
    Serial.println("cold start");
  }
  Serial.printf("timer: %d   button: %d\n",
                timer_wakeups, button_wakeups);

  // The button ties the pin to ground when pressed, so we hold it high with
  // an internal resistor and wake up on the falling edge.
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  // Two wakeup sources active at the same time.
  esp_sleep_enable_timer_wakeup(SLEEP_S * uS_PER_S);
  esp_deep_sleep_enable_gpio_wakeup(BIT(BUTTON_PIN), ESP_GPIO_WAKEUP_GPIO_LOW);

  Serial.println("sleeping - press the button or wait 30 s");
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {}

esp_sleep_enable_timer_wakeup(5 * uS_PER_S);
esp_light_sleep_start();          // this function DOES RETURN

Serial.println("woke up and continuing from here");
Serial.printf("variables are intact: %d\n", ordinary_counter);

#include <WiFi.h>
#include <esp_wifi.h>

const char* SSID = "lab_network";
const char* PASSWORD = "password";

// Everything worth remembering from the previous cycle, so we do not redo it.
RTC_DATA_ATTR uint8_t  saved_channel = 0;
RTC_DATA_ATTR uint8_t  saved_bssid[6];
RTC_DATA_ATTR bool     have_saved_data = false;
RTC_DATA_ATTR uint32_t consecutive_failures = 0;

// A fixed address completely removes the DHCP negotiation.
IPAddress local_ip(192, 168, 1, 77);
IPAddress gateway  (192, 168, 1, 1);
IPAddress subnet   (255, 255, 255, 0);
IPAddress dns      (192, 168, 1, 1);

bool connect(uint32_t limit_ms = 8000) {
  uint32_t t0 = millis();

  WiFi.mode(WIFI_STA);
  WiFi.config(local_ip, gateway, subnet, dns);   // no DHCP
  WiFi.setSleep(true);                            // the radio turns off between frames

  if (have_saved_data) {
    // We know exactly which channel and access point: no scanning.
    WiFi.begin(SSID, PASSWORD, saved_channel, saved_bssid);
  } else {
    WiFi.begin(SSID, PASSWORD);                   // the first time, we search
  }

  while (WiFi.status() != WL_CONNECTED && millis() - t0 < limit_ms) {
    delay(10);
  }

  if (WiFi.status() != WL_CONNECTED) {
    consecutive_failures++;
    // After three failures we suspect the access point moved to another
    // channel and drop the saved data, to redo a full scan.
    if (consecutive_failures >= 3) have_saved_data = false;
    return false;
  }

  saved_channel = WiFi.channel();
  memcpy(saved_bssid, WiFi.BSSID(), 6);
  have_saved_data = true;
  consecutive_failures = 0;

  Serial.printf("connected in %lu ms  (channel %d, IP %s)\n",
                millis() - t0, saved_channel, WiFi.localIP().toString().c_str());
  return true;
}

#include <WiFi.h>
#include <HTTPClient.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <esp_sleep.h>

#define uS_PER_S      1000000ULL
#define PERIOD_S      900              // 15 minutes
#define SDA_PIN       6
#define SCL_PIN       7

const char* SSID     = "lab_network";
const char* PASSWORD = "password";
const char* SERVER   = "http://192.168.1.10:8000/readings";

RTC_DATA_ATTR uint32_t cycle = 0;
RTC_DATA_ATTR uint32_t total_active_time_ms = 0;
RTC_DATA_ATTR uint8_t  saved_channel = 0;
RTC_DATA_ATTR uint8_t  saved_bssid[6];
RTC_DATA_ATTR bool     have_saved_data = false;

Adafruit_BME280 bme;

void go_to_sleep(const char* reason) {
  total_active_time_ms += millis();
  Serial.printf("[%s] active %lu ms  (cumulative %lu ms over %lu cycles)\n",
                reason, millis(), total_active_time_ms, cycle);
  Serial.flush();

  WiFi.disconnect(true);               // explicitly turn off the radio
  WiFi.mode(WIFI_OFF);

  esp_sleep_enable_timer_wakeup((uint64_t) PERIOD_S * uS_PER_S);
  esp_deep_sleep_start();
}

void setup() {
  Serial.begin(115200);
  delay(150);
  cycle++;

  // --- 1. the sensor, as early as possible: it can be read without Wi-Fi on ---
  Wire.begin(SDA_PIN, SCL_PIN);
  if (!bme.begin(0x76)) {              // some modules respond at 0x77
    Serial.println("the sensor is not responding");
    go_to_sleep("no sensor");
  }

  // Forced mode: the sensor takes a single measurement on request and then stops.
  // This is exactly what we need - a sensor that measures continuously wastes energy.
  bme.setSampling(Adafruit_BME280::MODE_FORCED,
                  Adafruit_BME280::SAMPLING_X1,     // temperature
                  Adafruit_BME280::SAMPLING_X1,     // pressure
                  Adafruit_BME280::SAMPLING_X1,     // humidity
                  Adafruit_BME280::FILTER_OFF);
  bme.takeForcedMeasurement();

  float temperature = bme.readTemperature();
  float humidity    = bme.readHumidity();
  float pressure    = bme.readPressure() / 100.0F;

  Serial.printf("cycle %lu: %.2f degC  %.1f%%  %.1f hPa\n",
                cycle, temperature, humidity, pressure);

  // --- 2. the network, as late and as briefly as possible ---
  WiFi.mode(WIFI_STA);
  WiFi.setSleep(true);
  if (have_saved_data) WiFi.begin(SSID, PASSWORD, saved_channel, saved_bssid);
  else                 WiFi.begin(SSID, PASSWORD);

  uint32_t t0 = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - t0 < 8000) delay(10);
  if (WiFi.status() != WL_CONNECTED) {
    have_saved_data = false;           // redo a scan next time
    go_to_sleep("no network");
  }
  saved_channel = WiFi.channel();
  memcpy(saved_bssid, WiFi.BSSID(), 6);
  have_saved_data = true;

  // --- 3. the transmission ---
  char body[160];
  snprintf(body, sizeof(body),
           "{\"cycle\":%lu,\"temp\":%.2f,\"humid\":%.1f,\"pres\":%.1f,\"active_ms\":%lu}",
           cycle, temperature, humidity, pressure, millis());

  HTTPClient http;
  http.begin(SERVER);
  http.addHeader("Content-Type", "application/json");
  int code = http.POST(body);
  Serial.printf("server: %d\n", code);
  http.end();

  go_to_sleep("ok");
}

void loop() {}

#include <WiFi.h>
#include <WiFiUdp.h>
#include <Wire.h>
#include <Adafruit_INA219.h>
#include <LiquidCrystal_I2C.h>
#include <esp_sleep.h>

#define SDA_PIN     6
#define SCL_PIN     7
#define DURATION_MS 10000UL            // how long each state is held
#define SLEEP_S     20                 // how long each sleep state lasts
#define uS_PER_S    1000000ULL

const char* SSID     = "lab_network";
const char* PASSWORD = "password";

Adafruit_INA219   ina(0x40);
LiquidCrystal_I2C lcd(0x27, 16, 2);    // some adapters answer at 0x3F
WiFiUDP           udp;

// Continuous transmission: UDP broadcast packets, no server needed.
void transmit() {
  static uint8_t buf[1000];
  udp.beginPacket(IPAddress(255, 255, 255, 255), 9999);
  udp.write(buf, sizeof(buf));
  udp.endPacket();
}

// Holds the state for DURATION_MS, averages the current, shows it every second.
float measure(const char* name, void (*work)() = nullptr) {
  lcd.clear();
  lcd.print(name);
  double sum = 0;
  uint32_t n = 0;
  unsigned long t0 = millis(), shown = t0;
  while (millis() - t0 < DURATION_MS) {
    if (work) work(); else delay(2);
    sum += ina.getCurrent_mA();
    n++;
    if (millis() - shown >= 1000) {
      shown = millis();
      lcd.setCursor(0, 1);
      lcd.printf("I=%7.1f mA    ", sum / n);
    }
  }
  return sum / n;
}

// The LCD is powered before the shunt: the text stays while the board sleeps.
void announceSleep(const char* name) {
  lcd.clear();
  lcd.print(name);
  lcd.setCursor(0, 1);
  lcd.print("read multimeter");
  ina.powerSave(true);                 // INA219 drops to a few uA
  delay(50);
}

void setup() {
  Wire.begin(SDA_PIN, SCL_PIN);
  lcd.init();
  lcd.backlight();
  if (!ina.begin(&Wire)) {
    lcd.print("no INA219!");
    while (true) delay(1000);
  }
  ina.setCalibration_32V_1A();         // 0.04 mA step, handles the Wi-Fi peaks

  WiFi.mode(WIFI_OFF);
  measure("WiFi off");

  lcd.clear();
  lcd.print("connecting...");
  WiFi.begin(SSID, PASSWORD);
  while (WiFi.status() != WL_CONNECTED) delay(100);
  measure("WiFi idle");
  measure("WiFi transmit", transmit);

  WiFi.mode(WIFI_OFF);
  announceSleep("Light-sleep 20 s");
  esp_sleep_enable_timer_wakeup(SLEEP_S * uS_PER_S);
  esp_light_sleep_start();             // the program continues from here
  ina.powerSave(false);

  announceSleep("Deep-sleep 20 s");
  esp_deep_sleep_start();              // on wakeup, setup() starts over
}

void loop() {}