Reading Time: 2 minutes

My private investment dashboard lives in a browser tab, which means I only see it when I go looking. This project puts a glanceable version on a shelf instead: a 7.5-inch e-paper screen in a picture frame showing a watchlist, the day's moves and a small chart for each line. E-paper only uses power when the picture changes, so with an ESP32 that spends almost all its time asleep, it should run for months on a single charge.

Where the project is today: design stage. This post sets out the full design, including a power budget that will be checked against real measurements. Nothing has been built and tested yet, and the code is a design sketch. It is a display for information I already follow: not a trading tool, and nothing on it is investment advice.

800×480e-paper pixels, readable in daylight
15 minupdates during market hours
~20 µAtarget deep-sleep current
~24weeks per charge, on paper
MARKETSFRI 21 NOVACME412.60▲ +1.84%BRIX88.15▼ −0.62%CRWN1,204.0▲ +0.31%DLTA56.72▼ −2.15%EMBR23.48▲ +4.02%82%Updated 14:30 · next 14:45 · sample dataUpdated 14:45 · next 15:00 · sample datazzZDeep sleep · about 20 µAWake · Wi-Fi · fetch the summaryFull refresh: the panel flashes to clear ghostingDone · the new image costs zero power to hold · back to sleep
Asleep most of the time, then a quick wake and a full refresh (animated illustration with sample data).

Why e-paper and deep sleep

An LCD needs power every moment it shows an image. E-paper is bistable: the tiny charged particles that form the picture stay put when the power is removed, so a static image costs nothing at all. Updating it takes a few seconds and a burst of power, and then the display can be ignored until the next change.

That suits market data well. Prices change constantly during the trading day, but a glance every fifteen minutes is plenty for a shelf display, and nothing needs to change overnight or at weekends. The ESP32 wakes, connects to Wi-Fi, fetches fresh numbers, redraws and goes back into deep sleep, where it draws microamps.

120 mA00 min5 min10 min15 min20 min25 min30 mindeep sleep ≈ 20 µA for ~893 s (99.2% of the time)wake ≈ 120 mA for ~7 sInside one 7-second wake (estimate)Boot 0.3 sWi-Fi connect 1.5 sHTTPS fetch 1.2 sE-paper refresh 3.5 sSleep prep 0.5 s
Two update cycles: tall, brief wakes and long, near-zero sleeps (estimate; sleep current exaggerated so it is visible).

The hardware

PartWhy this oneApprox. £
Seeed Studio XIAO ESP32-S3Tiny, with built-in LiPo charging and a low deep-sleep current. Measure your own: board-level sleep current varies.7–12
Waveshare 7.5" e-Paper + HAT800 × 480 black and white panel with its SPI driver board. Big enough to read across a room, and supported by the GxEPD2 library.40–60
2000–3000 mAh LiPoWith a protection circuit. Months of updates per charge; check the connector polarity.8–14
1 MΩ × 2 + 100 nFA high-value divider to read the battery voltage without draining it.<1
Tactile push buttonWake and redraw on demand, or flip to a second page.<1
Deep picture frame or a 3D-printed frameHides the electronics behind the panel.5–15

That is roughly £60 to £105 in total.

Reading the battery without wasting it

The ESP32's analogue input can only measure up to about 3 V, but a full LiPo sits at 4.2 V, so the battery is measured through a divider that halves it. Ordinary 10 kΩ resistors would quietly drain around 200 µA, ten times the whole sleep budget. A pair of 1 MΩ resistors cuts that to about 2 µA, and a 100 nF capacitor across the lower resistor gives the ADC a stiff enough source to sample accurately.

Wiring

Pin names are the XIAO's printed labels, and the assignment is a proposal to check against Seeed's pinout. Newer revisions of the e-paper HAT add a PWR pin; if yours has one, connect it to 3V3, or to a spare GPIO so the panel can be switched off completely.

Seeed XIAO ESP32-S33V3GNDBAT+ (pads underneath)D8 · SCKD10 · MOSID1 · CSD3 · DCD0 · RSTD2 · BUSYD9 · battery senseD5 · button (wake)e-Paper driver HATVCCGNDCLKDINCSDCRSTBUSYLiPo battery+ (red)− (black)Battery dividertop: 1 MΩ to BAT+middle → D9 (+100 nF)bottom: 1 MΩ to GNDPush buttonleg 1leg 2 → GNDProposed assignment using the XIAO's labels: verify against Seeed's pinout before soldering.
Proposed wiring for the e-paper dashboard.

Where the numbers come from

The frame does not talk to a market-data provider directly. Instead it asks a tiny JSON endpoint on a home server (it can sit alongside the investment dashboard) for a pre-digested summary: symbols, last prices, daily change and a handful of intraday points for each sparkline. That design has three advantages:

  • Market-data API keys never live on a device sitting on a shelf.
  • The ESP32 downloads a few hundred bytes instead of parsing bulky provider responses, which keeps every wake short.
  • Changing data provider, or adding a holding, needs no firmware update.

The request still uses HTTPS with certificate checking, and the endpoint only answers on the home network.

{
  "asof": "2026-11-21T14:45:00Z",
  "items": [
    { "sym": "ACME", "last": 412.60, "chg_pct": 1.84,  "spark": [404, 406, 405, 409, 411, 412.6] },
    { "sym": "BRIX", "last": 88.15,  "chg_pct": -0.62, "spark": [88.9, 88.7, 88.4, 88.5, 88.2, 88.15] }
  ]
}

Software design

The firmware is a straight line rather than a loop, because every wake is a fresh boot from deep sleep: wake, connect, fetch, draw, schedule the next wake, sleep. It uses the Arduino core for ESP32, GxEPD2 for the panel, U8g2_for_Adafruit_GFX for clean proportional fonts, ArduinoJson for parsing and Preferences for the Wi-Fi details. A few kilobytes of RTC memory, which survives deep sleep, hold the day's sparkline points and the Wi-Fi channel for a faster reconnect.

StepWhat happensTarget
WakeTimer or button wakes the S3; state restored from RTC memory~0.3 s
ConnectWi-Fi using the saved channel and access point; static IP, no scanning~1.5 s
FetchHTTPS request for the summary JSON; clock synced with SNTP~1.2 s
DrawRender the frame; partial refresh, or a full refresh every eighth update~3.5 s
SleepWork out the next wake time, switch off the panel and Wi-Fi, deep sleep~0.5 s

Only wake when it matters

Markets keep office hours, so the schedule does too. The London Stock Exchange trades from 08:00 to 16:30 UK time, and the main US exchanges from 09:30 to 16:00 New York time, which is 14:30 to 21:00 in the UK for most of the year (an hour earlier for a few weeks each spring and autumn, when the two countries change their clocks on different dates). Waking every 15 minutes from 08:00 to 21:00 on weekdays covers both, and everything else is sleep:

// Design sketch - NOT TESTED ON HARDWARE.
// Seconds to sleep before the next wake. Local time is Europe/London
// (TZ "GMT0BST,M3.5.0/1,M10.5.0"), re-synced over the network on every wake.
uint32_t secondsUntilNextWake(const tm &now) {
    constexpr int OPEN_MIN  = 8 * 60;              // 08:00, London open
    constexpr int CLOSE_MIN = 21 * 60;             // 21:00, after the US close (UK time)
    constexpr int STEP_MIN  = 15;
    constexpr uint32_t MAX_SLEEP_S = 6 * 3600;     // long sleeps end with a clock sync

    const bool weekday = now.tm_wday >= 1 && now.tm_wday <= 5;
    const int  minute  = now.tm_hour * 60 + now.tm_min;
    uint32_t secs;

    if (weekday && minute >= OPEN_MIN && minute < CLOSE_MIN) {
        const int next = (minute / STEP_MIN + 1) * STEP_MIN;      // next quarter hour
        secs = (next - minute) * 60 - now.tm_sec;
    } else {                                                      // 08:00 next weekday
        int days = (weekday && minute < OPEN_MIN) ? 0 : 1;
        int wday = (now.tm_wday + days) % 7;
        while (wday == 0 || wday == 6) { ++days; wday = (wday + 1) % 7; }
        secs = days * 86400 + (OPEN_MIN - minute) * 60 - now.tm_sec;
    }
    return secs < MAX_SLEEP_S ? secs : MAX_SLEEP_S;
}

The ESP32's sleep timer runs from an internal oscillator that can drift by minutes over a long weekend, so long sleeps are split into six-hour chunks, each ending with a quick clock sync before going back to sleep. Clock changes are handled the same way. Bank holidays are not modelled: on those days the frame simply shows a quiet market.

Drawing for e-paper

E-paper has its own rules. A full refresh flashes the panel black and white several times to clear every pixel, which looks dramatic and takes a few seconds. A partial refresh only touches what changed, but slowly leaves faint ghosts of old images. Where the panel supports it, routine updates are partial, with a full refresh at the first update of the day and every eighth update after that. The layout is designed for pure black and white: bold type for the numbers that matter, thin rules, and arrows rather than red and green to show direction.

Power budget

On paper, using cautious figures that will be replaced by measurements:

ItemAssumptionCharge used
Updates52 per weekday, 7 s each at 120 mA average12.1 mAh per weekday
Clock syncsUp to 4 a day during long sleeps, 2 s at 100 mA0.2 mAh per day
Deep sleepAbout 22 µA (board plus divider), all day0.5 mAh per day
Weekly totalFive weekdays plus a quiet weekend~65 mAh per week

A 2000 mAh cell, keeping 20% in reserve, would last around 24 weeks: about five and a half months between charges. The two numbers that matter most, deep-sleep current and the length of each wake, are exactly what the first prototype will measure, with a USB power meter for the active phase and a microamp-capable meter for sleep.

Testing plan

  • Schedule: unit-test the wake calculation on a PC across weekends, both clock changes, midnight and New Year.
  • Failures: Wi-Fi down, server down, malformed JSON and slow responses. The screen keeps the last good data and adds a clear "stale since 14:45" line instead of going blank.
  • Power: sleep current with and without the panel connected, and the energy of a full refresh compared with a partial one.
  • Display: a week of partial refreshes to judge ghosting before fixing the full-refresh interval.
  • Battery: a low-battery screen at 10%, and a clean final message before the protection circuit cuts out.

What's next

Step one is measuring the XIAO's real deep-sleep current with the panel attached, because the whole design depends on it. Then the server endpoint, then the layout. A second page, flipped with the button, could show portfolio allocation as a simple bar chart.

For more on keeping data honest on a small screen, see my ESP32-S3 vehicle computer design.

← All articles

Related articles