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.
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.
The hardware
| Part | Why this one | Approx. £ |
|---|---|---|
| Seeed Studio XIAO ESP32-S3 | Tiny, 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 + HAT | 800 × 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 LiPo | With a protection circuit. Months of updates per charge; check the connector polarity. | 8–14 |
| 1 MΩ × 2 + 100 nF | A high-value divider to read the battery voltage without draining it. | <1 |
| Tactile push button | Wake and redraw on demand, or flip to a second page. | <1 |
| Deep picture frame or a 3D-printed frame | Hides 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.
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.
| Step | What happens | Target |
|---|---|---|
| Wake | Timer or button wakes the S3; state restored from RTC memory | ~0.3 s |
| Connect | Wi-Fi using the saved channel and access point; static IP, no scanning | ~1.5 s |
| Fetch | HTTPS request for the summary JSON; clock synced with SNTP | ~1.2 s |
| Draw | Render the frame; partial refresh, or a full refresh every eighth update | ~3.5 s |
| Sleep | Work 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:
| Item | Assumption | Charge used |
|---|---|---|
| Updates | 52 per weekday, 7 s each at 120 mA average | 12.1 mAh per weekday |
| Clock syncs | Up to 4 a day during long sleeps, 2 s at 100 mA | 0.2 mAh per day |
| Deep sleep | About 22 µA (board plus divider), all day | 0.5 mAh per day |
| Weekly total | Five 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.


