Mercury in Tiefschlaf versetzen < 24uA

Das Altimeter kann in Tiefschlaf versetzt werden und verbraucht dabei fast keine Leistung, während die 3,3V-Versorgung für das Gerät und die Systeme aufrechterhalten wird.
Die Status-LEDs und Sensoren können im Tiefschlaf ebenfalls ausgeschaltet werden.
Aufgrund von Leistungsverlust auf der I2C-Leitung bei Hardware-Revisionen 1–3 sollten diese die Sensoren eingeschaltet lassen, sie aber in den Schlafmodus versetzen, um den effizientesten Tiefschlaf von etwa 24µA zu erreichen.
Hardware-Revision 4+ kann die Sensoren ausschalten und etwa 20µA im Schlaf erreichen.

Alle ungenutzten Pins sollten mit dem Befehl gpio_reset_pin(GPIO_NUM_21); zurückgesetzt und dann alle GPIO-Pins vor dem Tiefschlaf gehalten werden, um den absolut niedrigsten Stromverbrauch zu erreichen.
Bei 24µA Schlafleistung hält der interne 50mAh-Akku etwa 3 Monate im Tiefschlaf.

Dieser Code zeigt auch, wie man die POWER-Taste, die eigentlich eine Reset-Taste ist, als Ein-/Aus-Schalter verwendet. Dies wird erreicht, indem ein Umschalter von 0 oder 1 in die NVS-Einstellungen gespeichert wird. Das bedeutet, dass der Code bei jedem Reset-Zyklus entweder EIN oder AUS geht. 

/*
 * Mercury Tiefschlaf-Umschalter-Beispiel
 * Jeder Reset schaltet zwischen EIN (grünes Strobe) und AUS (Tiefschlaf) um.
 * Sensoren werden via I2C in den Schlaf versetzt, bevor Tiefschlaf aktiviert wird.
 * VACC bleibt HIGH, um zu vermeiden, dass Strom durch I2C Pullup-ESD-Dioden fließt.
 */
#include "Wire.h"
#include "Preferences.h"
#include "Adafruit_NeoPixel.h"
#include "esp_sleep.h"
#include "driver/gpio.h"
#include "WiFi.h"
#include "Mercury_Pins.h"

Adafruit_NeoPixel pixels(4, LED, NEO_GRB + NEO_KHZ800);
Preferences preferences;
unsigned int onoroff = 0;

void led_clear() {
    pixels.setPixelColor(0, 0);
    pixels.setPixelColor(1, 0);
    pixels.setPixelColor(2, 0);
    pixels.setPixelColor(3, 0);
    pixels.show();
}

void i2cWrite(uint8_t addr, uint8_t reg, uint8_t val) {
    Wire.beginTransmission(addr);
    Wire.write(reg);
    Wire.write(val);
    Wire.endTransmission();
}

bool i2cPresent(uint8_t addr) {
    Wire.beginTransmission(addr);
    return (Wire.endTransmission() == 0);
}

void setup() {
    // Sensorversorgung einschalten
    pinMode(VACC, OUTPUT);
    digitalWrite(VACC, HIGH);

    // NeoPixel ein, rotes Blinken zur Bestätigung des Reset
    pinMode(LEDPOWER, OUTPUT);
    digitalWrite(LEDPOWER, HIGH);
    delay(20);
    pixels.begin();
    pixels.setPixelColor(0, pixels.Color(80, 0, 0));
    pixels.setPixelColor(1, pixels.Color(80, 0, 0));
    pixels.setPixelColor(2, pixels.Color(80, 0, 0));
    pixels.setPixelColor(3, pixels.Color(80, 0, 0));
    pixels.show();
    delay(100);
    led_clear();

    // ââ Frühe Ein-/Aus-Entscheidung vor Serial- oder USB-Init ââ
    preferences.begin("example", false);
    delay(2);
    onoroff = preferences.getUInt("onoroff", 0);

    if (onoroff == 0) { onoroff = 1; }
    else { onoroff = 0; }

    preferences.putUInt("onoroff", onoroff);
    delay(10);
    preferences.end();

    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    // SCHLAFPFAD – onoroff ist 0, Sensoren in Schlaf versetzen und Tiefschlaf aktivieren
    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    if (onoroff == 0) {

        pixels.setPixelColor(0, pixels.Color(80, 0, 0));
        pixels.setPixelColor(1, pixels.Color(80, 0, 0));
        pixels.setPixelColor(2, pixels.Color(80, 0, 0));
        pixels.setPixelColor(3, pixels.Color(80, 0, 0));
        pixels.show();
        delay(1200);
        led_clear();
        delay(5);

        // ââ Sensoren via I2C in den Schlaf versetzen ââ
        // VACC bleibt HIGH – wenn wir die Sensorversorgung abschalten würden,
        // würden die I2C Pullups (verbunden mit 3V3) Strom durch den Sensor
        // ESD-Schutzdioden verlieren. Stattdessen senden wir Schlafbefehle.
        Wire.begin(SDA, SCL);
        delay(10);

        // BMP581 (rev 3+ bei 0x47): schreibe 0x00 in ODR-Register = Standby ~1,3µA
        if (i2cPresent(0x47)) i2cWrite(0x47, 0x37, 0x00);

        // BMP390 (rev 0-2 bei 0x77): schreibe 0x00 in PWR_CTRL = Schlaf ~3,4µA
        if (i2cPresent(0x77)) i2cWrite(0x77, 0x1B, 0x00);

        // LSM6DSO32 (alle Revisionen bei 0x6B): Beschleunigung + Gyroskop ausschalten ~3µA
        if (i2cPresent(0x6B)) {
            i2cWrite(0x6B, 0x10, 0x00);  // CTRL1_XL = Beschleunigung aus
            i2cWrite(0x6B, 0x11, 0x00);  // CTRL2_G  = Gyroskop aus
        }

        Wire.end();

        // ââ NeoPixel ausschalten ââ
        digitalWrite(LEDPOWER, LOW);
        pinMode(LED, OUTPUT);
        digitalWrite(LED, LOW);

        // ââ Ausgang ausschalten ââ
        pinMode(OUT1, OUTPUT);
        digitalWrite(OUT1, LOW);

        // ââ Pins während Tiefschlaf halten ââ
        // gpio_hold_en teilt dem RTC mit, dass der aktuelle Level
        // aufrechterhalten werden soll, während der Haupt-GPIO-Controller
        // ausgeschaltet ist. Ohne dies können Pins schweben und Sensoren
        // könnten zusätzlichen Strom verbrauchen.
        gpio_hold_en((gpio_num_t)VACC);       // Gehalten HIGH – Sensoren im Schlaf mit Strom versorgt
        gpio_hold_en((gpio_num_t)LEDPOWER);   // Gehalten LOW
        gpio_hold_en((gpio_num_t)LED);        // Gehalten LOW
        gpio_hold_en((gpio_num_t)OUT1);       // Gehalten LOW

        esp_deep_sleep_start();
    }

    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    // EIN-PFAD – Haltungen freigeben und ausführen
    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    gpio_hold_dis((gpio_num_t)VACC);
    gpio_hold_dis((gpio_num_t)LEDPOWER);
    gpio_hold_dis((gpio_num_t)LED);
    gpio_hold_dis((gpio_num_t)OUT1);

    // Versorgung wiederherstellen (könnte vom Schlaf gehalten worden sein)
    digitalWrite(VACC, HIGH);
    digitalWrite(LEDPOWER, HIGH);
}

void loop() {
    // Grün/Blau blinken wenn eingeschaltet
    for (int i = 0; i < 4; i++) {
        pixels.setPixelColor(i, pixels.Color(0, 80, 0));
    }
    pixels.show();
    delay(200);
    for (int i = 0; i < 4; i++) {
        pixels.setPixelColor(i, pixels.Color(0, 0, 80));
    }
    pixels.show();
    delay(200);
}

#pragma once
/*
 * Mercury (ESP32-C6) Pin-Definitionen
 * Board-spezifische GPIO-Zuweisungen
 */

// ââ Status-LED (NeoPixel) ââ
#define LEDPOWER      3    // NeoPixel-Versorgung (HIGH fahren zum Aktivieren)
#define LED           2    // NeoPixel-Datensignal

// ââ I2C-Bus ââ
#define SDA           21   // I2C-Daten
#define SCL           22   // I2C-Takt

// ââ Sensorversorgung ââ
#define VACC          20   // Sensorversorgungsleitung (HIGH fahren zum Aktivieren)

// ââ Universelle Anschlüsse ââ
#define GP06          6    // GP06-Anschluss
#define GP07          7    // GP07-Anschluss

// ââ Hochstrom-Ausgang ââ
#define OUT1          5    // Hochstrom-Ausgang (z.B. Pyro / Relais)

// ââ Batterie-Balken-LEDs ââ
#define BL1           4    // Batterie-LED 1 (niedrigste)
#define BL2           14   // Batterie-LED 2
#define BL3           15   // Batterie-LED 3
#define BL4           18   // Batterie-LED 4
#define BL5           19   // Batterie-LED 5 (höchste)

// ââ Indikatoren ââ
#define DISK          8    // Disk-Aktivitäts-LED

// ââ Analog / Erkennung ââ
#define BATIN         0    // Batteriespannung (1:1-Teiler)
#define USBDETECT     1    // USB-Stromerkennung (HIGH = USB vorhanden)
#define BUTTON        9    // BUTTON auf dem Board, Boot-Button aber verwendbar