Close
0%
0%

CALE Low Energy Eink Calendar

Long-life battery powered photo frame that renders a Screen every morning and goes to sleep - CALE.es WebService to render Bitmaps

Public Chat
Similar projects worth following
The idea is to provide two open source parts: 1. ESP8266/ ESP32 Firmware using in C++ using GxEPD library and supporting Eink displays with different resolutions. 2. A server-side script that will take care of making an screenshoot of any website and return a BMP image that this display can read. This Firmware is a work in progress. Please refer to:http://cale.es/firmware to read about the configuration and schematic for ESP32 and ESP8266

ESP8266 demo without download compression

About composer

We use composer to install php dependences. Just go to the screenshot folder and run:

composer install

That's it. It will create vendors folder and download all required libraries. Make sure the other scripts reference this vendor/autoload.php with the right path.

Google calendar reader

In the directory screenshot/g_calendar you can find a very easy and configurable example to generate a webpage with your google calendar:

https://github.com/martinberlin/eink-calendar/blob/master/screenshot/g_calendar

Screenshot tool

The single file php script needs two things to work. First :

wkhtmltoimage

That is the responsible to take a website screenshot and return an image. And after this the php-imagick extension that in most Linux servers you can get installed with one command line.

Imagick is a PHP extension to create and modify images using the ImageMagick library. You can use also a different library to convert the image to BMP like :

https://www.php.net/manual/en/ref.image.php

As long as the output is a 1 or 4 bits depth BMP image. The firmware will read also a 24 bits depth image but is unnecessary large when we just want to render a monochrome image.

About colours

I find the two colours eink that I've tested very slow compared to the only black ink models. So the firmware can support with gxepd library two color models but is up to you to implement it.

back-eink-V1.3.stl

Demo model for a TinyPICO and 5000mA 60*100*6mm 5000mA Lion

sla - 340.80 kB - 01/25/2020 at 10:48

Download

hat-cover-eink.obj

PLA hat cover to glue in the back of the epaper display

wavefront-obj - 23.28 kB - 01/25/2020 at 10:48

Download

waveshare-7.5-preview.png

A fast preview to get an idea how it looks

Portable Network Graphics (PNG) - 52.86 kB - 01/19/2020 at 23:09

Preview
Download

back-eink.blend

Blender file for the back 7.5 Waveshare eink

x-blender - 735.16 kB - 01/19/2020 at 23:07

Download

back-eink-V1.1.stl

STL preview, notice that the idea is to edit the Blend file and add your custom walls for battery, ESP32 and so on

sla - 322.64 kB - 01/19/2020 at 23:07

Download

View all 6 files

  • 1 × ESP8266 board Optionally ESP32 but not needed in v1.0
  • 1 × E-ink display with Hat exposing SPI interface Any size you like. Waveshare has nice ones like 800*480 pixels. We prefer b/w without any colours since it refreshes faster
  • 1 × Powerbank at least 10000 ma Even if it's 5000 mA will last for long days. I'm tired of adding Lion power and charging circuits like adafruit that proved so far to be non efficient
  • 1 × 3D Printed case and HAT cover STLs/OBJ Provided in files
  • 1 × *optional 12x12 mm push reset button Goes between RST in the board and ground, simply restarts it

  • Collaboration with diy-esp32-epub-reader

    Martin Fasani10/13/2021 at 10:18 0 comments

    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

  • JPEG download, decode and render code examples

    Martin Fasani09/01/2021 at 13:29 0 comments

    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:

  • Cale-idf adds support for 7 color epapers

    Martin Fasani03/06/2021 at 16:10 0 comments

    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.

  • Adding support for Parallel epaper displays using EPDiy

    Martin Fasani01/20/2021 at 20:54 0 comments

    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

  • Adding FocalTech touch interface support (FT6X36)

    Martin Fasani10/08/2020 at 14:34 0 comments

    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.

  • New epaper component for ESP-IDF

    Martin Fasani09/14/2020 at 12:23 0 comments

    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)

  • A highly inneficient, imprecise and cool ESP32 digital epaper clock

    Martin Fasani07/01/2020 at 13:45 0 comments

    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.

  • A new impressive 12.48 Epaper is added to the list of supported devices

    Martin Fasani06/10/2020 at 14:07 0 comments

    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.

  • Building an SPI Sniffer for ESP32

    Martin Fasani06/04/2020 at 15:51 0 comments

    As you could read in last Log post if you follow this project I'm slowly coding a new IDF component to act as an epaper driver.
    And in that process I'm reverse engineering GxEPD that is the library we actually use in CALE Firmware.
    Actual branch is:

    https://github.com/martinberlin/cale-idf/tree/refactor/oop


    Since I'm refactoring the OOP part. And doing so I found out that even that I'm sending the same SPI commands and data than GxEPD some models are refusing to work. My father come up with a great idea:

    If you have the face to reverse engineer an existing library then do it well!
    Add an ESP32 SPI Slave sniffer and check exactly what the Epaper display receives.

    So I put my hands at work:

    That's basically the setup, the one labeled as Ein is the SPI slave and the other ESP32 the master. Now that was not going to be so easy as finding an existing working code and modifying it to my needs. First tried with Espressif own SPI slave example in IDF framework. For some reason, mostly because I'm still a beginner with the framework, it didn't work. And then found an Arduino-framework version that did but it was outdated and didn't compiled. So I fixed it:
    https://github.com/martinberlin/esp32-spi-slave

    Now doing a SPI slave with a CPU based chip is not a task for the faint of the heart. Is not a native SPI slave device and according to Espressif documentation


    The ESP32 SPI slave peripherals are designed as general purpose Devices controlled by a CPU. As opposed to dedicated slaves, CPU-based SPI Devices have a limited number of pre-defined registers. All transactions must be handled by the CPU, which means that the transfers and responses are not real-time, and there might be noticeable latency.

    And yes there is! Apart of that if you want to this in real-time and output the results via Serial, you will be limited by the UART speed, so the idea was to make the UART high like 500000 instead of default 115200 and also downgrade the SPI speed of the master.

    It's working but still loosing 1 or 2 bytes each 44 which is still not good. In the way I found some strange things, like an 0x78 byte that is not sent by the master (otherwise epapers will not work) and also the challenging task of detecting what is a CMD ( in GxEPD a command puts additionally DC - data command GPIO low to send and high after sending) DATA puts only SS pin low/high (CMD toogles both SS & DC to send)
    Doing that in real-time is not easy. Additionally I got a cheap Logic-Analyzer that will help me to find out why some of my Epapers won't update with my own class.

    If it happens to tick your interest then check the CALE-IDF repository that is starting to take form and soon will be the component, CalEPD epaper driver, detached and pushed in it's own repository so also another people can use it.

  • ESP-IDF version being build slowly

    Martin Fasani05/19/2020 at 07:31 0 comments

    If you want to join the efforts please put this repository under your Radar:

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

    It will take time since I started beginning of 2020 really focusing my efforts to learn IDF, submodules, C++ classes "in deep" and more concepts.

    It's exciting and a challenging build since there is not such a thing as GxEPD multi epaper class for ESP-IDF or at least I didn't found it and is a good oportunity to create something that can be not only used in the CALE project but also added as a component in any epaper Firmware.

View all 29 project logs

  • 1
    Select a board that you want to use: ESP8266 or ESP32

    Either will work. 8266 will consume less but ESP32 will have another powerful features that make it a nice partner to travel with like zlib compression and bluetooth configuration

  • 2
    Get PlatformIO and the Framework from your selected board installed

    https://fasani.de/2018/11/24/platformio-an-alternative-to-arduino-ide-and-a-complete-ecosystem-for-iot If you still use Arduino is also fine, but I recommend to try Platformio since is a very nice way to package dependencies in your project

  • 3
    Build and compile

    Edit the default_envs line if you want to switch to lolin_d32 (ESP32) or just select your board to match it exacly
    https://github.com/martinberlin/eink-calendar/blob/master/platformio.ini#L5

    And make a copy of lib/Config.h.dist into lib/Config.h
    Add there your SSID / PASS so the board knows how to connect to your Router

View all 6 instructions

Enjoy this project?

Share

Discussions

Martin Fasani wrote 02/22/2020 at 17:56 point

Launched

https://cale.es so you can compose a dynamic screens there and fetch it from ESP32. If you want to try it out just register and I will get in touch. I really need some early feedback!

  Are you sure? yes | no

Martin Fasani wrote 12/23/2019 at 14:27 point

This one is a 7.5 inches Waveshare. The new version looks even better since it has more resolution: 800x480 
https://www.waveshare.com/wiki/7.5inch_e-Paper_HAT

This takes about 4.5/5 seconds to load using ESP8266. In the branch feature/compression there is an ESP32 version supporting zlib (miniz decompression) downloading a compressed BMP image reduces this download time to 900 miliseconds

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates