T-Watch 2020 : Micropython + LVGL

Lors de mon dernier article sur la twatch, je vous présentais comment installer MicroPython sur la TTGO T-Watch 2020. L’environnement déployé était plutôt “rustique” et ne permettait pas de profiter pleinement des fonctionnalités que propose la T-Watch. Depuis, les choses ont un peu bougé, et il est maintenant possible d’avoir un environnement bien plus développé avec notamment le support de LVGL pour avoir une interfaces graphiques qui dépote.

Qu’est ce que LVGL ?

LVGL est une bibliothèque permettant de facilement créer des interfaces graphiques pour de l’embarqué. Le tout semble plutôt léger et propose tout un tas de widget bien pratique. Par exemple voici le type de rendu que l’on peut avoir :

Exemple d’interface créée avec LVGL

Créer l’image Micropython avec LVGL

Contrairement au dernier article, nous n’allons pas partir du dépot Micropython officiel, mais d’une version modifiée. En effet, Nikita Selin a fait une grosse partie du boulot pour porter proprement la montre avec Micropython et notamment offrir une compatibilité avec LVGL. Nous allons donc partir de son dépôt.

Comme la dernière fois nous allons, préparer notre environnement avec les commandes suivantes :

mkdir twatch-micropython-lvgl && cd twatch-micropython-lvgl
# Téléchargement du code Micropython
git clone https://github.com/OPHoperHPO/lilygo-ttgo-twatch-2020-micropython micropyhon
# Téléchargement du framework de développement Espressif
git clone https://github.com/espressif/esp-idf.git
# Téléchargement de la toolchain ESP32 Xtensa
wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz
tar xzvf xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Maintenant que tout est téléchargé, Il suffit de se rendre dans le dossier lilygo-ttgo-twatch-2020-micropython puis de modifier le fichier makefile présent dans ports/esp32 afin d’y définir les chemins vers ESP-IDF et la toolchain ESP32 Xtensa. Cela evite de se pastiller les variables d’environnement à définir à chaque fois comme c’était le cas précédemment.

Une fois que c’est fait, on prépare l’environnement :

cd micropython
git submodule update --init
make -C mpy-cross

Maintenant, nous pouvons brancher la montre, compiler, puis déployer le firmware:

make -C ports/esp32 deploy

Tester le firmware

Maintenant que nous avons déployer notre firmware, nous allons pouvoir tester si LVGL fonctionne correctement avec le script suivant :

import lvgl as lv
import ttgo

# Init watch
watch = ttgo.Watch()

# Init lvgl
lv.init()
watch.lvgl_begin()

# Enable backlight
watch.tft.backlight_fade(100)


# Init lvgl
lv.init()
watch.lvgl_begin()

# Enable backlight
watch.tft.backlight_fade(100)

# Init interface
scr = lv.obj()
win = lv.win(scr)
win.set_title("TWatch + LVGL")
btn = lv.btn(win)
label = lv.btn(btn)
label.set_text("Hello world")
lv.scr_load(scr)

Si une interface s’affiche, c’est gagné! On va maintenant pouvoir s’amuser avec les différents composant de la montre. Pourquoi pas créer un TVBGone ou outils d’attaque Bluetooth ? ;)

Micropython sur TTGO T-Watch 2020

Il y a quelque temps, j’ai eu l’occasion de me procurer une smartwatch Lilygo T-Watch 2020. Il s’agit d’une montre totalement programmable avec un prix plutôt accessible, aux alentours de 30€. Son principal interêt, c’est les différents composants qu’elle embarque, à savoir :

  • Un chip ESP32
  • Un Module RTC PCF8563 (pour une montre c’est mieux)
  • Un écran LCD tactile
  • Un accéleromètre
  • Un vibreur
  • Un haut-parleur
  • Un emetteur infrarouge
  • Un chip WiFi 802.11 b/g/n
  • Un chip Bluetooth 4.2 et BLE

Du coup, c’est plutôt interessant à bricoler et les possibilités de “hack” sont assez importante. Bien que la montre se programme principalement en C++ à l’aide de l’éditeur Arduino, il semble possible de programmer en Python dessus via MicroPython. Du coup, c’est parti.

Créer l’image Micropython

Avant de pouvoir programmer en python sur la T-Watch, il est tout d’abord nécessaire de déployer un firmware avec Micropython dessus. Comme il n’éxiste pas de firmware officiel, nous allons compiler le notre, y inclure quelques librairies python permettant de jouer avec les composants de la montre et le déployer.

La première étape consiste à télécharger les sources de MicroPython et les différentes dépendances du projet :

mkdir twatch-micropython && cd twatch-micropython
# Téléchargement du code Micropython
git clone https://github.com/micropython/micropython/
# Téléchargement du framework de développement Espressif
git clone https://github.com/espressif/esp-idf.git
export ESPIDF=<PATH_TO_DIRECTORY>/esp-idf
# Téléchargement de la toolchain ESP32 Xtensa
wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz
tar xzvf xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz
export PATH=<PATH_TO_DIRECTORY>/xtensa-esp32-elf/bin:$PATH

# Préparation de l'environnement Micropython
cd micropython
git submodule update --init
make -C mpy-cross

Il est ensuite possible de compiler le firmware avec les commandes suivantes :

make -C ports/esp32 clean
make -C ports/esp32 all

Si tout s’est bien passé, le firmware est présent dans le dossier ports/esp32/build-GENERIC. Nous allons pouvoir le tester.

Tester le firmware

Pour déployer le firmware que nous venons de compiler, il suffit de brancher la T-Watch en USB à l’ordinateur puis d’entrer la commande suivante :

make -C ports/esp32 deploy

Il est ensuite possible de se connecter à un shell interactif python (REPL) via le port USB en série. Par exemple, à l’aide du logiciel picocom :

picocom /dev/ttyUSB0 -b115200

Il est ensuite possible d’entrer un simple code python :

from machine import Pin
buzz=Pin(4,Pin.OUT)

# Faire vibrer la montre
buzz.on()
# Arrêter le vibreur
buzz.off()

Si tout s’est bien passé, nous allons pouvoir passer à la préparation d’un firmware plus spécifique à la T-Watch. Pour quitter picocom, il suffit d’effectuer Ctrl+a Ctrl+x.

Préparer un framework spécifique

Comme nous avons pu le voir, le framework actuel permet d’interagir avec les composants de la montre. Néanmoins, il s’agit d’un environnement basique sans librairies permettant, par exemple, d’interagir facilement avec l’écran LCD ou la puce RTC.

Nous allons donc amener quelques bibliothèques dans notre firmware afin de pouvoir les utiliser sur notre montre. Ce type de bibliothèque est souvent chronophage à développer, heureusement, certains projet sur cette montre commence à pointer le bout de leur nez, c’est par exemple le cas de ce projet dont nous allons récupérer quelques fichiers utiles, à savoir :

Nous allons donc retourner dans nos sources de Micropython et télécharger ces fichiers dans un dossier spécifiques.

cd micropython/ports/esp32/modules
wget https://gitlab.com/mooond/t-watch2020-esp32-with-micropython/-/raw/master/bma423.py
wget https://gitlab.com/mooond/t-watch2020-esp32-with-micropython/-/raw/master/axp202c.py
wget https://gitlab.com/mooond/t-watch2020-esp32-with-micropython/-/raw/master/pcf8563.py
wget https://gitlab.com/mooond/t-watch2020-esp32-with-micropython/-/raw/master/st7789my.py
wget https://gitlab.com/mooond/t-watch2020-esp32-with-micropython/-/raw/master/focaltouch.py

Le dossier modules permet de déposer des bibliothèques écrite en python qui seront intégrées dans notre firmware. Maintenant que c’est fait, nous pouvons recompiler notre firmware et le déployer :

cd micropython/ports/esp32
make all
make deploy

Testons, notre module RTC avec le code suivant :

from machine import Pin,I2C
import pcf8563

i2c = I2C(0,scl=Pin(22), sda=Pin(21))
rtc = pcf8563.PCF8563(i2c)

# Doit renvoyer l'heure actuelle
print(rtc.hours())

# Changement d'heure
rtc.write_all(hours=12)
print(rtc.hours())

Et voilà, il ne reste plus qu’à ajouter quelques autres bibliothèques pour simplifier l’usage de python sur cette montre. Pourquoi pas l’ajout de LVGL pour créer de jolies interfaces ?

Ressources :