Customer:
I’m working on a typewriter-like product with a focus on LaTeX writing and markdown and JSON file sync. I have a question about display refresh rates: is the high refresh rate dependent on code running on the ESP32 chip? If code was running on a Raspberry Pi and pushed to the ESP32, would the refresh rate be comparable? I’m interested in ordering multiple units.
Originally submitted via email support on 25 April 2025. Migrated to the forum for community visibility.
Soldered Support:
The refresh rate is somewhat capped by the ESP32, but these e-paper panels also have a physical limitation on how often they can be refreshed, which you can observe in the e-paper’s datasheet.
You can write custom ESP32 firmware which will receive data via SPI, USB Serial, or another communication method and render it to the display. Alternatively, you could render the image on your host machine (like a Raspberry Pi) and send the image data itself. This could be slower but could still work.
There is a basic ‘peripheral mode’ where Inkplate receives drawing commands via UART, though this sketch is outdated and will be updated later this year.
To help further, which specific Inkplate product are you referring to?
Customer:
I’m interested in Inkplate 5 Gen2. I need a Raspberry Pi because the product requires subprocesses running on it (Web APIs to sync with research software, libraries to convert BibTeX to citations, etc.), so I can’t move all the code to the ESP32.
I have a few questions:
What do I need to do to preserve the advertised refresh rate? My code is written in Python (running on RPi) with a module draw.py that draws PIL images. From what I understand, passing PIL images to the ESP32 to render is not ideal. Are you suggesting I write the drawing and UI logic on the ESP32 (compile it into binary) which only receives text data from the app running on RPi?
Is the way ESP32 refreshes the 5-inch EPD synchronous/blocking? If I send 20 refreshes within a minute (all triggered by keypresses), will they get queued?
Soldered Support:
The advertised refresh rate will be kept 100% in both cases.
Here are the two main options:
Option 1: Send rendered image data
Send a rendered PIL image converted to Inkplate’s bitmap format to Inkplate over Serial, then ‘unpack’ that image on Inkplate’s side and draw it. This takes a few milliseconds at least. Once the image is drawn and unpacked on Inkplate and stored in a uint8_t array of fixed size, processing this fixed-size data (o(1)) will take some time, then you can refresh as fast as possible. If you store multiple frames/images and only fetch data once every so often, you could transfer these images once and then send a short command from the RPi to change the image, making the process basically instant. This approach is good because you can completely make your resulting image in PIL in grayscale using all available tools without depending on the ESP32. You could also transfer the image data over SPI to increase transmission speed. I can explain the expected Inkplate uint8_t image data format later.
Option 2: Send command data
Send JSON over Serial containing data to write, then write an ESP32 Inkplate Arduino sketch which unpacks it using the Arduino JSON library and draws this data. This is limiting but possible. Data transmission is essentially instant, and unpacking the data and manually drawing into Inkplate’s framebuffer element by element using the Inkplate library would be faster than sending the whole picture as a bitmap. But it comes with limitations depending on the kind of data and how you want to display it.
Refresh behavior
The way the EPD is refreshed is blocking. The 20 refreshes within a minute on Inkplate 5 Gen2 should be no problem because the full update is around one second and the partial update is even quicker. If Inkplate 5 Gen2 receives input during the short time while it’s refreshing, it will not register unless the input is done with an Interrupt, but this shouldn’t be problematic in your case.
Let me know if you need help with an image bitmap format description or a code example.