ESP32 E-Ink Environmental Monitor (Low Power + Safe Design)¶

// config.h
#pragma once

// Pins — E-Ink
#define EINK_SCK   18
#define EINK_MOSI  23
#define EINK_CS     5
#define EINK_DC    17
#define EINK_RST   16
#define EINK_BUSY   4

// Pins — I2C
#define I2C_SDA    21
#define I2C_SCL    22

// Sleep
#define SLEEP_SECONDS 300UL   // 5 minutes

// Battery ADC (voltage divider: 100k/100k, GPIO35 = ADC1_7)
#define BAT_ADC_PIN 35
#define BAT_LOW_V   3.2f      // enter hibernation below this voltage

// sensors.h
#pragma once
struct Readings {
    float tempC;
    float humidity;
    float pressurePa;
    uint32_t lux;
    bool valid;
};

Readings readSensors();

// sensors.cpp
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <BH1750.h>
#include "sensors.h"

static Adafruit_BME280 bme;
static BH1750 lightMeter;

// Simple exponential moving average for smoothing
static float ema(float prev, float next, float alpha = 0.3f) {
    return (prev == 0.0f) ? next : alpha * next + (1 - alpha) * prev;
}

// RTC-persisted smoothed values survive deep sleep
RTC_DATA_ATTR float smoothTemp  = 0.0f;
RTC_DATA_ATTR float smoothHum   = 0.0f;
RTC_DATA_ATTR float smoothPa    = 0.0f;

Readings readSensors() {
    Wire.begin(I2C_SDA, I2C_SCL, 400000);

    Readings r{};
    if (!bme.begin(0x76)) {
        Serial.println("[SENSOR] BME280 not found");
        r.valid = false;
        return r;
    }
    if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE)) {
        Serial.println("[SENSOR] BH1750 not found");
    }

    r.tempC     = bme.readTemperature();
    r.humidity  = bme.readHumidity();
    r.pressurePa = bme.readPressure();
    r.lux       = lightMeter.readLightLevel();

    // Smooth — persist across deep sleep cycles
    smoothTemp = ema(smoothTemp, r.tempC);
    smoothHum  = ema(smoothHum, r.humidity);
    smoothPa   = ema(smoothPa, r.pressurePa);

    r.tempC      = smoothTemp;
    r.humidity   = smoothHum;
    r.pressurePa = smoothPa;
    r.valid      = true;
    return r;
}

// display.h
#pragma once
#include "sensors.h"
void renderDisplay(const Readings& r, float battV, uint32_t bootCount);

// display.cpp
#include <GxEPD2_BW.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <Fonts/FreeSans9pt7b.h>
#include "display.h"
#include "config.h"

// Adjust for your exact panel model
GxEPD2_BW<GxEPD2_154_D67, GxEPD2_154_D67::HEIGHT> display(
    GxEPD2_154_D67(EINK_CS, EINK_DC, EINK_RST, EINK_BUSY));

RTC_DATA_ATTR uint8_t partialCount = 0;

void renderDisplay(const Readings& r, float battV, uint32_t bootCount) {
    display.init(115200, true, 2, false);
    display.setRotation(1);
    display.setTextColor(GxEPD_BLACK);

    // Full refresh every 10 cycles to clear ghosting
    bool fullRefresh = (partialCount == 0);
    if (fullRefresh) {
        partialCount = 10;
        display.setFullWindow();
    } else {
        partialCount--;
        display.setPartialWindow(0, 0, display.width(), display.height());
    }

    display.firstPage();
    do {
        display.fillScreen(GxEPD_WHITE);

        // Title bar
        display.setFont(&FreeSansBold12pt7b);
        display.setCursor(4, 22);
        display.print("Environment");

        // Sensor values
        display.setFont(&FreeSans9pt7b);
        display.setCursor(4, 50);
        display.printf("Temp:  %.1f C", r.tempC);
        display.setCursor(4, 72);
        display.printf("Hum:   %.1f %%", r.humidity);
        display.setCursor(4, 94);
        display.printf("Press: %.0f hPa", r.pressurePa / 100.0f);
        display.setCursor(4, 116);
        display.printf("Light: %u lux", r.lux);

        // Footer: battery + boot count
        display.setFont(nullptr);
        display.setCursor(4, 190);
        display.printf("BAT %.2fV  #%lu", battV, bootCount);
    } while (display.nextPage());

    display.hibernate();  // mandatory — powers down driver
}

// power.cpp
#include <Arduino.h>
#include <esp_sleep.h>
#include "config.h"

RTC_DATA_ATTR uint32_t bootCount = 0;

void enterDeepSleep() {
    // Ensure all SPI peripherals are idle before sleep
    SPI.end();
    // Release GPIO drive to reduce leakage
    gpio_deep_sleep_hold_dis();

    esp_sleep_enable_timer_wakeup(SLEEP_SECONDS * 1000000ULL);
    Serial.printf("[PWR] Entering deep sleep for %lus\n", SLEEP_SECONDS);
    Serial.flush();
    esp_deep_sleep_start();
}

float readBatteryVoltage() {
    // Voltage divider: BAT+ → 100k → GPIO35 → 100k → GND
    // Full-scale: 4.2V battery → 2.1V at GPIO35 → ADC reads ~2610 (12-bit, 3.3V ref)
    int raw = analogRead(BAT_ADC_PIN);
    return (raw / 4095.0f) * 3.3f * 2.0f;
}

bool batteryLow(float v) { return v < BAT_LOW_V; }

// main.cpp
#include <Arduino.h>
#include "config.h"
#include "sensors.h"
#include "display.h"
#include "power.cpp"  // inline for brevity; split in real project

extern RTC_DATA_ATTR uint32_t bootCount;

void setup() {
    Serial.begin(115200);
    bootCount++;

    float battV = readBatteryVoltage();
    Serial.printf("[MAIN] Boot #%lu  Bat=%.2fV\n", bootCount, battV);

    if (batteryLow(battV)) {
        Serial.println("[MAIN] Battery low — hibernating");
        esp_deep_sleep_start();  // no timer — wake only on power restore
    }

    Readings r = readSensors();
    if (!r.valid) {
        // Sensor failure: display error state, sleep, retry next cycle
        Serial.println("[MAIN] Sensor read failed");
    }

    renderDisplay(r, battV, bootCount);
    enterDeepSleep();
}

void loop() {}  // never reached — deep sleep re-runs setup()