QT Py CH32V203 eInk / ePaper Daily Calendar and Clock

by Liz Clark

published October 15, 2024, last edited January 22, 2025

posted in Arduino Compatibles LCDs & Displays/ eInk / ePaper Breakout Boards/ Clocks Breakout Boards/ LCDs, LEDs, & Displays STEMMA

Save Download

Intermediate

Project guide

Overview

Love daily calendars but cringe at the 365 pages of paper waste? This project lets you have a smol electronic version. You'll use a CH32V203 QT Py with an EYESPI BFF to display the date and time on an eInk display. The time is kept with a DS3231 STEMMA real-time clock breakout. Even though the CH32V203 QT Py is for more advanced users, it still plays well with the BFF breakout buddies.

The 3D printed stand has a little hook that lets you sandwich the QT Py and the BFF so that they are secured behind the display.

About the CH32V203 QT Py

The CH32V203 QT Py features the powerful CH32V203 low-cost processor that's all the trend: based on RISC-V and cheaper than an 8-bit core! However, it is best used by folks comfortable with having to use Makefiles, clone git repositories, edit configuration files, etc., re. not great for beginners. If none of this scares you though, check out the Learn Guide before heading into this project to get a little more familiar with the ins and outs of this tiny but mighty board.

Adafruit QT Py CH32V203

By Liz Clark

Overview

View Guide

Parts

Angled shot of black, square-shaped microcontroller with castellated pads.

Adafruit QT Py CH32V203 Dev Board with STEMMA QT

What a cutie pie! Or is it... a QT Py? This diminutive dev board features the powerful CH32V203 low-cost processor that's all the trend: based on RISC-V and cheaper than an...

guides with product

$4.95

In Stock

Add to Cart

Adafruit EYESPI BFF for QT Py or Xiao - 18 Pin FPC Connector

Our QT Py boards are a great way to make very small microcontroller projects that pack a ton of power - and now we have a way for you to add a small, colorful, and bright display to...

guides with product

$3.95

In Stock

Add to Cart

Front of E-Ink display with monochrome graphic and "1.54 inch E-Ink Monochrome" text

Adafruit 1.54" Monochrome eInk / ePaper Display with SRAM

Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add an eInk display. Chances are you've seen one of those new-fangled...

guides with product

Out of Stock

Adafruit DS3231 Precision RTC - STEMMA QT

The datasheet for the DS3231 explains that this part is an "Extremely Accurate I²C-Integrated RTC/TCXO/Crystal". And, hey, it does exactly...

guides with product

$13.95

In Stock

Add to Cart

EYESPI Cable - 18 Pin 100mm long Flex PCB (FPC) A-B type

Connect this to that when a 18-pin FPC connector is needed. This 25 cm long cable is made of a flexible PCB. It's A-B style which means that pin one on one side will match...

$0.95

In Stock

Add to Cart

STEMMA QT / Qwiic JST SH 4-Pin Cable - 50mm Long

This 4-wire cable is 50mm / 1.9" long and fitted with JST SH female 4-pin connectors on both ends. Compared with the chunkier JST PH these are 1mm pitch instead of 2mm, but...

Out of Stock

1 x USB C Cable

USB A to USB C Cable - 1 meter long

Out of Stock

1 x M2.5 Screws

Screw and Stand-off Set – M2.5 Thread

Add to Cart

1 x Socket Headers

20-pin 0.1" - Rainbow Color Mix - 5 pack

Add to Cart

1 x Plug Headers

Break-away 0.1" 36-pin - Rainbow Combo 10 Pack

Add to Cart

Page last edited October 15, 2024

Text editor powered by tinymce.

Circuit Diagram

You'll plug a CH32V203 QT Py into an EYESPI BFF breakout board.

The eInk display plugs into the EYESPI BFF with an EYESPI cable.

The DS3231 RTC breakout connects to the QT Py with a STEMMA QT cable.

Page last edited October 15, 2024

Text editor powered by tinymce.

3D Printing

You can 3D print a stand for this project. The stand has mounting holes for the parts and lets the display sit at a jaunty angle.

The STL file can be downloaded directly here or from Printables.

CH32V203 eInk Calendar Stand STL

Printables Download

The stand has a hook that lets you sandwich the QT Py and the BFF for mounting. You should print the model with some supports for the display cutout.

Page last edited October 15, 2024

Text editor powered by tinymce.

Arduino IDE Setup

You've seen the warnings that you definitely can't use this QT Py with CircuitPython or MicroPython. What you can do though is use the arduino_core_ch32 board support package to write code in the Arduino IDE.

Support for the CH32V203 in the Arduino IDE is very new and Adafruit has contributed some changes to make interfacing with the QT Py easier. As a result, the steps on this page are more involved than what you may be used to when setting up the Arduino IDE for a new development board.

Install Arduino IDE

The first thing you will need to do is to download the latest release of the Arduino IDE. You will need to be using version 1.8 or higher for this guide.

Arduino IDE Download

Install the arduino_core_ch32 Board Support Package

After you have downloaded and installed the latest version of Arduino IDE, you will need to start the IDE and navigate to the Preferences menu. You can access it from the File menu in Windows or Linux, or the Arduino menu on OS X.

A dialog will pop up just like the one shown below.

We will be adding a URL to the new Additional Boards Manager URLs option. The list of URLs is comma separated, and you will only have to add each URL once. New Adafruit boards and updates to existing boards will automatically be picked up by the Board Manager each time it is opened. The URLs point to index files that the Board Manager uses to build the list of available & installed boards.

To find the most up to date list of URLs you can add, you can visit the list of third party board URLs on the Arduino IDE wiki. We will only need to add one URL to the IDE in this example, but you can add multiple URLS by separating them with commas. Copy and paste the link below into the Additional Boards Manager URLs option in the Arduino IDE preferences.

Download File

Copy Code

https://github.com/openwch/board_manager_files/raw/main/package_ch32v_index.json

https://github.com/openwch/board_manager_files/raw/main/package_ch32v_index.json

If you have multiple boards you want to support, say ESP8266 and Adafruit, have both URLs in the text box separated by a comma (,)

Once done click OK to save the new preference settings.

Installation Prerequisites

Before you install the board support package via the Arduino IDE, make sure to check the toolchain prerequisites for your operating system in the board support package repository. It's very important that you follow the steps listed in the README before installing the board support package in the Arduino IDE.

Follow the steps listed in the GitHub README for your operating system before installing the board support package in the Arduino IDE.

Install with the Board Manager

The next step is to actually install the Board Support Package (BSP). Go to the Tools → Board → Boards Manager submenu. A dialog should come up with various BSPs. Search for ch32.

Click the Install button and wait for it to finish. Once it is finished, you can close the dialog. This takes care of installing all of the backend dependencies and toolchain for the WCH chips.

Install the Adafruit TinyUSB Arduino Library

A lot of effort and time has been put into updating the TinyUSB Arduino library to support the CH32V203 QT Py. These updates allow you to upload code easily to the QT Py over USB. You'll need to install version 3.3.3 or newer to use these changes.

Version 3.3.3 or newer of the Arduino TinyUSB Library is required to properly interface with the QT Py

Click the Manage Libraries ... menu item, search for Adafruit TinyUSB, and select the Adafruit TinyUSB library:

If asked about dependencies, click "Install all".

If the "Dependencies" window does not come up, then you already have the dependencies installed.

Manually Install the arduino_core_ch32 Board Support Package

A pull request was recently merged to the CH32 board support package to add a board definition for the QT Py CH32V203. Until a new release is made, you'll want to manually install the board support package to get these newest features. To do this, you'll need to git clone the repository into the hardware folder inside of your Arduino folder in your filesystem.

You can do this using the GitHub Desktop app or by using git in the terminal:

Copy Text

cd /path/to/Arduino/hardware
git clone https://github.com/openwch/arduino_core_ch32.git

cd /path/to/Arduino/hardware
git clone https://github.com/openwch/arduino_core_ch32.git

There is one final step to have the manual installation of the board support package appear in the Arduino IDE. Navigate to the arduino_core_ch32 folder inside of the hardware folder. You'll need to create a new folder called WCH. Move the contents of the arduino_core_ch32 folder that you just cloned into that WCH folder.

Your new folder hierarchy should be Arduino/hardware/arduino_core_ch32/WCH

You may need to update the Adafruit TinyUSB submodule that came with the git clone by doing this:

Copy Text

cd /path/to/Arduino/hardware/arduino_core_ch23/WCH
git submodule update --init

cd /path/to/Arduino/hardware/arduino_core_ch23/WCH
git submodule update --init

Restart the Arduino IDE to be sure that it grabs the forked board support package in the hardware folder.

Code Upload Options

In the Tools → Board submenu you should see CH32V EVT Boards Support (in sketchbook). This is the manual installation that you just cloned into your hardware folder.

Under Board, select CH32V20x.

Under Board Select, select Adafruit QTPy CH32V203G6. Under USB Support, select Adafruit TinyUSB with USBD. These settings will work with the CH32V203 QT Py.

If you're not able to upload to the board, you may need to 'manually' put it into bootloader mode and use the WCHISP tool. Check this page https://learn.adafruit.com/adafruit-qt-py-ch32v203/bootloader-mode

Page last edited October 15, 2024

Text editor powered by tinymce.

Code the Calendar

The CH32V203 QT Py has Arduino support, which means that you can use the Arduino libraries that you know and love for your projects. You can either compile the code with the Arduino IDE after installing the necessary libraries or upload the precompiled .BIN file with the WCHISP tool.

Arduino IDE - Install the Libraries

You can install the libraries for this project using the Library Manager in the Arduino IDE.

Click the Manage Libraries... menu item, search for Adafruit EPD, and select the Adafruit EPD library:

If asked about dependencies, click "Install all".

Then install the RTC library. Click the Manage Libraries... menu item again, search for RTClib, and select the RTClib library fork by Adafruit:

Code

Download File

Copy Code

// SPDX-FileCopyrightText: 2024 Liz Clark for Adafruit Industries
//
// SPDX-License-Identifier: MIT

#include <Arduino.h>
#include <SPI.h>
#include "Adafruit_TinyUSB.h"
#include "Adafruit_ThinkInk.h"
#include "RTClib.h"
#include <Wire.h>
#include <Fonts/FreeSans24pt7b.h>
#include <Fonts/FreeSans18pt7b.h>
#include <Fonts/FreeSans12pt7b.h>

#define EPD_DC PA3
#define EPD_CS PA2
#define EPD_BUSY -1 // can set to -1 to not use a pin (will wait a fixed delay)
#define SRAM_CS PA1
#define EPD_RESET -1  // can set to -1 and share with microcontroller Reset!
#define EPD_SPI &SPI // primary SPI

// 1.54" Monochrome displays with 200x200 pixels and SSD1681 chipset
ThinkInk_154_Mono_D67 display(EPD_DC, EPD_RESET, EPD_CS, SRAM_CS, EPD_BUSY, EPD_SPI);

RTC_DS3231 rtc;

char daysOfTheWeek[7][4] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
char monthsOfYear[13][4] = {"NULL", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};

bool start = true;

String lastTimeStr = "00:00";

void setup() {
  Serial.begin(115200);

  /*while (!Serial) {
    delay(10);
  }*/
  Serial.println("eInk Calendar & Clock with CH32V203");
  SPI.begin();
  Serial.println("SPI started");
  pinMode(EPD_CS, OUTPUT);
  digitalWrite(EPD_CS, HIGH);

  Wire.begin();
  Serial.println("Wire started");
  Serial.println("starting display, might take a bit..");
  display.begin(THINKINK_MONO);
  Serial.println("display started");

  while (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    delay(10);
  }
}

void loop() {
    Serial.println("we did it!");
    DateTime now = rtc.now();
    Serial.println("read rtc");
    char timeChar[6];
    sprintf(timeChar, "%02d:%02d", now.hour(), now.minute());
    String timeStr = String(timeChar);
    String monthStr = monthsOfYear[now.month()];
    String dateStr = String(now.day());
    String yearStr = String(now.year());
    String dayOfWeekStr = daysOfTheWeek[now.dayOfTheWeek()];
    Serial.println(timeStr);
    int16_t x1, y1;
    uint16_t w, h;
    if (lastTimeStr != timeStr) {
      display.clearBuffer();
      display.fillRect(0, 0, 200, 60, EPD_BLACK);
      display.drawRect(0, 0, 200, 170, EPD_BLACK);
      display.setTextColor(EPD_WHITE);
      display.setFont(&FreeSans24pt7b);
      display.getTextBounds(dayOfWeekStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (60 - h) / 2 + h);
      display.println(dayOfWeekStr);
      display.setTextColor(EPD_BLACK);
      display.getTextBounds(dateStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (170 - h) / 2 + h + 28);
      display.println(dateStr);
      display.setFont(&FreeSans18pt7b);
      display.getTextBounds(monthStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (60 + h) + 3);
      display.println(monthStr);
      display.getTextBounds(yearStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (170 - h) - 5 + h);
      display.println(yearStr);
      display.setFont(&FreeSans12pt7b);
      display.getTextBounds(timeStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (200 - h) - 5 + h);
      display.println(timeStr);
      display.display();
      lastTimeStr = timeStr;
    }
    delay(30000);
}

// SPDX-FileCopyrightText: 2024 Liz Clark for Adafruit Industries
//
// SPDX-License-Identifier: MIT

#include <Arduino.h>
#include <SPI.h>
#include "Adafruit_TinyUSB.h"
#include "Adafruit_ThinkInk.h"
#include "RTClib.h"
#include <Wire.h>
#include <Fonts/FreeSans24pt7b.h>
#include <Fonts/FreeSans18pt7b.h>
#include <Fonts/FreeSans12pt7b.h>

#define EPD_DC PA3
#define EPD_CS PA2
#define EPD_BUSY -1 // can set to -1 to not use a pin (will wait a fixed delay)
#define SRAM_CS PA1
#define EPD_RESET -1  // can set to -1 and share with microcontroller Reset!
#define EPD_SPI &SPI // primary SPI

// 1.54" Monochrome displays with 200x200 pixels and SSD1681 chipset
ThinkInk_154_Mono_D67 display(EPD_DC, EPD_RESET, EPD_CS, SRAM_CS, EPD_BUSY, EPD_SPI);

RTC_DS3231 rtc;

char daysOfTheWeek[7][4] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
char monthsOfYear[13][4] = {"NULL", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};

bool start = true;

String lastTimeStr = "00:00";

void setup() {
  Serial.begin(115200);

  /*while (!Serial) {
    delay(10);
  }*/
  Serial.println("eInk Calendar & Clock with CH32V203");
  SPI.begin();
  Serial.println("SPI started");
  pinMode(EPD_CS, OUTPUT);
  digitalWrite(EPD_CS, HIGH);

  Wire.begin();
  Serial.println("Wire started");
  Serial.println("starting display, might take a bit..");
  display.begin(THINKINK_MONO);
  Serial.println("display started");

  while (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    delay(10);
  }
}

void loop() {
    Serial.println("we did it!");
    DateTime now = rtc.now();
    Serial.println("read rtc");
    char timeChar[6];
    sprintf(timeChar, "%02d:%02d", now.hour(), now.minute());
    String timeStr = String(timeChar);
    String monthStr = monthsOfYear[now.month()];
    String dateStr = String(now.day());
    String yearStr = String(now.year());
    String dayOfWeekStr = daysOfTheWeek[now.dayOfTheWeek()];
    Serial.println(timeStr);
    int16_t x1, y1;
    uint16_t w, h;
    if (lastTimeStr != timeStr) {
      display.clearBuffer();
      display.fillRect(0, 0, 200, 60, EPD_BLACK);
      display.drawRect(0, 0, 200, 170, EPD_BLACK);
      display.setTextColor(EPD_WHITE);
      display.setFont(&FreeSans24pt7b);
      display.getTextBounds(dayOfWeekStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (60 - h) / 2 + h);
      display.println(dayOfWeekStr);
      display.setTextColor(EPD_BLACK);
      display.getTextBounds(dateStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (170 - h) / 2 + h + 28);
      display.println(dateStr);
      display.setFont(&FreeSans18pt7b);
      display.getTextBounds(monthStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (60 + h) + 3);
      display.println(monthStr);
      display.getTextBounds(yearStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (170 - h) - 5 + h);
      display.println(yearStr);
      display.setFont(&FreeSans12pt7b);
      display.getTextBounds(timeStr.c_str(), 0, 0, &x1, &y1, &w, &h);
      display.setCursor((200 - w) / 2, (200 - h) - 5 + h);
      display.println(timeStr);
      display.display();
      lastTimeStr = timeStr;
    }
    delay(30000);
}

Upload the sketch to your board. The QT Py will initialize the RTC and eInk display. In the loop, the RTC will be read and the eInk display will be updated when the time has changed.

If you need to set the time on your RTC breakout, check out the DS3231 Learn Guide.

Adafruit DS3231 Precision RTC Breakout

By lady ada

Arduino Usage

View Guide

BIN File

If you prefer to skip the Arduino IDE, you can upload the precompiled .BIN file to your board with the WCHISP command line tool. The .BIN file is available for download below. If you aren't familiar with the WCHISP tool, there is a page available in the CH32V203 Learn Guide.

CH32V203-eInk-Calendar-Clock.bin

Adafruit QT Py CH32V203

By Liz Clark

Using WCHISP Tool

View Guide

Page last edited October 15, 2024

Text editor powered by tinymce.

Assembly

Solder socket headers to the EYESPI BFF. Solder plug headers to the QT Py.

Plug in the RTC breakout to the QT Py using a STEMMA QT cable.

Insert an EYESPI cable into the eInk display.

Attach the eInk display to the mounting holes on the 3D printed stand using M2.5 stand-offs and screws. Make sure to run the EYESPI cable through the display cutout.

Plug the EYESPI cable into the EYESPI BFF.

Plug the QT Py into the EYESPI BFF so that the 3D printed hook is sandwiched between them. Make sure that the QT Py USB port is above the BFF EYESPI connector.