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.

The problem

A 3D printer is the most versatile tool any maker can have, but it has possible pitfalls and one of the more insidious ones is damp filament.

What happens: You have the printer dialled-in perfectly, everything works perfectly, a couple of weeks pass and then you try to print something again. It comes out looking terrible: blobs, stringing, ugly surfaces.

This is due to humidity absorbed by the filament. Once the filament enters the hot extruder, humidity expands into steam and plays havoc with the flow of molten material in the nozzle. In really bad cases you can actually hear the pops from the tiny steam bubbles during printing.

Some materials are more sensitive than others—you will be able to leave ABS or PLA out longer than, say Nylon, the worst of them. But one month outside in summer heat will make any filament unusable.

You can delay these problems a lot by storing filaments in an enclosed container and adding some desiccant helps even more. But eventually, any filament will get humid enough to need drying.

The Most Common Solution

On the surface, this looks like a solved problem: e.g. Sunlu dryer boxes work well and are not that expensive. But this kind of dryer box is not without problems:

• They are not cheap, a two-roll box will cost you about ~90€. If you are serious about printing, you will need at least two of those.
• They have 150-200W heaters. If you are paying German electricity prices, each day you use one will cost ~1-2€. And each year has 365 days…

So is there a different way?

How Does Drying Even Work?

The Usual Dryer Boxes

The dryer boxes I mention above work by heating up the air. Hotter air can carry more moisture (relative humidity is reduced) and this “sucks” moisture from the filament due to osmosis (which happens faster due do higher temperature as well). The hot and humid air is then blown out of the enclosure automatically or you need to do it manually after the end of each cycle. Some will take advantage of moisture condensing on the cooler walls, which you must then wipe down.

See this explanation for extra info.

The Proper Way To Dry Things

If you look at industrial dryers or modern clothes dryers, these work differently.

The first step of the process is the same: Blow hot air into the chamber to capture the humidity. The next step is very different, though: The hot humid air is cooled, which causes the excess moisture to condense away, leaving you with dry cool air that you can then heat up again to dry the filament, in an endless circle.

At first glance, this seems like a very wasteful process: instead of simply heating the air, you need to cool it too. But here comes the magic part: You can use a heat-pump to transfer the heat from cooling to the heating part of the cycle. A modern heat-pump is extremely efficient and will only consume about 25% of energy it is able to transfer. So if you need 200W of heating power, you will only need about 40W of electricity for the same effect. What is more, because you are cooling the return air, the return air is very dry and the drying effect is even stronger.

My Solution

The parameters

I wanted a solution that does the following:

• There should be enough space for at least 10 rolls of filament.
• It should be able to work continuously, no wiping down etc.
• It should consume no more than 50W of electricity (a quarter of the consumption of a normal dryer)
• Some monitoring would be nice

The hardware

There are many possibilities:

I could possibly build a really big dryer out of a second-hand clothes-dryer. My neighbor and I actually converted one into a big fruit dryer so his apples and plums don’t spoil after the harvest. But while this is a good way to dry out large amounts of moisture, filaments only contain a few grams of moisture each at most and the dryer will consume 700W of electricity. So this would be a really wasteful way of doing it and it would take up a lot of space.

Maybe a mini fridge? I could use an air duct to heat up the air at the rear heat-exchanger, blow it into a box, and then return it to the cold side of the mini fridge. But this would take extra space and I’m not sure how to cool the air effectively.

In the end I decided to buy a very simple and very cheap room air-dryer on Aliexpress. These small units will consume about 15W and dry out a couple of tens of grams of moisture a day from the surrounding air.

They use a Peltier element instead of a proper heat-pump, but since we need so little drying capacity, this is good enough. The Peltier element, the two heat-sinks and the fan are combined into one compact unit like this:

There is also a power-supply, so you only need some more fans, a control board and a new housing.

The Box

I decided to use a simple plastic storage box I kept the filaments in already. IKEA is a good place to find one that is large enough for your needs. Mine is about 40 x 50 x 60 cm, enough for about 12 rolls.

The Housing

My idea was to put the entire Peltier block along with two temperature sensors (DS1820, hot and cold side), a humidity sensor (AHT20, for monitoring) and two fans (hot and cold side) inside the box as a drying unit.

A small hole in the side of the box connects this drying unt with the control box outside. The control box contains the power supply, an ESP8266 controller and a couple of relays for control.

There is also a small outlet for the condensed water on the bottom of the cold side housing. This is connected to a small tube and routed outside the box.

Here is the Fusion project, if you want to play with it.

The First Prototype

Control

I decided to use ESPHome and integrate it into my Home Assistant system to control the whole thing.

The first version was over-engineered, with PWM control of both fans and measurements on hot and cold side. It turns out you only need to monitor humidity and control two relays, one for the Peltier element and the hot side fan, the other for the cold side fan. You could even do without the cold side fan at the expense of a slightly lower drying power.

The Algorithm

The algorithm is simple:

1. Turn on the Peltier and the hot side fan.
2. Wait for a while for the water to condense on the cold side. (The hot side fan is strong enough to ensure the circulation on the cold side too.)
3. Turn off the Peltier and turn on cold side fan to blow the water off the heat sink ribs down into the water outlet. A minute is enough. This is optional, water will drip down on it’s own until there is very little moisture left.
4. Repeat.

It also needs a safety feature to turn off the whole thing if the hot side heats up above 45 °C (i.e. fan problems).

I also added an automation that only turns the dryer on when there is extra power available from the solar plant I have installed. This is optional, but it does keep the whole thing from taking energy from the grid.

Final Thoughts

The whole thing cost me about 70€ at most and it works. There is one drawback: It takes a few days to dry a moist filament roll, but it keeps everything nice and dry afterwards. It seems that putting in a moist roll does not affect the rest of the stored rolls at all.

The ESPHome Code and Planned Improvements

Planned improvements

The code is for the current over-engineered system. The next version will have no PWM, no cold side fan, and no cold side temperature sensor. The hot side fan power will be fixed using a resistor. There will be only one relay that controls both the Peltier and hot side fan. The power supply will be next to the hot side fan to use the wasted energy to heat the box.

The Code

esphome:
  name: susilnik
  friendly_name: susilnik

esp8266:
  board: esp01_1m

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "secret"

ota:
 —platform: esphome
    password: "secret"

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  use_address: secret

one_wire:
 —platform: gpio
    pin: 13

sensor:
 —platform: aht10
    temperature:
      id: temperatura
      name: "Temperatura"
    humidity:
      id: vlaznost
      name: "Vlaznost"
    update_interval: 60s
 —platform: dallas_temp
    address: 0x090417b10b0cff28
    name: "Temperatura topla stran"
    id: temperatura_topla_stran
 —platform: dallas_temp
    address: 0x690517a0c505ff28
    name: "Temperatura hladna stran"
    id: temperatura_hladna_stran

i2c:
  sda: 4
  scl: 5
  frequency: 10kHz

switch:
 —platform: gpio
    pin: 16
    name: "Vklop 12V"
    id: vklop_12v
    restore_mode: ALWAYS_ON

output:
 —platform: esp8266_pwm
    pin: 12
    frequency: 10 Hz
    id: pwm_hladni_ventilator
 —platform: esp8266_pwm
    pin: 14
    frequency: 10 Hz
    id: pwm_hladilni_ventilator

fan:
 —platform: speed
    output: pwm_hladni_ventilator
    name: "Hladni ventilator"
    id: hladni_ventilator
 —platform: speed
    output: pwm_hladilni_ventilator
    name: "Hladilni ventilator"
    id: hladilni_ventilator

time:
 —platform: homeassistant
    id: homeassistant_time
    on_time:
      #Safety functions
     —minutes: /1
        seconds: 0
        then:
          if:
            condition:
              switch.is_on: vklop_12v
            then:
             —if:
                  condition:
                    or:
                     —sensor.in_range:
                          id: temperatura_topla_stran
                          above: 45
                     —sensor.in_range:
                          id: temperatura
                          above: 40
                  then:
                    switch.turn_off: vklop_12v
     —minutes: 55
        seconds: 0
        then:
          if:
            condition:
              switch.is_on: vklop_12v
            then:
              fan.turn_on:
                id: hladni_ventilator
                speed: 50
     —minutes: 57
        seconds: 0
        then:
          fan.turn_off: hladni_ventilator
      #Start cooling fan for PSU
     —minutes: /1
        seconds: 0
        then:
          if:
            condition:
              switch.is_on: vklop_12v
            then:
              fan.turn_on:
                id: hladilni_ventilator
                speed: 50
            else:
              fan.turn_off: hladilni_ventilator

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