De Mercury in diepe slaap zetten < 24µA

Het altimeter kan in diepe slaapstand worden gezet en verbruikt bijna geen vermogen terwijl de 3.3V voeding naar het apparaat en systemen wordt gehandhaafd.
De status-LED's en sensoren kunnen ook in diepe slaapstand worden uitgeschakeld.
Door vermogenslekking op de I2C-lijn op hardwareversies 1 - 3 moeten deze de sensoren aan laten maar hun opdracht geven om in slaap te gaan voor de meest efficiënte diepe slaap van ongeveer 24µA.
Hardwareversie 4+ kan de sensoren uitschakelen en ongeveer 20µA in slaap bereiken.

Alle ongebruikte pinnen moeten worden gereset met de opdracht gpio_reset_pin(GPIO_NUM_21); en vervolgens moeten alle GPIO-pinnen vastgehouden worden voordat u in diepe slaap gaat om het absolute laagste vermogenverbruik te bereiken.
Bij 24µA slaapvermogen gaat de interne 50mAh ongeveer 3 maanden mee in diepe slaap. 

Deze code demonstreert ook hoe u de POWER-knop, die eigenlijk een resetknop is, als aan/uit-knop kunt gebruiken. Dit wordt bereikt door een toggle van 0 of 1 in de NVS-voorkeuren op te slaan. Dit betekent dat de code bij elke resetcyclus ofwel AAN ofwel UIT gaat. 

/*
 * Mercury Deep Sleep Toggle Example
 * Each reset toggles between ON (green strobe) and OFF (deep sleep).
 * Sensors are put to sleep via I2C before entering deep sleep.
 * VACC stays HIGH to avoid current leaking through I2C pullup ESD diodes.
 */
#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() {
    // Turn on sensor power
    pinMode(VACC, OUTPUT);
    digitalWrite(VACC, HIGH);

    // NeoPixel on, red flash to confirm 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();

    // ââ Early on/off decision before Serial or 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();

    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    // SLEEP PATH — onoroff is 0, put sensors to sleep and enter deep sleep
    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    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);

        // ââ Put sensors to sleep via I2C ââ
        // VACC stays HIGH — if we cut sensor power the I2C pullups
        // (connected to 3V3) would leak current through the sensor
        // ESD protection diodes. Instead we send sleep commands.
        Wire.begin(SDA, SCL);
        delay(10);

        // BMP581 (rev 3+ at 0x47): write 0x00 to ODR register = standby ~1.3uA
        if (i2cPresent(0x47)) i2cWrite(0x47, 0x37, 0x00);

        // BMP390 (rev 0-2 at 0x77): write 0x00 to PWR_CTRL = sleep ~3.4uA
        if (i2cPresent(0x77)) i2cWrite(0x77, 0x1B, 0x00);

        // LSM6DSO32 (all revisions at 0x6B): power down accel + gyro ~3uA
        if (i2cPresent(0x6B)) {
            i2cWrite(0x6B, 0x10, 0x00);  // CTRL1_XL = accel off
            i2cWrite(0x6B, 0x11, 0x00);  // CTRL2_G  = gyro off
        }

        Wire.end();

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

        // ââ Turn off output ââ
        pinMode(OUT1, OUTPUT);
        digitalWrite(OUT1, LOW);

        // ââ Hold pins during deep sleep ââ
        // gpio_hold_en tells the RTC to maintain each pin's current
        // level while the main GPIO controller is powered down.
        // Without this, pins float and sensors could draw extra current.
        gpio_hold_en((gpio_num_t)VACC);       // Held HIGH — sensors powered in sleep
        gpio_hold_en((gpio_num_t)LEDPOWER);   // Held LOW
        gpio_hold_en((gpio_num_t)LED);        // Held LOW
        gpio_hold_en((gpio_num_t)OUT1);       // Held LOW

        esp_deep_sleep_start();
    }

    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    // ON PATH — release holds and run
    // ââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
    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);

    // Restore power (may have been held from sleep)
    digitalWrite(VACC, HIGH);
    digitalWrite(LEDPOWER, HIGH);
}

void loop() {
    // Flash green/blue when in on state
    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 Definitions
 * Board-specific GPIO assignments
 */

// ââ Status LED (NeoPixel) ââ
#define LEDPOWER      3    // NeoPixel power (drive HIGH to enable)
#define LED           2    // NeoPixel data signal

// ââ I2C Bus ââ
#define SDA           21   // I2C data
#define SCL           22   // I2C clock

// ââ Sensor Power ââ
#define VACC          20   // Sensor power rail (drive HIGH to enable)

// ââ General Purpose Ports ââ
#define GP06          6    // GP06 port
#define GP07          7    // GP07 port

// ââ High Current Output ââ
#define OUT1          5    // High current output (e.g. pyro / relay)

// ââ Battery Bar LEDs ââ
#define BL1           4    // Battery LED 1 (lowest)
#define BL2           14   // Battery LED 2
#define BL3           15   // Battery LED 3
#define BL4           18   // Battery LED 4
#define BL5           19   // Battery LED 5 (highest)

// ââ Indicators ââ
#define DISK          8    // Disk activity LED

// ââ Analogue / Detection ââ
#define BATIN         0    // Battery voltage (1:1 divider)
#define USBDETECT     1    // USB power detect (HIGH = USB present)
#define BUTTON        9    // BUTTON on the board, boot button but can be used