Introduction

Last fall I came across an interesting article in Hackaday, where Arne van Itersen made an interesting solar power display with an analog gauge and an e-paper screen.

It immediately grabbed my attention because it solves the biggest problem with e-paper displays—they need a few seconds to refresh, making them unsuitable for displaying continuously changing data like solar power. A simple analog needle takes care of that problem but is limited to displaying one thing only. But if you put the needle in front of an e-paper screen, you get continuous power information from the needle. You can then use the e-paper display for displaying things that only change every few minutes, like storage battery level, daily production, and system operation mode.

But using an analog dial from a multimeter seemed a bit fiddly to me, and I thought about how to improve on that. Using a small servo instead would be better, because I could use needles of any size. Controlling the servos is quite simple too, I needed the ESP32 to control the e-paper display anyway. It took a weekend to put together a simple prototype for a one gauge display, which I used for my DIY EV-charger.

The thing worked like a charm and got me thinking about how to improve it. I was thinking about updating my solar system display for a while now, and this seemed like a good solution.

Thinking About The Design

One needle wasn’t going to cut it this time—I wanted one for solar power, one for power coming from the grid, and one for the power going into the house. After thinking about it for a while, I decided to put the grid and house power servos on the left and right side of the display. The solar servo would be on the bottom. This provides some spatial logic too—power flows from the grid (left) or solar (bottom) to the house (right). I guess putting the solar need on top could also work, but that didn’t look right to me for some reason.

I wanted to put the display outside, where it would be exposed to the elements, so it needed a weatherproof housing. So I had to think a bit on how to make a housing that would be both weatherproof and easy to assemble. It’s easy to build a two part shell, but how to design it in a way you can assemble and then disassemble it easily while keeping it watertight? I decided to approach it differently. I designed a mounting plate for the servos and the e-paper display first and gave it a flange on the sides and on the bottom. Then I designed a one-piece housing with a window and a simple top cover. This housing had simple guides to hold the flanges of the mounting plate. The window can be closed using some acrylic glued with silicone to make it weatherproof. The top cover is designed to have rainproof downslopes and only needs a drop of superglue on each side to keep it in place. This makes the assembly and testing really simple, you can do everything with the mounting plate alone.

The Software

I’m used to Arduino, so this is what I used. E-paper in Arduino is IMO best used with the GxEPD2 library, which includes the Adafruit GFX functions, the servos are controlled using the Servo library, data exchange is done using Adafruit MQTT, and network connectivity uses WiFi.

The program is subscribed to several MQTT topics, containing the values for grid power, house power, solar power, solar production, battery level, and system mode. Each of these topics is linked to a callback function that triggers on topic updates. The callback functions for grid, house and solar power all move the respective servo needles. The callbacks for battery level and solar production only update the relevant global variables. Screen refresh is only directly triggered by a system mode topic change or every 10 minutes, but this updates the display with the latest data stored in the globals.

Startup makes a full sweep of all the needles, serving as a kind of servo calibration check, then starts the main loop. The main loop is really short and only keeps the MQTT connection alive and resets the whole thing if Wi-Fi drops.

Getting the Data To the Topics

The one remaining job on the software side was to get the data from my solar system to the MQTT topics. The solar system is connected to my Home Assistant installation, so it was really easy to set up some automations that publish the relevant data to MQTT topics when the relevant sensor states change. I used state changes for triggers and the MQTT Publish service to send the data to the MQTT topic. I already had a MQTT broker set up for my other projects, so I just used that one.

Build

Once I was satisfied with the results, it was plain sailing:

• 3D-print the enclosure using ABS
• Cut the acrylic to size and glue it to the enclosure using some silicone glue
• Drill a hole for the power cable on the appropriate spot, then use some mounting glue to fix the enclosure to the wall
• Connect the power and insert the mounting plate in the housing.

You can find all the relevant code and files on Github

If you found this article useful, you can buy me a beer here.

When researching the e-paper displays for the art project described here, I bought a Waveshare ECP 600x488 7-color E-paper Display (just a normal link, I’m not making any money with this), but ended up never using it. I really try to avoid stuff piling up in my drawers, so I decided to use an old (vintage: 2011 😀) Raspberry Pi 1B I had lying around too and build a simple photo frame.

Using Raspberry Pi To Control the E-paper Display

First, set up a headless Pi using Raspberry Pi OS Lite.

Next, you have to wire the display to the Pi header. The Waveshare Wiki instructions are pretty good and the setup should work out of the box for most people.

I had to make a few changes for my setup, because I wanted to use my old Raspberry Pi 1B to keep it from the e-waste bin. But it has different GPIO pins, so I ended up using the SPI pins on the Pi 1 and GPIO0, GPIO2, and GPIO3 for the DC, RST, and BUSY signals. This required a change in the /RaspberryPi_JetsonNano/python/lib/waveshare_epd/epdconfig.py file. Under # Pin definition I changed the defs this way:

 # Pin definition
    RST_PIN  = "WPI2"
    DC_PIN   = "WPI0"
    CS_PIN   = "WPI10"
    BUSY_PIN = "WPI3"
    PWR_PIN  = "WPI1"
    MOSI_PIN = "WPI12"
    SCLK_PIN = "WPI14"

This enabled the Waveshare e-paper library to work with my old Pi. If you will be using a newer Pi (2 or higher, with the 40-pin header), you don’t need to do this.

Now just run the /RaspberryPi_JetsonNano/python/examples/epd_5in65f_test.py file to see if everything works.

Preparing the Image Files for Display

The 7-color e-paper display works differently than the normal LCD displays. Instead of every pixel having an RGB value, each pixel can only display one of the seven available colors: black, white, green, blue, violet, yellow, and red. Then there is the fixed 600x488 pixel resolution. Finally, the Waveshare library is written to accept bitmap (*.bmp) files only.

Color Conversion

The 7 color limitation means we have to do a color conversion to be able to display the pictures on this display. Selecting simply the nearest color for each pixel will give pretty underwhelming results, so we need a better method, called Floyd-Steinberg dithering. This is a very good explanation of it.

You could code this yourself, but there is a lovely program called ImageMagick that will take care of this for us. But first we need an file that contains only the colors we need. Luckily, the Waveshare library comes with example pictures and you only need this one: RaspberryPi_JetsonNano/python/pic/5in65_n0.bmp, just copy it to the folder you will be using.

Select the Files

This is a pretty obvious first step—collect all the pictures you want displayed on your photo frame. In my case, I did a keyword search in my Google Photo account and simply exported all the results to a temporary directory. Then I did a quick scroll through to delete some photos I did not want to include. Since I was dealing with about 7000 photos, “quick” was a relative term, but it only took a couple of hours.

Do the Conversion

First install ImageMagick (I used winget install ImageMagick.Q16-HDRI on my windows PC). Next, run the following command-line command (replace the folder name accordingly):

magick *.jpg -resize 600x488 -dither FloydSteinberg -define dither:diffusion-amount=85% -remap "folder/your/color/definition/file/is/in/5in65_n0.bmp" BMP3:images.bmp

This opens all the JPEG files in your folder, resizes them to max 600x488 pixels (leaving the unused space blank, so the aspect ratio stays correct), applies the Floyd-Steinberg dithering using the specified file, and, finally, saves them as bitmap files using the given filename, to which the sequence number of the file is appended.

Of course, there are many other ways of doing this, but this worked for me.

Doing the Conversion in Batches

ImageMagick is a very powerful program, but once you convert more than about 1000 pics at once, it will create a crazy amount of temporary files and the conversion itself will take a LONG time. So it’s best to limit the conversion to batches of about 500-2000 files. This depends on your computer: 2000 pics took almost an hour on my rather new and quite powerful computer, producing over hundred GBs of temporary files in the process.

I think the best way is to copy all the image files to a folder called todo first. Then you copy the first batch of, say, 1000 files to your working folder. You then run the conversion, wait until it completes, and then copy everything but the resulting BMP files to the done folder. Then copy the next 1000 files, run the conversion again, but add “_1” to the result filename. Repeat, incrementing the suffix, until the todo folder is empty.

Congratulations, you now have a large pile of bitmap files suitable for displaying on the 7 color e-paper display 😀 All you have to do now is copy it to a folder of your choice on the Raspberry Pi.

The Python Code

The code to display the files we just prepared is quite trivial, I simply copied the /RaspberryPi_JetsonNano/python/examples/epd_5in65f_test.py demo code and removed all the unnecessary parts. Then I added the code to be able to display bitmaps that don’t fill the whole screen. Finally, I added random selection to keep the files from repeating too quickly. The code uses Pillow and you should take care to use proper file handling or you will have problems.

import sys
import os
import random
import logging
import time
from PIL import Image
import traceback
# Imports the Waveshare library
libdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'lib')
if os.path.exists(libdir):
    sys.path.append(libdir)
from waveshare_epd import epd5in65f

# Let's keep the log short and only collect warnings. Use levels "INFO" or "DEBUG" for setup.
logging.basicConfig(level=logging.WARN)

try:
    logging.info("Random files")
    
    # Initialize the display driver
    epd = epd5in65f.EPD()
    logging.info("init")

    #The forever loop
    while True:
        logging.info("read bmp file")
        image_folder="/the/folder/with/the/bitmaps/"
        #Randomly select the file from the folder
        random_file=random.choice(os.listdir(image_folder))
        logging.info("Chosen file: " + image_folder + random_file)

        #This is important: if you don't use proper file handling using "with",
        #the file stays open and displaying the next file will fail
        with Image.open(image_folder + random_file).convert('RGBA') as bitmap:
            #First set up a white background
            Himage = Image.new('RGB', (epd.width, epd.height), 0xffffff)
            #Get image dimensions from the bitmap file
            width, height = bitmap.size
            #Paste the image on the middle of the white background
            Himage.paste(bitmap, (int((600-width)/2), int((488-height)/2), int((600-width)/2)+width, int((488-height)/2+height)))
        #Initialize the display
        epd.init()    
        #Display the bitmap on background
        epd.display(epd.getbuffer(Himage))
        #Turn off the display internals and wait 10 minutes before you show the next pic
        logging.info("Goto Sleep...")
        epd.sleep()
        time.sleep(600)
    
except Exception as e:
    logging.info(e)
    
except KeyboardInterrupt:    
    logging.info("ctrl + c:")
    epd5in65f.epdconfig.module_exit(cleanup=True)
    exit()

Insert the image path as needed, then run and check if it works.

Set Up the Pi To Run Unattended

If everything works as intended, set up the Pi to auto-run the code on startup using this handy guide. I like the SYSTEMD method best.

Once everything works well after you reboot the Pi, don’t forget to turn on the Overlay File System to prevent SD card corruption if the power goes out unexpectedly.

Putting Everything Together

You now have an e-paper display showing beautiful pictures next to a Raspberry Pi. But it’s not a digital photo frame yet, it needs some kind of a housing first. I decided to use a simple 3D-printed VESA 75 mm case for my Pi and then designed a simple stand to hold everything together.

Conclusion

The first thing anybody will probably ask is: Why? Why use a strange display with a rather low resolution and only 7 colors to display your family photos? Without even keeping it low-power?

The answer is a bit complicated, but I can explain it best like this:

• Constraints spur creativity.
• It’s not about the resolution or color fidelity, it’s about the pictures.
• The grainy dithered images have a nice rough and timeless vintage feel to them. They give a new quality to the images I saw many times before.
• The slow tempo of changing images does not demand your attention. It is a decor item, not another gadget to waste time with.

And I got to rescue an 13-year old Raspberry Pi from the drawer in the process 😄

If you found this article useful, you can buy me a beer here.

What Do I Mean by Low Power?

I was involved in an art project where we wanted to use a smallish (10 x 15cm) solar panel to power an e-paper display inside a gallery, controlled by an ESP32 micro controller.

This would be a pretty trivial job outdoors: the panel has 5W peak power and I could just put a small DC-DC converter on it to get stable 3.3V power from it during normal daylight.

Indoors, the game changes completely, due to two main issues: low illuminance and low solar panel efficiency at low illuminance.

Outdoors, the illuminance will be anywhere from 1000 to 100000lux during the day. On the other hand, normal indoor lighting would normally range from 100 to 500lux. This alone reduces the available power from the solar cell by a factor of 200 or more. 5W turns into 25mW.

But there is another problem: The solar panel efficiency drops at low light. At full illuminance, the total power conversion efficiency of a modern solar panel can exceed 20%, but the same panel will have a much lower efficiency at low light due to interior current leakage. The expected 25mW turns into 5 or 10mW at most with normal indoor lighting.

To put this in perspective: ESP32 will consume somewhere around 900 mW transferring data via WiFi and some 20 to 70 mW with radio off. See this helpful article.

So is there no way to power the ESP32 using our solar panel?

The Solution

Our project involves refreshing an e-paper display at certain intervals and e-paper consumes power only during the refresh (drawing). So the solution is to somehow store the miniscule amount of available energy until there is enough to draw the next picture, turn everything on, draw the picture, save the data for the next one, and power off.

The Hardware

On the hardware side, I achieved this using a solar harvester chip AEM10941 evaluation board that very efficiently charges a single super-capacitor. This super-capacitor in turn powers a low-power, low-voltage boost converter and this powers the ESP32.

The Software

But the hardware alone is not the solution yet: I needed a way to turn off everything so the harvester has the chance to charge the capacitor up, do the drawing only when the capacitor is full and then turn off everything again until there is enough power available.

ESP32 Deep Sleep

The solution is to implement the deep sleep on the ESP32. While in deep sleep, the ESP32 chip only consumes 10μA, but it powers off almost everything, leaving only a small portion of slow RTC RAM and a counter that periodically wakes it up.

So how does it all work?

1. The system spends most of the time in deep sleep, where the combined power usage of the power harvesting system, converter and ESP32 never exceeds about 150μW.

2. Every 5 or 10 seconds it wakes up for a fraction of a second to measure the capacitor voltage:

   2a. If the voltage is not high enough, it goes to deep sleep again.

   2b. If the voltage is high enough, it draws the picture, stores the sequence number into the RTC RAM and goes to deep sleep again.

3. Rinse and repeat.

Pick the Right ESP32 Board!

There is a possible pitfall here: Some ESP32 development boards, like the basic ESP32 Dev Module, power additional circuitry (level converters, USB-to-RS232 chips etc.) from the 3.3V rail. This means they will always use at least 10mW of power, regardless of the deep-sleep mode, which is useless for our use case. I had really good experience with the Olimex ESP32-DevKit-LiPo boards in this respect, but there are other well built development boards out there.

There Are Always Unintended Consequences

Remember how the chip powers off almost everything when in deep sleep? All the regular RAM contents are lost too, only the sequence number in RTC RAM remains. So when I try to draw the next picture, the system doesn’t know a picture was already drawn previously and simply draws over it. The results are really ugly:

I spent way too much time thinking how to fix this…

One option would be to use a full refresh, but that would entail the annoying blinking of the whole display. Then I thought about adapting the library and storing some of it’s variables in the RTC RAM. This seemed like a sure way to lose all my remaining hair, though.

After a lot of thinking, I finally thought of a nice hack. The system doesn’t know what was displayed previously? I should draw the exact same picture as the last time to “refresh it’s memory” and right afterwards draw the new one.

This worked beautifully:

Conclusion

Super-capacitors are a wonderful way to power small devices that work at intervals when there is not much power available. They are preferable to batteries due to their much better cycling ability. I like things that you can put on a wall and expect them to work for years and years instead of becoming electronic waste soon.

And if you use deep sleep with ESP32, always keep in mind the lost RAM contents when the chip wakes up again.

The Code

#include <GxEPD2_BW.h>

#include "GxEPD2_display_selection_new_style.h"

#include "bitmaps/images.h"
#include <pgmspace.h>

#include <driver/adc.h>
#include <esp_sleep.h>

RTC_DATA_ATTR int pic_index = 0;
const int adcPin = 34; // GPIO34 (ADC1_CH6)
const int sleepTimeSeconds = 3; // Sleep time in seconds
const int array_size = sizeof(images)/sizeof(images[0]);
const int refresh_size = 30;

void setup()
{
  // Configure ADC
  adc1_config_width(ADC_WIDTH_BIT_12);
  adc1_config_channel_atten(ADC1_CHANNEL_6, ADC_ATTEN_DB_11);
  
  // Read the voltage on pin 34
  int adcValue = adc1_get_raw(ADC1_CHANNEL_6);
  float voltage = adcValue * (3.3 / 4095.0); // Convert ADC reading to voltage

  if (voltage>2.45) { // Only if voltage is high enough
    if (pic_index%refresh_size == 0 || pic_index%array_size == 0) {
      display.init(0, true, 2, true); // first update should be full refresh
    } else {
      display.init(0, false, 2, true); // following updates should be normal refresh + draw previous picture to avoid artifacts
      display.drawImage(images[(pic_index-1)%array_size], 0, 0, 400, 300, false, false, true);
    }

    display.drawImage(images[pic_index%array_size], 0, 0, 400, 300, false, false, true);
  
    display.hibernate(); //Turn off voltage converters inside the display to save power

    pic_index++;
  }

  // Configure the ESP32 to wake up after a fixed delay
  esp_sleep_enable_timer_wakeup(sleepTimeSeconds * 1000000);
  esp_deep_sleep_start();
}

void loop()
{
}

If you found this article useful, you can buy me a beer here.

E-paper displays are a niche display technology that uses electric fields to move colored particles in a controlled way to make a very paper-like display.

Most people first saw it in the smart price tags in supermarkets, another widespread use is for e-book readers, and there are used more and more in signage.

These are all very good ways to use a technology with some pronounced advantages and disadvantages:

Advantages:

• Extremely low power requirements: They only need power during refresh and consume no power once the image is displayed. This is perfect e.g. for a price tag that normally only needs to be changed once a day or less.
• Paper-like display: They really do look like printed paper with all the advantages this brings: no need for backlight, extremely broad viewing angle, no eye strain.

Disadvantages:

• Low refresh rate: You can forget playing video games on e-paper, it takes anywhere from hundreds of milliseconds (smaller black and white) to tens of seconds (large multi-color) to refresh the display.
• Limited color display options: E-paper display are monochrome (black and white) by default. Lately, gray-scale (4 or 16 level) and multicolor e-paper displays became available, but these are still limited to 3, 4 or 7 colors. You can’t control them in the same way as RGB displays, so these displays are best for art that looks like comics, i.e. with clear lines and large single-colored surfaces.
• Full refresh involves blinking: When you initialize e-paper, this involves fast blinking; the duration depends on number of colors and size. Black and white displays can do partial refresh with no blinking, but even these must do a blinking full refresh from time to time.
• Not a mainstream technology yet: When you decide to use e-paper, there are resources available, from libraries to displays themselves. It is a technology that has seen some widespread use, especially in e-readers. But e-paper displays are much less standardized and more diverse than other display technologies. One display might allow partial refresh, the other doesn’t. A display that supports partial refresh might make a clean update or blink just once. The libraries I’ve seen are sometimes poorly documented. You might stumble upon unforeseen problems and will have to study some issues for sure. It’s doable, but using an OLED or LCD display is much more straightforward.

How To Use It?

E-paper is normally controlled by a small, low-power micro controller to take advantage of the low power requirements. It does not require much computing power and I’ve seen systems running on a simple Arduino Nano. Most systems will use a modern micro controller like a Pico or ESP32, but some people also use a Raspberry Pi, eg. to display computer- or AI-generated art.

I chose to use the ESP32 micro controller.

Why Use an ESP32 for E-paper?

• It’s ubiquitous: There are many development tools available and a big community of developers to help you on your way.
• It has all the periphery you need: WiFi, Bluetooth, SPI, a lot of flash
• It will work with very low power in deep sleep. This enables compact battery- and solar-powered systems with no need for extra wiring and power supply.

Development Tools

There are several options to develop apps for ESP 32:

• The ESP IDF: A very powerful development environment that includes an IDE, but you can use it in VSCode and Platformio too.
• The Arduino ESP32 core: An Arduino core for ESP32 that you can use in Arduino and Platformio environments.

Pros and Cons of ESP IDF

ESP IDF is the native development environment of the manufacturer, so you can use all the options the chips offer. I would prefer to use it, but there is a problem: Libraries for e-paper are limited.

I found only one promising library for e-paper, the CALE EPD, but the GitHub project is not active lately (since 2023). This is a problem due to changes being introduced in the ESP IDF by ongoing development which mean you will have to fork and repair the library. The range of e-papers seems to be somewhat limited as well, even if it is still the most versatile option. In the end, I wasn’t able to get it working, which is mostly due to me not being an experienced developer, but should still tell you something.

Pros and Cons of the Arduino Core

It looks like the Arduino core is not prioritized by Espressif, but it is reasonably up to date and does not have many limitations. Arduino is a mature environment that puts a lot of emphasis on being backwards compatible, which I really like, but the main advantage in this case is the fact you have a great e-paper library available:

GxEPD2 is a really comprehensive e-paper library with very broad coverage of e-paper displays. It builds on Adafruit GFX, so the interface should be somewhat familiar if you worked with displays in Arduino before. It should work with all the chips Arduino supports, from the old Atmel ones, to the STM, Pico, ESP32 etc.

It’s main disadvantage is the lack of comprehensive documentation There are extensive examples that will enable you to get where you are going, but there will be pitfalls.

The very best thing about this library is that you simply take the example project, wire the display, and select the options in the configuration files: it should work on the first try. There is also a lot of information about it in the internet.

If you found this article useful, you can buy me a beer here.