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

  • 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.

  • CALE TFT Firmware is ready to be tested

    Martin Fasani04/24/2020 at 11:43 1 comment

    You can download the right repository here:
    https://cale.es/firmware-tft

    This example Firmware does provides three things only:

    • A way to download a JPG image from an external URL into ESP32
    • An interpreter that reads this jpeg image and prepares a Buffer for the display (based on JPEGDecoder library examples)
    • An authorization Token to make sure you don't need to leave your Calendar events open to the world (Bearer token)

    Proof-of-concept video: 

    https://twitter.com/martinfasani/status/1253594911204655104

    Half loading image bug has been solved. The problem is that sometimes in ESP32 WiFiClient the client.available() returns false and stops downloading. Circumvented it with an incremental counter. If you have a better idea just leave your comments

  • Register and get a 3D-Printed housing for your CALE

    Martin Fasani04/21/2020 at 08:53 0 comments

    We are offering to 3D-Print a T5S case for free just register in CALE.es

    We will pay the shipping cost but only for Europe but if you live outside EU I will ask just to cover the difference to your area. This it how it looks the case when assembled:

    CALE project has been sponsored by makers store digitspace.com

  • Announcing the Bluetooth Firmware + Android app the default configuration

    Martin Fasani04/13/2020 at 08:24 0 comments

    The master branch of the eink-calendar github repository now defaults to Bluetooth configuration sent over Bluetooth by an Android app.

    Please read more about how the process goes here: 

    https://cale.es/firmware-bluetooth

    It basically sends all configuration needed to the ESP32, screen URL and WiFi configuration, to the ESP32 in an easy step after scanning a QR code to list your screens in the App. This Android app and Bluetooth configuration that works in a few clicks is for us the state-of-the-art configuration for IoT devices.

    No WiFi managers, no hardcoded C config, just send your Firmware the config per Bluetooth and let it restart and do it's job. This will allow us to ship pre-assembled displays withouth the need to have the user installing compiling tools on his computer and ultimately leating CALE be used by a broad amount of non-technical people that just wants it's functionality but not it's complexity.

    CALE project has been sponsored by makers store digitspace.com

  • Adding service times and an internal API

    Martin Fasani04/09/2020 at 12:01 0 comments

    At CALE we are implementing this weekend a very fast and reliable API with the mission to serve content to the new CALE Android app, that is already published in Google play store, but I'm making the last updates for a more user friendly release in the next days

    1. Service times
      With this feature we will be able to check if the display needs to be
      updated on every wakeup. For exanple defining Monday -> Friday from 8 to 17:59 Hrs it will update the display only when it wakes up between this service times. How is done?  The firmware will ping the new CALE API with their screen_id and the API will respond with a single byte: 0  or  1, when is 1 the refresh will take place Firmware update will be released on the weekend. This will enable us not only to make battery lifetime longer but also to spare API calls since not all the APIs are free (I use for example AWS Cloudwatch and it costs around 3 dollars per month)
    2.  Mobile API
      Just for a preview, after login enter in: cale.es and preview the QR code. The idea is to enable the CALE App to scan this code and then the Android App will be connected to CALE. Planning to list screens, logs, and of course send send Screen configurations with one click, without need to copy/paste from the website

    Please note that we are also offering to print T5S board housings for free if you register in CALE.es

    CALE project has been sponsored by makers store digitspace.com

  • Bluetooth configuration is ready to be tested

    Martin Fasani04/02/2020 at 12:56 0 comments

    After about one week of work and 3 public repositories being updated: 


    1. CALE app | 2. C++ Firmware (cale_ble branch) | 3. CALE Webservice

    I managed to get first Bluetooth app and Firmware working together. The idea is the config will be simplified to copying one JSON string only that will contain at the same time: 

    1. WiFi SSID + Password 1
    2. WiFi SSID + Password 2
    3. Screen URL
    4. Bearer token

    This will be sent to the Firmware per Bluetooth (Only ESP32 of course since ESP8266 does not have Bluetooth)

    And it will save it on Preferences, restart, and Voila! Your display should refresh with the Screen URL and go to sleep until next refresh.

    Now we would like to invite the project followers to try it. And of course if you have fellow hackers that like EINK displays, please give them a hint and invite them to test CALE.es

    CALE project has been sponsored by makers store digitspace.com

  • A Firmware for the awesome ESP32 TyniPICO

    Martin Fasani03/24/2020 at 06:01 0 comments

    Since Unexpected Maker’s tiny ESP32 project saw the light a few months ago I’ve been a great fan of it. Not only because it’s the makers dream ESP32, packed with a DotStar Neopixel and a very small mini design, but mostly because it beats many other boards out of there regarding low consumption. Optimizing it the best we could and following the authors library helpers we managed to get a 0.08 mA deepsleep. Please check this branch to try it out: 

    https://github.com/martinberlin/eink-calendar/tree/cale_tinypico

    Please note that we are also offering to print T5S board housings for free if you register in CALE.es

    CALE project has been sponsored by makers store digitspace.com

View all 23 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