Stările de consum și autonomia unui nod ESP32-C6

#include <esp_sleep.h>

#define uS_PER_S   1000000ULL
#define SOMN_S     10             // cate secunde dormim

// Atributul RTC_DATA_ATTR aseaza variabila in memoria din domeniul mereu
// alimentat. Ea supravietuieste somnului adanc; o variabila obisnuita nu.
RTC_DATA_ATTR int numar_treziri = 0;
RTC_DATA_ATTR uint32_t timp_total_activ_ms = 0;

int contor_obisnuit = 0;          // acesta va fi mereu 0 dupa trezire

void afiseaza_motivul() {
  switch (esp_sleep_get_wakeup_cause()) {
    case ESP_SLEEP_WAKEUP_TIMER:  Serial.println("trezit de temporizator"); break;
    case ESP_SLEEP_WAKEUP_GPIO:   Serial.println("trezit de un pin");       break;
    case ESP_SLEEP_WAKEUP_EXT1:   Serial.println("trezit de EXT1");         break;
    default:                      Serial.println("pornire normala (nu din somn)");
  }
}

void setup() {
  uint32_t t0 = millis();
  Serial.begin(115200);
  delay(200);                     // fara aceasta pauza pierdem primele mesaje

  numar_treziri++;
  contor_obisnuit++;

  Serial.println("-----------------------------");
  afiseaza_motivul();
  Serial.printf("treziri (memorie RTC) : %d\n", numar_treziri);
  Serial.printf("contor obisnuit       : %d   <- mereu 1\n", contor_obisnuit);
  Serial.printf("timp activ cumulat    : %lu ms\n", timp_total_activ_ms);

  // Aici ar veni treaba propriu-zisa: citire senzor, transmisie.
  delay(500);

  timp_total_activ_ms += millis() - t0;

  Serial.printf("adorm %d secunde...\n", SOMN_S);
  Serial.flush();                 // golim tamponul serial INAINTE de a adormi

  esp_sleep_enable_timer_wakeup(SOMN_S * uS_PER_S);
  esp_deep_sleep_start();         // de aici incolo nu se mai executa nimic
}

void loop() {
  // Nu se ajunge niciodata aici: esp_deep_sleep_start() nu se intoarce.
}

#include <esp_sleep.h>

#define uS_PER_S    1000000ULL
#define SOMN_S      30
#define PIN_BUTON   GPIO_NUM_4    // pe C6, trezirea prin pin cere GPIO0..GPIO7

RTC_DATA_ATTR int treziri_temporizator = 0;
RTC_DATA_ATTR int treziri_buton = 0;

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

  esp_sleep_wakeup_cause_t motiv = esp_sleep_get_wakeup_cause();
  if (motiv == ESP_SLEEP_WAKEUP_TIMER) {
    treziri_temporizator++;
    Serial.println("temporizator - masuratoare programata");
  } else if (motiv == ESP_SLEEP_WAKEUP_GPIO) {
    treziri_buton++;
    Serial.println("BUTON - eveniment neasteptat!");
  } else {
    Serial.println("pornire de la zero");
  }
  Serial.printf("temporizator: %d   buton: %d\n",
                treziri_temporizator, treziri_buton);

  // Butonul leaga pinul la masa cand este apasat, deci il tinem sus printr-o
  // rezistenta interna si ne trezim pe front descendent.
  pinMode(PIN_BUTON, INPUT_PULLUP);

  // Doua surse de trezire active simultan.
  esp_sleep_enable_timer_wakeup(SOMN_S * uS_PER_S);
  esp_deep_sleep_enable_gpio_wakeup(BIT(PIN_BUTON), ESP_GPIO_WAKEUP_GPIO_LOW);

  Serial.println("adorm - apasati butonul sau asteptati 30 s");
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {}

esp_sleep_enable_timer_wakeup(5 * uS_PER_S);
esp_light_sleep_start();          // aceasta functie SE INTOARCE

Serial.println("m-am trezit si continui de aici");
Serial.printf("variabilele sunt intacte: %d\n", contor_obisnuit);

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

const char* SSID = "reteaua_laboratorului";
const char* PAROLA = "parola";

// Tot ce merita memorat de la ciclul anterior, ca sa nu-l refacem.
RTC_DATA_ATTR uint8_t  canal_salvat = 0;
RTC_DATA_ATTR uint8_t  bssid_salvat[6];
RTC_DATA_ATTR bool     avem_date_salvate = false;
RTC_DATA_ATTR uint32_t esecuri_la_rand = 0;

// Adresa fixa elimina complet negocierea DHCP.
IPAddress ip_local(192, 168, 1, 77);
IPAddress poarta   (192, 168, 1, 1);
IPAddress masca    (255, 255, 255, 0);
IPAddress dns      (192, 168, 1, 1);

bool conecteaza(uint32_t limita_ms = 8000) {
  uint32_t t0 = millis();

  WiFi.mode(WIFI_STA);
  WiFi.config(ip_local, poarta, masca, dns);   // fara DHCP
  WiFi.setSleep(true);                          // radioul se stinge intre cadre

  if (avem_date_salvate) {
    // Stim exact pe ce canal si la ce punct de acces: fara scanare.
    WiFi.begin(SSID, PAROLA, canal_salvat, bssid_salvat);
  } else {
    WiFi.begin(SSID, PAROLA);                   // prima data, cautam
  }

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

  if (WiFi.status() != WL_CONNECTED) {
    esecuri_la_rand++;
    // Dupa trei esecuri banuim ca punctul de acces s-a mutat pe alt canal
    // si stergem datele memorate, ca sa reluam cu scanare completa.
    if (esecuri_la_rand >= 3) avem_date_salvate = false;
    return false;
  }

  canal_salvat = WiFi.channel();
  memcpy(bssid_salvat, WiFi.BSSID(), 6);
  avem_date_salvate = true;
  esecuri_la_rand = 0;

  Serial.printf("conectat in %lu ms  (canal %d, IP %s)\n",
                millis() - t0, canal_salvat, 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 PERIOADA_S    900              // 15 minute
#define SDA_PIN       6
#define SCL_PIN       7

const char* SSID    = "reteaua_laboratorului";
const char* PAROLA  = "parola";
const char* SERVER  = "http://192.168.1.10:8000/masuratori";

RTC_DATA_ATTR uint32_t ciclu = 0;
RTC_DATA_ATTR uint32_t timp_activ_total_ms = 0;
RTC_DATA_ATTR uint8_t  canal_salvat = 0;
RTC_DATA_ATTR uint8_t  bssid_salvat[6];
RTC_DATA_ATTR bool     avem_date_salvate = false;

Adafruit_BME280 bme;

void adormi(const char* motiv) {
  timp_activ_total_ms += millis();
  Serial.printf("[%s] activ %lu ms  (cumulat %lu ms in %lu cicluri)\n",
                motiv, millis(), timp_activ_total_ms, ciclu);
  Serial.flush();

  WiFi.disconnect(true);               // oprim radioul explicit
  WiFi.mode(WIFI_OFF);

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

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

  // --- 1. senzorul, cat mai devreme: se poate citi fara Wi-Fi pornit ---
  Wire.begin(SDA_PIN, SCL_PIN);
  if (!bme.begin(0x76)) {              // unele module raspund la 0x77
    Serial.println("senzorul nu raspunde");
    adormi("fara senzor");
  }

  // Modul fortat: senzorul face o singura masuratoare la cerere si se opreste.
  // Este exact ce ne trebuie - un senzor care masoara continuu consuma degeaba.
  bme.setSampling(Adafruit_BME280::MODE_FORCED,
                  Adafruit_BME280::SAMPLING_X1,     // temperatura
                  Adafruit_BME280::SAMPLING_X1,     // presiune
                  Adafruit_BME280::SAMPLING_X1,     // umiditate
                  Adafruit_BME280::FILTER_OFF);
  bme.takeForcedMeasurement();

  float temperatura = bme.readTemperature();
  float umiditate   = bme.readHumidity();
  float presiune    = bme.readPressure() / 100.0F;

  Serial.printf("ciclul %lu: %.2f gradeC  %.1f%%  %.1f hPa\n",
                ciclu, temperatura, umiditate, presiune);

  // --- 2. reteaua, cat mai tarziu si cat mai scurt ---
  WiFi.mode(WIFI_STA);
  WiFi.setSleep(true);
  if (avem_date_salvate) WiFi.begin(SSID, PAROLA, canal_salvat, bssid_salvat);
  else                   WiFi.begin(SSID, PAROLA);

  uint32_t t0 = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - t0 < 8000) delay(10);
  if (WiFi.status() != WL_CONNECTED) {
    avem_date_salvate = false;         // reluam cu scanare data viitoare
    adormi("fara retea");
  }
  canal_salvat = WiFi.channel();
  memcpy(bssid_salvat, WiFi.BSSID(), 6);
  avem_date_salvate = true;

  // --- 3. transmisia ---
  char corp[160];
  snprintf(corp, sizeof(corp),
           "{\"ciclu\":%lu,\"temp\":%.2f,\"umid\":%.1f,\"pres\":%.1f,\"activ_ms\":%lu}",
           ciclu, temperatura, umiditate, presiune, millis());

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

  adormi("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 DURATA_MS   10000UL            // cat timp tinem fiecare stare
#define SOMN_S      20                 // cat dureaza fiecare stare de somn
#define uS_PER_S    1000000ULL

const char* SSID   = "reteaua_laboratorului";
const char* PAROLA = "parola";

Adafruit_INA219   ina(0x40);
LiquidCrystal_I2C lcd(0x27, 16, 2);    // unele adaptoare raspund la 0x3F
WiFiUDP           udp;

// Emisie continua: pachete UDP de difuzare, nu e nevoie de server.
void emite() {
  static uint8_t buf[1000];
  udp.beginPacket(IPAddress(255, 255, 255, 255), 9999);
  udp.write(buf, sizeof(buf));
  udp.endPacket();
}

// Tine starea DURATA_MS, mediaza curentul si il afiseaza o data pe secunda.
float masoara(const char* nume, void (*lucru)() = nullptr) {
  lcd.clear();
  lcd.print(nume);
  double suma = 0;
  uint32_t n = 0;
  unsigned long t0 = millis(), afisat = t0;
  while (millis() - t0 < DURATA_MS) {
    if (lucru) lucru(); else delay(2);
    suma += ina.getCurrent_mA();
    n++;
    if (millis() - afisat >= 1000) {
      afisat = millis();
      lcd.setCursor(0, 1);
      lcd.printf("I=%7.1f mA    ", suma / n);
    }
  }
  return suma / n;
}

// LCD-ul e alimentat inainte de sunt: textul ramane pe ecran cat doarme placa.
void anuntaSomn(const char* nume) {
  lcd.clear();
  lcd.print(nume);
  lcd.setCursor(0, 1);
  lcd.print("cititi multimetr");
  ina.powerSave(true);                 // INA219 coboara la cativa uA
  delay(50);
}

void setup() {
  Wire.begin(SDA_PIN, SCL_PIN);
  lcd.init();
  lcd.backlight();
  if (!ina.begin(&Wire)) {
    lcd.print("INA219 lipsa!");
    while (true) delay(1000);
  }
  ina.setCalibration_32V_1A();         // pas de 0,04 mA, suporta varfurile Wi-Fi

  WiFi.mode(WIFI_OFF);
  masoara("WiFi oprit");

  lcd.clear();
  lcd.print("conectare...");
  WiFi.begin(SSID, PAROLA);
  while (WiFi.status() != WL_CONNECTED) delay(100);
  masoara("WiFi inactiv");
  masoara("WiFi emisie", emite);

  WiFi.mode(WIFI_OFF);
  anuntaSomn("Light-sleep 20 s");
  esp_sleep_enable_timer_wakeup(SOMN_S * uS_PER_S);
  esp_light_sleep_start();             // programul continua de aici
  ina.powerSave(false);

  anuntaSomn("Deep-sleep 20 s");
  esp_deep_sleep_start();              // la trezire, setup() o ia de la capat
}

void loop() {}