On another of this half sleep ideas one night I was playing with one of this 2.7" small epapers with touch interface and I though, why not to make a simple digital switch?

It's made by 2 PCBs. One provides 3.3DC converted from Mains power and receives 2 signals (50 ms HIGH) that move a latch relay TICK, TICK and switches on /off something.

Second one is the epaper w/touch controller. The MCU we choosed to drive it is ESP32-C3 (About 2.60 USD)

On the back of that PCB is the epaper itself, where we drawn with C++ and the second tick of an RTC, the basic interface you can see here:

https://github.com/martinberlin/bistable-smart-switch/wiki

For more information please visit the WiKi. We will add some units to our Lectronz store soon (At the moment is out-of-stock)

This one might be interesting for you when building some Store or Factory panel:

https://github.com/martinberlin/epaper-weather-station
Collection of examples to read sensors (I2C and others) and publish real-time information with minimum consumption using fast ESP32S3/ESP32 and epaper controllers such as IT8951 or EPDiy

This time we've focused mostly on parallel type of epapers: 16 grayscales and fast updates, just like the ebook readers.

With this mission we created Cinwrite that is an ESP32S3 based PCB with an RTC chip and some other goodies.

Please give as a ★ star in github if you like the project and feel welcome on board.

Since two weeks I've enjoyed collaborating on a Firmware for ESP32 to convert an EPDiy based epaper into an Epub reader  (Like Lilygo EPD47)

This is the repository:
https://github.com/atomic14/diy-esp32-epub-reader

My collaboration so far was to add touch functionality and helping to use the right Waveform for this test epaper.
If you have one of this devices or any EPDiy PCB with a parallel epaper feel free to try it out!

And if you like it don't be shy and ★ the repository!
Build it with platformio and save some books in the /data folder (2 or 3 since SPIFFs has not a lot of free space)
It uses git submodules so remember to clone it using

git clone --recursive https://github.com/atomic14/diy-esp32-epub-reader.git

 And then just push the SPIFFs data folder into the device in Platformio terminal and after that build it

pio run -t uploadfs

 Short preview on my twitter timeline
https://twitter.com/martinfasani/status/1446535433253527557

I wanted to mention that is last weeks I was focusing my efforts to try JPEG decoding. Here it's a resume of the 3 code examples for ESP-IDF:

https://github.com/martinberlin/cale-idf/tree/refactor/oop/main/www-jpg-render#download-and-render-image-example

Result looks like this in Lilygo EPD47 parallel epaper:

Some weeks after we added color support for our epaper component we are announcing also support for 7 color epapers and demo Firmware to render a full color bitmap on this displays.

Original picture:

Rendered using 3x3 dither mode in a Waveshare 4.01 7 color Acep epaper

Of course it does not look like a high resolution color picture, the dither mode reduces the colors to 4 bits per pixel, also 16 colors, but the Epaper supports only less than half: 7 colors. So there is no wonder that the colors look a bit washed out and could only look better in a big epaper and looking it from some distance. But we need to face reality here: this Eink displays are designed for price labels. Not really meant to display a full color picture,p. Not even the full color phone Hisense A5 does it. It renders more colors than 607 but is still not photo quality. 

Class in our IDF component:

https://github.com/martinberlin/cale-idf/wiki/Model-color-wave5i7color.h

For a 7 color example that can render either a 4 bits per pixel or 24 bmp example please check cale-7-color.cpp example in the same repository.

At the beginning of this year I received from Chinese company LILYGO a great 4.7 parallel epaper. I really like the update speed (650ms full update) and the communication speed compared with SPI.

So I decided not to reinvent the wheel and use the great component EPDiy that is also a project here in HackADay to drive them. Here is concept behind it:

https://github.com/martinberlin/cale-idf/wiki/Parallel-epapers-driven-by-Epdiy-with-I2S-Data-bus

What I did in my existing Cale-idf C++ Firmware is to make function wrappers to support most of EPDiy functions but using Adafruit GFX functions and font support.

Proof of concept video

Flashing and rendering a Bitmap downloaded using ESP32 WiFi
Documenting the parallel implementation idea

Proud to announce that in last iteration of CalEPD we added touch support. A small code-snippet to inject Touch in the Gdew027w3T (2.7 inch from Goodisplay)
This is meant to be used as a component in the ESP-IDF Framework:

#include "FT6X36.h"
#include <gdew027w3T.h>

// INTGPIO is touch interrupt, goes low when it detects a touch, which coordinates are read by I2C
FT6X36 ts(CONFIG_TOUCH_INT);
EpdSpi io;
Gdew027w3T display(io, ts);

Priced at about 15 u$ this epaper is very cool to build small UX interfaces using epaper and ESP32.

E-paper component driver for the ESP-IDF framework and compatible with ESP32 / ESP32S2 can be found in this repository:

https://github.com/martinberlin/CalEPD

Codenamed Cal e-pe-de for the initials of E-Paper Display this is basically all what I’ve been doing the last weeks. Learning more about C++ object oriented coding and preparing a class that can be used to send graphic Buffers to different epaper displays. In order to do that I’m documenting on the go and building at the same time CALE-IDF that is our Firmware version for CALE.es but this time built on top of the Espressif IoT Development Framework (IDF)

The mission of this new component is to have a similar library for ESP-IDF that is easier to understand. If possible strictly meeting these requirements:

• Extendable
• Maintainable
• Object-Oriented Programming with human-readable code and function names
• Easy to add a new Epaper display drivers
• Easy to implement and send stuff to your Epaper displays
• Human-understandable
• Well documented
• ESP-IDF only (No Arduino classes)

Please find here the Wiki with the models that are already supported in the component:

https://github.com/martinberlin/cale-idf/wiki

There are 11 monochrome epapers supported, includeding Good display, and a german brand called PlasticLogic with 4 gray level support. Additionally two other models with colors are supported (5.83 and 7.5 both from Good display, red/black or yellow/black)

Project sprint done in one single day:

https://hackaday.io/project/173507-epaper-digital-magnets-clock
The mission is to make an epaper digital clock with the lowest power consumption in ESP32

repository:

https://github.com/martinberlin/cale-idf/wiki/Demo-epaper-clock

Even the most impresice clock is right at least once a day!

If you are interested in making your own ESP32 digital clock check out my demo example. It explores ways to:

Use as little internet as possible to consume less (Only short HTTP requests, very fast and then sleep)

Use an epaper as a mean of minimum possible consumption and persistance when the ESP32 is in deepsleep

Learn how to use ESP-IDF with C++. Without Arduino boilerpate functions, straight into Espressif own framework.

On our Web-Service CALE.es now there is a new model available:

With astonishing 1304×984 pixels this 12.48" display is a very nice hardware. It also worked out of the box after configuring the Waveshare demo example (That I made mine just to improve it a bit)
So what's coming next is a CALE Firmware for this one. That must be different than the existing since this display looks like a big epaper but the are in fact 4 epapers working together.
So it shares MOSI and CLK for all SPI slaves, but it has one Chip select line each of them, and I've still didn't discover why, they share RST and BUSY lines in groups of two. So it's going to be a nice challenge, to download a BMP from WiFi and stream it in the display Buffer.
If you have a github account and are interested in epaper dissplays please put this repository in your Radar
https://github.com/martinberlin/cale-idf
I'm trying to make a multi-epaper display component. It's working already with 6 eink models from different sizes and I'm quite excited about it since it should be more optimized than the existing Arduino framework classes we are using. So if you have some epaper displays hanging around your workshop, don't be shy!  Just tell me the model and I will add it so you can try it out. Keep in mind is only at the time to be used as an IDF component and not in Arduino-framework.