Waveshare E-Paper + ESP32: Build a Low-Power Display Project

Waveshare E-Paper displays paired with an ESP32 create one of the best low-power display combinations for battery-operated IoT projects. E-Paper screens retain their image with zero power draw, and the ESP32’s deep sleep mode drops current consumption to microamps between updates. In this tutorial, we will build a battery-powered weather dashboard that fetches live weather data over Wi-Fi and displays it on a Waveshare 2.9-inch E-Paper module, running for months on a single 18650 battery cell.

Table of Contents

• Why E-Paper and ESP32 Are Perfect Together
• Components You Will Need
• Wiring the E-Paper Display to ESP32
• Arduino IDE Setup for ESP32
• Code Walkthrough: Weather Dashboard
• Power Optimization and Battery Life Calculations
• Weather APIs for Indian Cities
• Frequently Asked Questions
• Conclusion

Why E-Paper and ESP32 Are Perfect Together

E-Paper (also called E-Ink) displays work on a fundamentally different principle from LCDs and OLEDs. Instead of backlighting pixels, E-Paper uses tiny charged particles suspended in microcapsules. When a voltage is applied, the particles rearrange to form an image. Once the image is set, no power is needed to maintain it. The screen looks like printed paper and is readable in direct sunlight without any backlight.

The ESP32 complements this perfectly. Espressif’s ESP32 chip includes built-in Wi-Fi and Bluetooth, runs at up to 240 MHz for processing, and critically supports deep sleep modes that reduce power draw to as low as 10 microamps. The typical workflow is: wake up, connect to Wi-Fi, fetch data, update the E-Paper display, then go back to sleep. This cycle takes about 5-10 seconds and consumes roughly 150-200 mA during the active phase. The rest of the time, the device essentially draws nothing.

This combination is ideal for applications where you need a display that updates periodically: weather stations, calendar displays, cryptocurrency tickers, bus arrival boards, inventory trackers, and environmental monitors. The E-Paper screen remains perfectly readable between updates, consuming zero power, while the ESP32 handles all the connectivity and processing during brief wake cycles.

Components You Will Need

Here is the complete parts list for this project. All components are available from Zbotic.in.

• Waveshare 2.9-inch E-Paper Module (V2) — 296×128 resolution, black and white, SPI interface. The V2 revision supports partial refresh, which is faster and extends display life. (Approximate price: ₹950-1,200)
• ESP32 development board — Any ESP32 DevKit will work. The Waveshare ESP32-S3-Nano is a compact option that fits nicely in small enclosures. (Approximate price: ₹700-900)
• 18650 lithium battery — 3.7V, 2600-3400 mAh. A single cell provides months of operation. (Approximate price: ₹200-400)
• TP4056 charging module — USB-C charging board with battery protection. (Approximate price: ₹50-80)
• Jumper wires — Female-to-female for connecting the E-Paper to the ESP32. 8 wires needed. (Approximate price: ₹30-50)
• Breadboard — For prototyping before soldering. (Approximate price: ₹60-100)
• 3D printed or laser-cut enclosure — Optional, for a finished look.

Wiring the E-Paper Display to ESP32

The Waveshare 2.9-inch E-Paper module communicates over SPI (Serial Peripheral Interface). It has 8 pins that need to be connected to your ESP32. Here is the pin mapping:

Important wiring notes:

• The E-Paper module runs on 3.3V. Never connect VCC to the 5V pin or you will damage the display controller.
• Keep SPI wires short (under 20cm) to avoid signal integrity issues. Longer wires can cause display corruption.
• The BUSY pin is an output from the display that tells the ESP32 when a refresh operation is complete. Your code should poll this pin before sending new data.
• If using the ESP32-S3-Nano, the default SPI pins differ. Use GPIO 11 (MOSI), GPIO 12 (CLK), and adjust CS/DC/RST/BUSY accordingly. Check the Waveshare wiki for ESP32-S3 specific pin maps.

Arduino IDE Setup for ESP32

Before writing code, you need to configure Arduino IDE for ESP32 development and install the E-Paper library.

Step 1: Install ESP32 Board Package

Open Arduino IDE, go to File > Preferences, and add this URL to “Additional Board Manager URLs”:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Then go to Tools > Board > Board Manager, search for “esp32”, and install the “esp32 by Espressif Systems” package (version 3.x or later).

Step 2: Install Required Libraries

Go to Sketch > Include Library > Manage Libraries and install:

• GxEPD2 by Jean-Marc Zingg — The best E-Paper library for Arduino. Supports all Waveshare E-Paper modules with full and partial refresh.
• ArduinoJson by Benoit Blanchon — For parsing the weather API JSON response.
• WiFi — Built into the ESP32 board package, no separate installation needed.
• HTTPClient — Also built in, for making HTTPS requests to the weather API.

Step 3: Select Board and Port

Under Tools > Board, select “ESP32 Dev Module” (or “ESP32-S3 Dev Module” if using the ESP32-S3-Nano). Set Upload Speed to 921600 and select the correct COM port.

Code Walkthrough: Weather Dashboard

The firmware follows a simple cycle: wake up, connect to Wi-Fi, fetch weather data from an API, render the data onto the E-Paper display, then enter deep sleep for a set interval. Here is a walkthrough of the key sections.

Wi-Fi Connection

The ESP32 connects to your home Wi-Fi network using the built-in WiFi library. We set a 10-second timeout so the device does not hang if the router is temporarily unavailable. If the connection fails, the ESP32 goes straight back to sleep and tries again on the next cycle.

WiFi.begin(ssid, password);
int attempts = 0;
while (WiFi.status() != WL_CONNECTED && attempts < 20) {
    delay(500);
    attempts++;
}
if (WiFi.status() != WL_CONNECTED) {
    esp_deep_sleep_start(); // Try again next cycle
}

Fetching Weather Data

We use the OpenWeatherMap API (free tier allows 1,000 calls per day) to fetch current weather for an Indian city. The API returns temperature, humidity, weather description, and wind speed in JSON format.

HTTPClient http;
String url = "http://api.openweathermap.org/data/2.5/weather?q="
             + city + "&appid=" + apiKey + "&units=metric";
http.begin(url);
int httpCode = http.GET();
if (httpCode == 200) {
    String payload = http.getString();
    // Parse JSON with ArduinoJson
    JsonDocument doc;
    deserializeJson(doc, payload);
    float temp = doc["main"]["temp"];
    int humidity = doc["main"]["humidity"];
    const char* desc = doc["weather"][0]["description"];
}

Rendering on E-Paper

The GxEPD2 library provides a paged drawing approach that works within the ESP32’s limited RAM. You define a display object, set fonts using the Adafruit GFX library, and draw text and shapes. For the weather dashboard, we display the city name, temperature in large font, humidity, weather description, and a timestamp showing when the data was last fetched.

display.setRotation(1); // Landscape orientation
display.setFont(&FreeMonoBold24pt7b);
display.setCursor(10, 50);
display.print(String(temp, 1) + " C");
display.setFont(&FreeMono9pt7b);
display.setCursor(10, 80);
display.print("Humidity: " + String(humidity) + "%");
display.setCursor(10, 100);
display.print(desc);

Deep Sleep

After updating the display, the ESP32 enters deep sleep for a configurable interval. During deep sleep, only the RTC (Real-Time Clock) module remains active, consuming around 10 microamps.

#define SLEEP_MINUTES 30
esp_sleep_enable_timer_wakeup(SLEEP_MINUTES * 60 * 1000000ULL);
esp_deep_sleep_start();

The complete source code, including fonts and layout helpers, is available on the Waveshare wiki and in example sketches bundled with the GxEPD2 library.

Power Optimization and Battery Life Calculations

Here is where the E-Paper + ESP32 combination truly shines. Let us calculate realistic battery life.

Active phase (Wi-Fi + display update):

• Duration: ~8 seconds
• Average current: 160 mA (Wi-Fi transmit peaks at 240 mA, idle is lower)
• Energy per cycle: 160 mA x 8s = 1,280 mAs = 0.356 mAh

Deep sleep phase:

• Duration: 30 minutes = 1,800 seconds
• Current: 10 microamps (0.01 mA)
• Energy per cycle: 0.01 mA x 1,800s = 18 mAs = 0.005 mAh

Total per cycle: 0.361 mAh every 30 minutes = 0.722 mAh per hour

Battery life with a 3,000 mAh 18650 cell:

3,000 mAh / 0.722 mAh per hour = 4,155 hours = 173 days (nearly 6 months)

If you reduce the update interval to once per hour, battery life doubles to nearly a year. For a display that updates only twice a day (morning and evening), a single 18650 cell could theoretically last several years, though battery self-discharge becomes the limiting factor at that point.

Tips to maximise battery life:

• Use static IP configuration instead of DHCP. This saves 2-3 seconds on every Wi-Fi connection because the ESP32 skips the DHCP negotiation.
• Reduce Wi-Fi transmit power with WiFi.setTxPower(WIFI_POWER_8_5dBm) if your router is nearby.
• Use partial refresh instead of full refresh when only updating numbers. Partial refresh takes ~0.3 seconds versus 2-3 seconds for a full refresh.
• Power the E-Paper module through a GPIO pin so you can cut power to it during deep sleep. This eliminates the ~1 mA quiescent current of the display’s voltage regulator.
• Avoid using the serial monitor in production — Serial.begin() draws extra current.

Weather APIs for Indian Cities

For a weather dashboard located in India, you have several API options beyond OpenWeatherMap:

• OpenWeatherMap (free tier): 1,000 API calls/day, supports Indian cities by name or coordinates. Reliable and well-documented. Use q=Mumbai,IN or q=Bengaluru,IN format for accurate results.
• WeatherAPI.com (free tier): 1,000,000 calls/month on the free plan. Supports Indian pin codes for hyperlocal data. Returns data in metric units by default.
• Open-Meteo (free, no key needed): Fully open-source weather API. No API key required. Supports coordinates-based queries. Good for Indian locations where city name matching can be unreliable.
• IMD (India Meteorological Department): The official Indian weather service publishes data through its website, but does not offer a public REST API. Third-party scrapers exist but are not reliable for production use.

For this project, OpenWeatherMap is the most straightforward option. Sign up at openweathermap.org, generate a free API key, and use it in your firmware. The free tier easily supports updates every 30 minutes for a single device (48 calls/day, well within the 1,000 daily limit).

If you are deploying multiple devices across different locations, Open-Meteo is the better option since it has no rate limits and requires no API key. The trade-off is slightly less accurate forecasting compared to OpenWeatherMap’s commercial data sources.

Frequently Asked Questions

How long does a Waveshare E-Paper display last?

Waveshare E-Paper displays are rated for 1,000,000+ full refresh cycles and have a 5+ year image retention capability. If you update the display every 30 minutes, that is roughly 17,520 refreshes per year. At that rate, the display would last over 50 years before reaching its cycle limit. In practice, other components will fail before the E-Paper panel does.

Can I display images on Waveshare E-Paper screens?

Yes. E-Paper displays support bitmap images converted to the appropriate resolution and colour depth. Waveshare provides an image conversion tool on their wiki that converts PNG/BMP files to C arrays for direct embedding in your Arduino code. For the 2.9-inch display (296×128), images must be exactly 296×128 pixels in 1-bit black and white format.

Does the E-Paper display work in hot Indian summers?

Waveshare E-Paper modules are rated for operating temperatures of 0 to 50 degrees Celsius. In most Indian cities, this is sufficient for indoor use. For outdoor deployments in places like Rajasthan or central India where temperatures can exceed 45 degrees Celsius, mount the display in a shaded enclosure with some air circulation. The display itself generates no heat, so the main concern is ambient temperature affecting the E-Paper fluid’s viscosity, which can slow refresh times in extreme heat.

Can I use other ESP32 variants with Waveshare E-Paper?

Yes. Any ESP32 variant works, including the ESP32-S2, ESP32-S3, ESP32-C3, and the original ESP32. The GxEPD2 library supports all of them. The ESP32-C3 is particularly interesting for ultra-low-power builds because it consumes even less current in deep sleep (around 5 microamps). The ESP32-S3 offers more processing power if you need to render complex graphics.

Conclusion

Building a low-power weather dashboard with a Waveshare E-Paper display and an ESP32 is one of the most practical IoT projects you can undertake. The hardware cost is under ₹2,500, the battery life is measured in months, and the E-Paper screen is perfectly readable in Indian sunlight. Once you have the basic weather dashboard working, you can extend it to display stock prices, cricket scores, air quality data, or any other information that benefits from a persistent, low-power display. Explore our complete Waveshare collection at Zbotic.in to find the right E-Paper display and development board for your project.