E-ink Hymn Boards
This project is open-source on GitHub: https://github.com/iBelieve/ehymnboard
Background and Idea
Liturgical churches often have hymn boards in the front of the church that display a list of hymns that will be sung during worship services. These usually use black cards with white numbers on them, and someone needs to manually update the hymn boards before each service. My church used to have hymn boards, but they had fallen into disuse for several years and finally were completely taken down.
A popular trend today is for churches to mount large digital TV displays in the front of the church, and show slides with hymns and other details during worship services. However, I don't think this is a beneficial trend for a couple of reasons. First, I think physical hymnal books are good, and churches should use hymnals so that people learn to use them and then use hymnals in their homes for daily family devotions. Second, screens by their nature draw the eye to them, and tend to distract from the traditional focus in liturgical churches on the altar, font, and other elements of the chancel that teach Christian doctrine. As a stanza from the hymn "Built on the Rock" (ELH 211) says,
Here stands the font before our eyes,
Telling how God did receive us;
Th'altar recalls Christ's sacrifice
And what His table doth give us;
Here sounds the Word that doth proclaim
Christ yesterday, today, the same,
Yea, and for aye our Redeemer.
Another point is that I think we use screens far too much today, whether that's scrolling on our smartphones or watching TV in our homes. In contrast to this, I really like the digital minimalism of eink screens, and love reading books on my Kindle or using BOOX tablets. I like the "physical" nature of eink, with actual physical particles that work without a backlight and hold their state without power.
I've read about people getting used batches of little eink "tags" used by grocery stores, department stores, etc. from eBay. These little eink tags seemed to be about the same size as hymn board numbers, so it gave me the idea that perhaps I could build a hymn board with eink digits that could be easily updated remotely prior to a service just by typing hymn numbers into a web page.
Early Prototype
As we researched e-ink screens and looked at the old hymn boards, we came across Waveshare's 13.3" eink screens. We realized that three of them stacked on top of each other would be the exact size we needed to display 6 lines of hymn numbers just like the old hymn boards had if we displayed two lines per screen. I ordered one of these e-ink screens and got a Raspberry Pi Pico to drive it. The Pico is cool in that it supports MicroPython, a "full Python compiler and runtime that runs on the bare-metal", as their website describes it. This made for really easy rapid testing and prototyping. Of course, we had to start with a classic "Hello World".
Woodworking
We built the wooden hymn boards themselves from scratch as we didn't want to damage the previous boards. We ordered red oak boards from Woodchucks Wood - they have a great selection of wood and can custom-cut wood as needed since I don't have access to a table saw. Nice! We went with gothic arches for the top of the hymn boards. Gothic arches are cool because they're just simple arcs made from two intersecting circles. I designed the boards in Onshape, and we chose to build the boards from three pieces, two boards across, and a bottom piece to sort of add support. This mirrored the designs of our church's old hymn boards that we were somewhat copying.
One thing I learned during this process was that we shouldn't have cut the curve before gluing up the boards because it makes it a whole lot harder to clamp. I then promptly made a similar mistake on the second board by cutting the curve before gluing on the bottom piece.
We decided to route a shallow inlay into the boards to hold the screens. A designed and built a simple jig for this, which worked really nicely. We built a simple frame out of thin strips of wood (thanks to Woodchucks Wood for custom cutting them for us!) and added some nice beveled edges. We also added a simple enclosure on the back to house the hardware for driving the screen. We considered a few different ideas for a decorative cross at the top, but ultimately went with a simple square design. Here's what the new boards looks like next to the old boards:
Hardware
We stuck with the initial choice of the Raspberry Pi Pico W driving three Waveshare 13.3" screens. The e-ink screens come with a nice driver board and are controlled over SPI. I designed a simple PCB in KiCAD to hold the Pico and cable connectors. With shipping and tax, a batch of five only cost $4.17!
The eink screens all pass their cables through to the back box, which houses the Pico board and the driver boards:
Software
I wanted to be able to update the hymn boards wirelessly from a web page, so I chose the wireless Pi Pico. I designed the architecture so the hymn boards would regularly poll a server for new images, and update the eink screens only if an image changed. I wanted the boards to be resilient to reboots or power failures. I definitely didn't want the boards to refresh in the middle of a church service! Because the boards will be updated prior to a service, I don't care about fast update cycles or the left and right hymn boards updating exactly in sync or even all three screens on a same board updating simultaneously. The hymn boards will also be far away from people, so I don't care about antialiasing or even multiple shades of gray. A simple 1-bit black/white mode is completely sufficient.
For the server, I wanted to use the Python Pillow image processing library to generate the images, as it has nice support for a 1-bit image mode. I chose Flask for the server and TailwindCSS and DaisyUI for a simple web admin. I skipped out on a database and just used basic auth with a username/password from env vars. I'm storing the text entered as well as some device stats in simple JSON files. Maybe not the most efficient, but super simple. I'm sending images to the device as simple pixel buffers without any encoding so I don't need to worry about image formats on the device. I'm hosting the server on a Hetzner VPS using Dokku, a lightweight self-hosted PaaS that uses Docker containers.
For the device itself, I initially used MicroPython, but ran into weird issues with network requests hanging. I spent a bunch of time trying to troubleshoot with Wireshark to inspect the network packets. I tried rewriting the code in C++ using the Pi Pico SDK and the lwIP TCP/IP stack, and eventually figured out that if I set LWIP_TCP_TIMESTAMPS, everything worked. Something either on my local network, in my ISP, in Hetzner, or somewhere in between seems to have been dropping TCP packets without timestamps. I don't know enough to know why that's the case or if that's expected, but setting this flag was enough to fix the issue, and I'm happy with that.
I tried to design the boards to be as resilient as possible. Any major issue would result in a reboot, rather than retries, as that seemed like the simplest approach. The server sends back an ETag for each image, and we save that to the device's flash storage and send it to the server when checking for image updates, so that we only update the eink screens if the image has changed. This means that if a hymn board reboots in the middle of a worship service, it won't refresh the eink screens.
Easter Sunday
We finished the hymn boards just in time for Easter 2025, and installed them the day before. We didn't have time to wire up a permanent power supply over USB, so I just updated the boards by plugging them into a USB power bank for just long enough for them to update. That's the beauty of e-ink - they hold their content and work just fine without power. I'm really pleased with how they turned out. I think they look really nice, and the look thing is that thanks to the use of e-ink, they don't even look digital!
Post-Launch Issues
We realized after the first Sunday or two that while the initial font I picked (Orelega One) was a beautiful serif font, it wasn't super readable from the back of the church. So I switched to a sans serif font, Bebas Neue, which everyone has said is much more readable.
We finally got the boards wired up to a permanent power supply, and immediately encountered an issue where the boards would freeze relatively soon after being powered up. After monitoring the board's serial output for a bit, I found it was panicking with the error tcp_write: no pbufs on queue => both queues empty. I haven't had time to track down the root of that issue yet. But I knew I wanted the boards to be more resilient, so I tried utilizing the Pico's watchdog so if at any point the main loop wasn't looping, the device would automatically reboot. Only problem: the Pico watchdog has a max timeout of 8 seconds. Rather than littering the codebase with watchdog updates, I ended up building a sort of double system using a repeating task. Every time the main loop loops, I reset a counter to 60. Then, once every second, a repeating task fires, decrements that counter, and as long as it hasn't reached zero, updates the watchdog. This creates a sort of "long watchdog" that has 60 seconds in between updates before actually triggering the hardware watchdog itself. Works nicely and keeps the codebase clean by only needing a single line to update it in the main loop.
The boards still regularly reboot at least every couple of hours, and I'd like to dive deeper into that panic issue, but for now, it's functionally working, and I'm happy for now. What I need to do is buy another Pico and run the code for a while while hooked up to the serial monitor over USB so I can better reproduce the issue and test fixes without having to go to church.
Conclusion
Overall, this was a really fun project and I'm quite pleased with how it turns out. We've been using it for around 20 worship services so far plus one wedding, and the only issue was that on the second Sunday I wrongly typed in a wrong hymn number. Oops. That was embarrassing.
This project encompassed woodworking, CAD design, circuit board design, programming, and 3D printing. We used to have hymn boards in church, but they got taken down because no one was actually updating them before services, so this was a really interesting opportunity to explore how we might leverage modern technology in an anti-technology, anti-screens way. I've come across other digital hymn boards, but I'm pretty sure ours are the first ever to use e-ink.
I really like that the e-ink is as minimally distracting as possible. The screens have no light and do not glow at all; the e-ink particles combined with a matte finish makes them look "real" and "physical" and not digital or screen-like. They are updated once before the service and don't change at all during worship.
This project is open-source on GitHub: https://github.com/iBelieve/ehymnboard