Build Your Own Ultra-Low-Power E-Ink Dashboard

In this guide (for video tutorial scroll down to the end), I show how to put together a custom e-ink dashboard called TRMNL (Pronounced as "Terminal"), a calm, minimalist gadget that brings only the information you actually care about to your desk or wall. Weather, stock prices, news headlines, or anything else you choose. No distractions, no noise. TRMNL is based on an ESP32 and a Waveshare e-paper display. Let’s walk through the hardware, firmware, enclosure, and power design step by step.

How Does TRMNL Work?

TRMNL is a cloud-connected e-ink dashboard designed for low power consumption. Instead of running apps locally, the device simply downloads and displays bitmap pages generated on a server. That keeps the firmware lean, power consumption low, and configuration extremely flexible. Think of it as a “read-only browser” for carefully curated information.

Core Components

For this build, the main components are:

• 7.5" Waveshare Black/Whitee-paper display
• Waveshare Universal E-Paper Driver Board (ESP32-based)
• Custom 3D-printed or hand-crafted enclosure
• Push Button and 10k resistor

If the device should run from a battery:

• Lithium-ion battery
• USB 5V 1A 18650 Lithium-Battery Charger Module

The display connects to the driver board using a flat-flex (FPC) cable, which makes he setup easy.

GPIO 33 of the module must be connected to a push button, that pulls 3.3 Volt to ground, like shown in the pictures below:

The button is used to switch between screens, reset the device, or trigger user-defined functions.

Build And Flash The Firmware

To build and flash the firmware, you’ll need:

• Visual Studio Code with PlatformIO extension
• Git command-line tools

Step 1: Cloning the Firmware

Clone the Terminal firmware repository and check out a stable release (v1.7.1 in this case):

git clone https://github.com/usetrmnl/trmnl-firmware
cd trmnl-firmware
git checkout tags/v1.7.1

This ensures a known-good firmware version. ZIP downloads also work if you prefer not to use Git.

Once opened in VS Code, PlatformIO automatically detects the project and installs the required toolchains and libraries. This step can take a while—let it finish uninterrupted.

Step 2: Configure The Project in PlatformIO

• Open PlatformIO Home
• Go to Projects
• Select your Terminal project
• Choose the Waveshare ESP32 driver as the default environment
• Save the configuration
• Compile and flash the firmware on the module

Wi-Fi and Device Registration

On first boot, the ESP32 creates a temporary Wi-Fi access point with the SSID "TRMNL". Connect to it and enter your network credentials via the captive portal.

If the portal doesn’t open automatically, navigate to:

http://4.3.2.1

Device Registration

Once connected, you’ll see a registration screen. Terminal BYOD devices require a license, which you can order online here: https://usetrmnl.com/go/docvolt10 Enter your order number (which you will receive by email) and a nickname or email address into the registration form to obtain your Friendly ID—a six-character registration code.

Use this Friendly-ID to link the device to your account.

Device Configuration

Once the device is registered, configuration is handled entirely through the Terminal dashboard. Here you can assign a human-readable device name and select the appropriate device model. Since Terminal supports a wide range of e-paper hardware, including repurposed e-book readers, the model selection is important. For this build, the Terminal OG 2-bit profile is a good match, as it enables black and white output along with two additional gray levels.

The dashboard also lets you define what happens when the physical button is pressed, including short and long press behavior. This can be used to cycle through pages, trigger refreshes, or perform resets, depending on your preferences and workflow.

Power-related settings are grouped under sleep and refresh options. Sleep mode allows the display to pause updates for a defined period, optionally showing a dedicated sleep screen. Refresh intervals determine how often new content is fetched and rendered, which has a direct and significant impact on battery life. Longer intervals dramatically reduce power consumption, making them especially important for battery-powered installations.

You can also choose between pure black-and-white rendering and grayscale output, depending on your display capabilities and visual preferences. Additional options include display mirroring, which allows multiple devices to stay in sync, and developer-specific settings such as registering the device’s MAC address for advanced features. Among all these parameters, refresh timing remains the most critical lever for balancing usability against power efficiency, so it’s worth spending some time fine-tuning it.

Plugins: Where the Magic Happens

Terminal supports 700+ plugins, covering everything from weather and calendars to finance. Plugins are essentially static bitmaps generated server-side. They don’t run on the ESP32, which keeps the firmware simple and power usage minimal. Terminal distinguishes between native plugins and recipes, even though both appear side by side in the plugin list and are configured in exactly the same way.

Native plugins are developed and maintained by the TRMNL core team and are considered part of the official platform. They typically cover common, broadly useful functions such as weather forecasts, calendars, system status information, or integrations with well-known services. Because they are maintained centrally, native plugins are tested against current firmware and backend changes, updated automatically as the platform evolves, and designed with stability and backward compatibility in mind.

Recipes, by contrast, are created and published by members of the Terminal community. Technically, they use the same rendering pipeline and technologies as native plugins, but responsibility for their maintenance lies entirely with the individual author. This makes recipes ideal for niche, experimental, or highly personalized use cases that would not necessarily belong in the official plugin set.

From the user’s perspective, recipes behave just like native plugins. They can be added from the plugin list, configured through the same interface, and placed into playlists alongside any other plugin. The important difference is how updates are handled. When a recipe author makes changes, those updates are automatically propagated to everyone using that recipe, which can be beneficial when bugs are fixed or features are improved, but can also introduce unexpected changes.

To address this, Terminal allows users to fork a recipe. Forking creates an independent copy that is no longer affected by upstream updates, giving you full control over future modifications. This is especially useful if a recipe becomes a critical part of your dashboard or if you want to customize it without the risk of it changing underneath you.

Power Supply and Battery

Power supply is one of the more subtle aspects of this build, if you intend to run the device from a lithium-ion battery. The ESP32 driver board accepts supply voltages between roughly 3.6 and 5 volts on its 5 V input pin, which makes it possible to connect it directly to a standard lithium‑ion battery without any additional regulation. A lithium‑ion battery charger module is used to protect the cell from overcharging and deep discharge.

Because the ESP32 driver module requires the supply voltage to remain above 3.6 volts, only around 80 percent of a typical single‑cell Li‑ion battery's charge can be accessed. The remaining capacity sits below the minimum operating voltage and is effectively unusable without additional power conversion.

Another challenge comes from the ESP32 itself. During Wi‑Fi activity, the module draws short but significant current spikes that can reach up to roughly 500 milliamps. As the battery discharges and its internal resistance increases, these spikes can momentarily pull the supply voltage low enough to trigger a reset. The result is an intermittent or even permanent reboot loop that becomes more likely as the battery voltage drops.

A simple and effective mitigation is to add additional bulk capacitance close to the ESP32. A capacitor on the order of 1000 microfarads between the 3.3‑volt pin and ground helps buffer these current spikes and stabilizes the supply voltage during radio transmissions. In addition, the ESP32 includes an internal brownout detector that forces a reset when the supply voltage falls below a defined threshold. Disabling this detector in firmware can further extend the usable voltage range, though it should be done with care and only after verifying stable operation.

It is tempting to solve the voltage range issue with a boost converter in order to extract the full battery capacity, but in practice this often provides little real benefit. Typical boost converters operate at efficiencies around 80 percent, draw their own standby current, and add another potential point of failure. In this build, the added complexity and losses outweighed the gains, so the design deliberately avoids voltage boosting in favor of simplicity.

Assembly

Finally, a sleek enclosure was designed in FreeCAD and 3D-printed in white PETG.

The enclosure consists of three parts: the shell, which holds the e-paper display, a back cover, and a bottom plate that holds the electronics.

The ESP32 driver board and its external components are soldered onto a perfboard, which is mounted on four standoffs on the bottom plate using screws. The battery and the USB charger module are also fixed to the bottom plate and secured in place with hot glue.

Video

Watch the video to see in detail