Domotique et objets connectés à faire soi-même

T-Watch. Créer votre 1er projet ESP32 avec la librairie LilyGoWatch (IDE Arduino ou PlatformIO)

La librairie LilyGoWatch pour l’IDE Arduino est livrée avec une l’ensemble des drivers nécessaires pour faire fonctionner les périphériques des montres et boitiers T-Watch. Dans cet article nous allons apprendre comment créer un projet from scratch (de zéro) sur l’IDE Arduino et PlatformIO.

 

PlatformIO est beaucoup plus performant pour compiler le firmware que l’IDE Arduino, à l’exception de la première compilation. Si vous êtes débutant en programmation, la prise en main de PlatformIO peut être déroutante. Je vous conseille donc par commencer par la lecture de ces quelques articles.

Créer un projet pour la T-Watch 2020 sur l’IDE Arduino

Avant de pouvoir commencer à développer un projet pour votre T-Watch, T-Block ou T-Bot, vous devez installer le SDK Arduino-ESP32 (ESP-IDF). C’est le kit de développement officiel qui contient toutes les librairies et les outils nécessaires pour pouvoir développer du code Arduino pour les micro-contrôleurs ESP32.

Une fois que le SDK est installé, il faut installer manuellement la librairie TTGO pour les T-Watch depuis GitHub.

Installer la librairie TTGO de LilyGo

LilyGo ne propose pas (encore) sa librairie sur le dépôt officiel de l’IDE Arduino. On va donc devoir aller la récupérer sur GitHub en ce allant sur cette page.

1 Cliquer sur Code puis Download ZIP pour télécharger la librairie. Ne compressez pas l’archive ZIP.

2 Aller dans le menu Croquis de l’IDE Arduino puis Ajouter une bibliothèque et enfin Ajouter une librairie .ZIP.

3 Indiquez le chemin vers le fichier ZIP de la librairie que vous venez de télécharger puis valider pour installer la librairie.

Sélectionner la carte ESP32 TTGO T-Watch (tout modèle)

Une fois installé, allez dans le menu Outils -> Carte de développement

Sélectionnez la carte “TTGO T-Watch” dans la section ESP32.

Si la carte n’apparaît pas dans la liste, mettez à jour le SDK ESP32 depuis le menu Outils -> Carte -> Gestionnaire de cartes. Sélectionner la version puis Installer pour mettre à jour.

Créer un nouveau projet T-Watch sur l’IDE Arduino

Créer un nouveau projet, coller le code Arduino suivant et enregistrer le fichier

// Doit être définit avant d'inclure la libraire LilyGoWatch
// De-commenter la ligne correspondant à votre montre LilyGo
#define LILYGO_WATCH_2019_WITH_TOUCH        // T-Watch 2019 with touchscreen
// #define LILYGO_WATCH_2019_NO_TOUCH       // T-Watch2019-N 
// #define LILYGO_WATCH_2020_V1             // T-Watch 2020

#include <LilyGoWatch.h>

// Objet C++ qui permettra d'accéder aux fonctions du boitier
TTGOClass *watch;

void setup() {
    // Récupère l'objet et allume l'écran
    watch = TTGOClass::getWatch();
    watch->begin();     
    watch->openBL();
    
    // On utilise la librairie eTFT pour afficher du texte à l'écran
    watch->tft->fillScreen(TFT_BLACK);
    watch->tft->setTextFont(2);
    watch->tft->setTextSize(2);
    watch->tft->setTextColor(TFT_WHITE);
    watch->tft->setCursor(0, 0);
    watch->tft->println(F("Hello T-Watch"));
}

void loop() {}

Explication du code Arduino ESP32

A l’initialisation de la librairie LilyGoWatch, celle-ci charge les drivers (librairies) des périphériques embarqués sur le Core PCB (accéléromètre, horloge RTC, écran TFT ou e-Paper…)

La librairie LilyGoWatch utilise un système de constantes pour déterminer les librairies qui doivent être chargées à l’initialisation.

Pour éviter de devoir chercher les constantes à activer manuellement en fonction des périphériques embarqués, on dispose d’une constante (détaillées dans ce paragraphe) pour chaque modèle de T-Watch.

La constante définissant le modèle de T-Watch doit être placée avant d’inclure la librairie LilyGoWatch comme ceci

#define LILYGO_WATCH_2019_WITH_TOUCH 
#include <LilyGoWatch.h>

La librairie LilyGoWatch permet d’accéder aux méthodes proposées (du moins celles exposées par les développeurs de LilyGo) des différents périphériques de la montre. Pour cela, on déclare un objet C++ de type TTGOClass.

Il est possible d’utiliser les librairies standards pour ESP32 à la place des celles intégrées
TTGOClass *watch;

Puis on initialise l’objet watch en appelant la méthode getWatch().

watch = TTGOClass::getWatch();

Maintenant, on peut accéder aux fonctions de tous les périphériques.

Par exemple, pour utiliser l’écran TFT de la montre, on commence par initialiser la librairie avec la méthode begin(), puis on allume le rétro-éclairage avec la méthode openBL().

watch->begin();  // Initialise l'écran couleur TFT
watch->openBL(); // Allume le rétro-éclairage de l'écran

Un fork de la librairie SPI_eTFT de Bodmer est intégrée à la librairie LiLyGoWatch. L’écran étant déjà pré-configuré, on peut directement utiliser les fonctionnalités proposées.

Ici on va mettre le fond de l’écran en noir et écrire un simple texte en blanc dans le coin supérieur gauche de l’écran.

watch->tft->fillScreen(TFT_BLACK); 
watch->tft->setTextFont(2); 
watch->tft->setTextSize(2); 
watch->tft->setTextColor(TFT_WHITE); 
watch->tft->setCursor(0, 0); 
watch->tft->println(F("Hello T-Watch"));

Téléverser le projet sur une T-Watch 2020

Voilà, il ne reste plus qu’à téléverser le projet comme n’importe quel autre projet ESP32.

Créer un projet T-Watch sur PlatformIO (VSCode)

Contrairement à l’IDE Arduino, PlatformIO est capable d’aller chercher lui même tout se dont il a besoin sur Internet (SDK, librairies…). Nous allons donc directement passer à la création du projet !

Lisez cet article pour installer et débuter avec PlatformIO rapidement

Depuis le menu PIO, cliquer sur + New project.

Puis

Il est possible d’importer (convertir) un projet (ou un exemple) développé avec l’IDE Arduino. Lisez cet article pour en savoir plus

Contrairement à un projet Arduino classique, un projet PlatformIO adopte une structure particulière ainsi qu’un fichier de configuration platformio.ini situé à la racine

project_dir
├── .pio
|     └─ buid
|     └─ libdeps
├── lib
|     └─ ...
├── includes
|     └─ ...
├── src
|     └─ main.cpp
└── test
|     └─ ...
└── platformio.ini

Le dossier caché .pio contiendra

Le dossier src contiendra le code source du projet. Au minimum un fichier C++ nommé main.cpp. L’équivalent du fichier ino sur l’IDE Arduino.

Lisez cet article pour prendre en main rapidement PlatformIO sur VSCode.

Modifier le fichier du code source main.cpp

L’assistant de création créé un fichier main.cpp dans le dossier scr (source). Ouvrez le puis collez le code suivant

#include Arduino.h
// Select you T-Watch in the platformio.ini file | Sélectionner votre T-Watch dans le fichier platform.io
#include LilyGoWatch.h

// C++ object which will allow access to the functions of the Watch | Objet C++ qui permettra d'accéder aux fonctions du boitier
TTGOClass *watch;

void setup() {
    // Get Watch object and set up the display | Récupère l'objet et allume l'écran
    watch = TTGOClass::getWatch();
    watch->begin();     
    watch->openBL();
    
    // Use eTFT library to display text on screen | On utilise la librairie eTFT pour afficher du texte à l'écran
    watch->tft->fillScreen(TFT_BLACK);
    watch->tft->setTextFont(2);
    watch->tft->setTextSize(2);
    watch->tft->setTextColor(TFT_WHITE);
    watch->tft->setCursor(0, 0);
    watch->tft->println(F("Hello T-Watch"));
}

void loop() {}

Vous pouvez remarquer deux différences par rapport au projet Arduino :

Modifier le fichier de configuration platformio.ini

La configuration proposée par l’assistant de création de projet de PIO ne déclare pas (encore) les librairies à installer.

On va donc devoir le faire manuellement. Pour cela, ouvrez le fichier platformio.ini qui se trouve à la racine du projet et remplacez la configuration par celle-ci :

[env:ttgo-t-watch]
platform = espressif32
board = ttgo-t-watch
framework = arduino
build_flags =
    ;-D LILYGO_WATCH_2019_WITH_TOUCH=1
    ;-D LILYGO_WATCH_2019_NO_TOUCH=1
    -D LILYGO_WATCH_2020_V1=1
lib_deps =
    TTGO TWatch Library
upload_speed = 2000000
monitor_speed = 115200

Enregistrez le fichier. L’installation des librairies débute automatiquement !

Explications

Lisez cet article pour en savoir plus sur le fichier de configuration platformio.ini

Téléverser le projet depuis PlatformIO

Branchez la T-Watch sur un port USB et cliquez sur l’icône en forme de flèche du menu PIO. Le projet et compilé et directement téléversé.

Le temps de compilation est similaire à celui de l’IDE Arduino … la première fois, puis c’est beaucoup plus rapide car PIO ne re-compile que le projet. Testez par vous même, vous ne pourrez plus vous en passer !

Où trouver les exemples installés avec la librairie TTGO ?

L’avantage de l’IDE Arduino et qu’il propose un menu Exemples où il est très facile de retrouver les exemples de codes livrés avec les librairies.

Avec PIO, il suffit d’aller dans le dossier .pio -> libdeps ->ttgo-t-watch -> TTGO T-Watch Library -> examples

Déclarer les accessoires et cartes d’extension pour T-Watch

En fonction du modèle, le Core PCB (l’équivalent de la carte mère d’un ordinateur) d’une T-Watch embarque des périphériques (horloge RTC, accéléromètre, contrôleur d’alimentation, écran eInk ou LCD) et éventuellement une carte d’extension (GPS, GPRS, Lora…).

Lisez cet article pour en savoir plus sur les différents modèles de T-Watch disponibles.

Pour simplifier le développement, on dispose de constantes pour charger les drivers depuis la librairie LilyGoWatch. Inutile donc de connaître les broches de chaque équipement. Tout est pré-configuré.

Les lignes barrées correspondent aux cartes d’extension obsolètes

Uniquement pour la T-Block

Les drivers sont déjà pré-installés et se trouvent dans le dossier src/divers de la librairie. Inutile donc d’installer manuellement les librairies Arduino des périphériques, les développeurs de LilyGo s’occupent de tout. Vous pouvez toutefois utiliser les librairies standards si certaines fonctions sont absentes.

Pour éviter de devoir chercher les constantes à activer manuellement, on dispose d’une constante pour chaque T-Watch. Tout est expliqué au prochain paragraphe.

N’oubliez pas que certaines options sont activées automatiquement en choisissant la T-Watch. Une double déclaration n’entraîne toutefois aucune erreur de compilation et d’exécution du projet Arduino.

Déclarer le type de T-Watch cible

Pour éviter de devoir chercher les constantes à activer manuellement en fonction des périphériques embarqués, on dispose d’une constante pour chaque modèle de T-Watch

Il suffit d’ajouter la constante au début de votre projet ou dans un fichier de configuration séparé pour charger les librairies et démarrer automatiquement les périphériques à la mise sous tension de l’ESP32.

LILYGO_WATCH_BLOCK, T-Block avec écran eInk

Périphériques activés automatiquement

Périphériques non supportés : aucune restriction indiquée

Voir plus d’offres

LILYGO_WATCH_2019_WITH_TOUCH, T-Watch Touch

Périphériques activés automatiquement

Périphériques non supportés

Voir plus d’offres

LILYGO_WATCH_2019_NO_TOUCH, T-Watch-N sans écran tactile

Périphériques activés automatiquement

Périphériques non supportés

Voir plus d’offres

LILYGO_WATCH_2020_V1, version 2020, montre au design Apple Watch

Périphériques activés automatiquement

Périphériques non supportés : toutes les autres options

Voir plus d’offres

LILYGO_WATCH_2020_V2, T-Watch 2020 en cours de développement

Périphériques activés automatiquement

Périphériques non supportés : toutes les autres options

Documentations techniques des périphériques

Avez-vous aimé cet article ?
[Total: 0 Moyenne: 0]
Exit mobile version