Station météo avec LilyGO TTGO T5-4.7 E-Paper

Le LilyGO TTGO T5-4.7 E-Paper est un module de développement intégré qui combine un écran E-paper (encre électronique) de 4,7 pouces avec un microcontrôleur ESP32-S3.

L’écran E-paper de la carte fonctionne avec une résolution de 540 × 960 pixels, offre 16 niveaux de gris et ne consomme de l’énergie que lors des opérations de rafraîchissement, ce qui minimise la consommation pour des données qui changent lentement, comme les données météo.

Dans ce tutoriel, vous apprendrez à démarrer avec la carte LilyGO TTGO T5-4.7 E-Paper. De plus, nous construirons une station météo qui récupère ses données via Internet depuis OpenWeatherMap et les affiche sur l’E-Paper.

Pièces requises

Vous pouvez vous procurer le LilyGO TTGO T5-4.7 E-Paper chez DFRobot ou Amazon via les liens ci-dessous. Si vous souhaitez alimenter l’écran sur batterie, vous aurez également besoin d’une batterie.

Je recommande une batterie rechargeable 18650 avec son support correspondant. Cependant, vous devrez souder les fils du support de batterie au connecteur batterie de l’écran LilyGO E-Paper. Ce n’est pas difficile, mais un fer à souder est nécessaire.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Matériel du LilyGO TTGO T5-4.7 E-Paper

La plateforme LilyGO TTGO T5-4.7 E-Paper est une carte contrôleur d’écran E Ink de 4,7 pouces qui intègre un module ESP32-S3 avec un panneau E-paper en niveaux de gris attaché.

Le design cible des applications bénéficiant d’une information persistante à l’écran et d’une faible consommation moyenne, où le contenu peut rester visible sans rafraîchissement continu. La photo ci-dessous montre le recto et le verso de la carte LilyGO TTGO T5-4.7 E-Paper.

Processeur et sous-système mémoire

La carte est construite autour du module ESP32-S3-WROOM-1-N16R18. Cette configuration offre 16 Mo de flash embarqué pour le firmware et les ressources, ainsi que 8 Mo de PSRAM pour supporter des opérations gourmandes en mémoire comme les buffers graphiques, le rendu de polices et la gestion des données réseau.

L’ESP32-S3 permet aussi la connectivité Wi-Fi et dispose de suffisamment de puissance de calcul pour l’acquisition périodique de données, le traitement local et les mises à jour d’affichage typiques des stations météo.

Caractéristiques de l’écran E-Paper

Le panneau E-paper intégré a une résolution de 540 × 960 pixels en orientation portrait et supporte un rendu en niveaux de gris sur 16 niveaux. L’écran permet un rafraîchissement partiel, avec des mises à jour sélectives de zones pour réduire le temps de rafraîchissement et la consommation d’énergie lorsque seul un sous-ensemble du contenu change.

Cependant, l’écran ne doit pas être rafraîchi partiellement pendant une longue période, sinon des images résiduelles irréversibles apparaîtront !

Entrées utilisateur et contrôles intégrés

L’entrée physique est assurée par trois boutons, dont un bouton personnalisable par l’utilisateur pour des fonctions au niveau de l’application. Les autres boutons sont un reset et un boot.

La carte expose aussi une interface dédiée à 6 broches pour connecter un écran tactile, qui peut être acheté séparément.

Interface d’alimentation par batterie

Pour l’alimentation par batterie, la carte inclut un connecteur PH 2.0 conçu pour une batterie 3,7 V. La protection contre la charge et la décharge est assurée par un circuit intégré de protection HX6610S.

Connecteur d’extension et compatibilité hôte

Un connecteur 40 broches est fourni sur le dessus de la carte et est compatible avec l’interface BUS Raspberry Pi. Voici le brochage du connecteur :

Notez que les interfaces I2C (SDA, SCL) et SPI (MISO, MOSI, CS) sont accessibles ici. La photo ci-dessous montre le brochage des autres connecteurs de la carte :

GPIO

Le tableau suivant liste les broches GPIO et leur usage interne par l’ESP32 intégré. Seules les broches GPIO 45, 10, 48 et 39 sont disponibles pour les applications utilisateur.

GPIO ESP32S3	Connecté à	Libre
13	74HCT4094D CFG_DATA	❌
12	74HCT4094D CFG_CLK	❌
0	74HCT4094D CFG_STR	❌
38	E-paper CKV	❌
40	E-paper STH	❌
41	E-paper CKH	❌
8	E-paper D0	❌
1	E-paper D1	❌
2	E-paper D2	❌
3	E-paper D3	❌
4	E-paper D4	❌
5	E-paper D5	❌
6	E-paper D6	❌
7	E-paper D7	❌
21	Bouton	❌
14	ADC Batterie	❌
16	SD MISO	❌*
15	SD MOSI	❌*
11	SD SCK	❌*
42	SD CS	❌*
18	SDA	❌
17	SCL	❌
47	IRQ TouchPanel	❌
45	Non connecté	✅
10	Non connecté	✅
48	Non connecté	✅
39	Non connecté	✅

Spécifications techniques

Le tableau suivant résume les spécifications techniques de la station météo avec LilyGO TTGO T5-4.7 E-Paper :

MCU	ESP32-S3-WROOM-1-N16R8
Connectivité sans fil	Wi-Fi Bluetooth V5.0
Flash	16 Mo
PSRAM	8 Mo
Support PCF8563 RTC	Détection de capacité batterie
Circuit intégré pilote	EDO47TC1
Taille	4,7 pouces
Niveaux de gris	16
Résolution	540 x 960 pixels
Courant en deep-sleep	~170µA

Le schéma de la carte d’affichage se trouve dans le github repo.

Versions

Notez qu’il existe au moins trois versions différentes du LilyGO TTGO T5-4.7 E-Paper. Il y a une version ancienne avec cinq boutons et un support pour batterie 18650. Voir la photo ci-dessous :

Je ne possède pas cette version et ne peux donc pas vous dire si les exemples de code de ce tutoriel fonctionnent avec cette carte.

Cependant, je possède les cartes des deux versions plus récentes V2.3 de 2021-06-10 et V2.4 de 2024-12-03. J’ai testé le code pour ces deux cartes et il fonctionne. Notez que ces cartes ont trois boutons et pas de support batterie. La photo ci-dessous montre les deux cartes avec leurs numéros de version visibles au dos :

Installation du Core ESP32

Le LilyGO TTGO T5-4.7 utilise un ESP32 et nous devons installer une version spécifique (2.017) du core ESP32. Commencez par ouvrir la boîte de dialogue Préférences en sélectionnant “Preferences…” dans le menu “File”. Cela ouvrira la fenêtre de préférences ci-dessous.

Sous l’onglet Settings, vous trouverez un champ de saisie en bas de la fenêtre intitulé “Additional boards manager URLs“ :

Dans ce champ, copiez l’URL suivante :

https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

Cela permettra à l’IDE Arduino de savoir où trouver les bibliothèques du core ESP32. Ensuite, nous installerons les cartes ESP32 via le Boards Manager.

Ouvrez le Boards Manager via « Tools -> Boards -> Board Manager ». Le gestionnaire de cartes apparaîtra dans la barre latérale gauche. Tapez « ESP32 » dans le champ de recherche en haut et vous verrez deux types de cartes ESP32 : les « Arduino ESP32 Boards » et les cartes « esp32 par Espressif ». Nous voulons les bibliothèques « esp32 par Espressif ».

Dans la liste déroulante pour esp32, sélectionnez la version 2.0.17 puis cliquez sur INSTALL. Après une installation réussie, vous devriez voir l’image suivante :

D’autres versions (plus anciennes) du core ESP32 fonctionnent probablement aussi, mais je ne les ai pas testées. Ce qui ne fonctionne pas pour l’instant, ce sont les versions récentes 3.x.

Installation des bibliothèques

Ensuite, nous devons installer des bibliothèques spécifiques et leurs versions. Cliquez d’abord sur ce EPD47 Library lien de bibliothèque et téléchargez le fichier « EPD47-master.zip ».

Décompressez le fichier ZIP pour en extraire le contenu. Vous devriez voir les fichiers suivants dans un dossier décompressé nommé « EPD47-master » :

Nous devons copier le dossier « EPD47-master » dans le dossier « libraries » de l’IDE Arduino. Sous Windows, le dossier « libraries » se trouve généralement sous :

C:\Users\<username>\OneDrive\Documents\Arduino\libraries

Comme ce dossier contient déjà des bibliothèques installées, je vous recommande de le renommer temporairement, par exemple en « _libraries », et de créer un nouveau dossier nommé « libraries ». Cela évite les conflits avec vos bibliothèques déjà installées et vous ne les perdez pas. Vous pourrez facilement revenir en arrière plus tard. L’image ci-dessous montre à quoi devrait ressembler votre dossier « Arduino » avec les bibliothèques :

Ensuite, copiez le dossier « EPD47-master » dans le nouveau dossier « libraries » comme montré ci-dessous :

Enfin, nous devons installer la version 6.19.0 de la bibliothèque Arduinojson par Benoit Blanchon. Ouvrez le LIBRARY MANAGER, tapez « arduinojson » dans la barre de recherche et installez la bibliothèque. Après une installation réussie, vous devriez voir l’image suivante :

Si vous regardez ensuite dans le dossier des bibliothèques, vous trouverez maintenant la bibliothèque EPD47-master et la bibliothèque ArduinoJson :

Carte ESP32-S3 et réglages

Le LilyGO TTGO T5-4.7 E-Paper utilise un ESP32-S3, nous sélectionnons donc la carte « ESP32S3 Dev Module ». Pour cela, cliquez sur le menu déroulant puis sur « Select other board and port… » :

Cela ouvrira une fenêtre où vous pouvez taper « esp32s3 dev » dans la barre de recherche. Vous verrez la carte « ESP32S3 Dev Module » sous Boards. Cliquez dessus, sélectionnez le port COM pour l’activer, puis cliquez sur OK :

Notez que vous devez connecter la carte via le câble USB à votre ordinateur avant de pouvoir sélectionner un port COM.

Réglages des outils

Avant de pouvoir programmer la carte, vous devez ajuster les réglages. Allez dans « Tools » et sélectionnez les paramètres montrés ci-dessous :

Les réglages importants sont « USB CDC On Boot: Enable » pour permettre la communication série avec la carte, « Flash Size : 16MB(128Mb) », « Partition Scheme: 16M Flash(3M APP/9.9MB FATFS) », et « PSRAM: OPI PSRAM » pour configurer la mémoire. Les autres réglages par défaut conviennent.

Téléversement

En général, vous pouvez maintenant téléverser le code via l’IDE Arduino et la carte passera automatiquement en mode upload. Cependant, si la carte est en deep-sleep ou bloquée dans une boucle de crash, vous pouvez forcer le mode upload avec la séquence suivante :

1. Appuyez et maintenez le bouton BOOT(IO0)
2. Tout en maintenant BOOT(IO0), appuyez sur RST
3. Relâchez RST
4. Relâchez le bouton BOOT(IO0)

Exemple de code : Bouton

Dans ce premier exemple de code, nous vérifions simplement que nous pouvons programmer la carte, détecter une pression sur un bouton et que la communication série fonctionne :

#define BTN 21

void setup() {
  Serial.begin(112500);
  pinMode(BTN, INPUT);
  Serial.println("running...");
}

void loop() {
  if (!digitalRead(BTN)) {
    Serial.println("pressed");
    delay(100);
  }
}

Nous commençons par définir la broche GPIO 21 pour le bouton marqué SENSOP_VN sur la carte.

#define BTN 21

C’est le seul bouton utilisable pour l’entrée utilisateur. Il s’agit du bouton à côté du slot de carte SD :

Dans la fonction setup, nous initialisons la communication série, déclarons la broche du bouton en entrée, et affichons « running… » sur le moniteur série. Le bouton est câblé en interne avec une résistance pullup, donc il n’est pas nécessaire d’activer les pullups en configurant la broche.

void setup() {
  Serial.begin(112500);
  pinMode(BTN, INPUT);
  Serial.println("running...");
}

Dans la fonction loop, nous lisons l’état actuel du bouton et si la valeur retournée est false, cela signifie que le bouton est pressé et nous affichons « pressed » sur le moniteur série.

void loop() {
  if (!digitalRead(BTN)) {
    Serial.println("pressed");
    delay(100);
  }
}

Testez ce code en premier pour vous assurer que vous pouvez programmer la carte et voir la sortie série. En cas de problème, vérifiez que les réglages des outils sont corrects.

Exemple de code : Affichage

Le deuxième exemple montre comment contrôler l’écran E-paper. Nous allons dessiner un cercle et afficher le texte « Makerguides » sur l’écran :

Jetez un œil rapide au code complet puis nous détaillerons son fonctionnement :

#include "epd_driver.h"
#include "firasans.h"

uint8_t *framebuffer = NULL;

void create_framebuffer() {
  size_t framesize = EPD_WIDTH * EPD_HEIGHT / 2;
  framebuffer = (uint8_t *)ps_calloc(sizeof(uint8_t), framesize);
  if (!framebuffer) {
    Serial.println("alloc memory failed !!!");
    return;
  }
  memset(framebuffer, 0xFF, framesize);
}

void init_display() {
  create_framebuffer();
  epd_init();
  epd_poweron();
  epd_clear();
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  init_display();

  epd_draw_circle(EPD_WIDTH / 2, EPD_HEIGHT / 2, 150, 0, framebuffer);
  
  const char *text= "Makerguides";
  int cursor_x = 355;
  int cursor_y = 270;
  writeln((GFXfont *)&FiraSans, text, &cursor_x, &cursor_y, framebuffer);

  epd_draw_grayscale_image(epd_full_screen(), framebuffer);
  epd_poweroff_all();
}

void loop() {
}

Imports

Nous commençons par inclure deux fichiers d’en-tête qui fournissent l’API du pilote d’affichage et une définition de police. « epd_driver.h » expose des fonctions comme l’initialisation, le contrôle d’alimentation, le dessin de primitives, et le transfert d’un buffer de pixels vers le panneau, tandis que « firasans.h » fournit les données de glyphes utilisées par la routine de rendu de texte.

#include "epd_driver.h"
#include "firasans.h"

État global

Ensuite, nous créons un pointeur global nommé framebuffer pour stocker l’adresse d’un buffer de pixels alloué dynamiquement en mémoire. Les fonctions du pilote d’affichage dans ce sketch dessinent d’abord dans ce buffer, puis l’ensemble est envoyé au panneau E-paper pour affichage.

uint8_t *framebuffer = NULL;

create_framebuffer

La fonction create_framebuffer() est responsable de l’allocation de RAM pour l’image en niveaux de gris à afficher. L’idée clé est que le panneau E-paper attend une représentation compacte, et l’expression EPD_WIDTH * EPD_HEIGHT / 2 reflète le nombre d’octets nécessaires quand chaque pixel utilise 4 bits (un demi-octet). Avec 4 bits de gris, deux pixels sont stockés par octet, d’où la division par deux du nombre total de pixels.

Après calcul de la taille, la fonction utilise ps_calloc pour allouer et initialiser la mémoire à zéro. Sur les cibles ESP32, cet allocateur place généralement les gros buffers en PSRAM si disponible, ce qui est important car un buffer complet en niveaux de gris peut être trop grand pour la RAM interne. En cas d’échec, la fonction affiche un message diagnostic sur la console série et retourne prématurément.

Enfin, le buffer est rempli avec 0xFF. Dans de nombreux formats de buffer E-paper, 0xFF correspond à “blanc” ou la valeur la plus claire sur tout le buffer, créant ainsi une toile blanche propre avant tout dessin.

void create_framebuffer() {
  size_t framesize = EPD_WIDTH * EPD_HEIGHT / 2;
  framebuffer = (uint8_t *)ps_calloc(sizeof(uint8_t), framesize);
  if (!framebuffer) {
    Serial.println("alloc memory failed !!!");
    return;
  }
  memset(framebuffer, 0xFF, framesize);
}

init_display

La fonction init_display() centralise la séquence de démarrage du matériel E-paper et s’assure que le buffer existe avant tout dessin. Elle appelle d’abord create_framebuffer() pour que les fonctions de dessin ultérieures aient une destination valide.

L’appel à epd_init() initialise typiquement le contrôleur d’affichage, configure GPIO/SPI, et prépare l’état interne du pilote. epd_poweron() active les rails d’alimentation du panneau et met le matériel en état opérationnel. Et epd_clear() efface le panneau, ce qui est utile sur E-paper car l’ancien contenu peut persister si le panneau n’est pas explicitement rafraîchi.

void init_display() {
  create_framebuffer();
  epd_init();
  epd_poweron();
  epd_clear();
}

setup

La fonction setup() s’exécute une fois au démarrage et réalise tout le travail dans ce sketch, c’est pourquoi loop() est vide. Nous commençons par initialiser le port série à 115200 bauds pour permettre la sortie de debug. Puis nous attendons brièvement pour assurer la stabilité de la connexion série avant de continuer. Ensuite, nous appelons init_display() pour allouer le buffer, alimenter et effacer le panneau.

void setup() {
  Serial.begin(115200);
  delay(1000);
  init_display();

Après l’initialisation, nous dessinons un cercle dans le buffer. Le cercle est centré à l’écran en utilisant la moitié de la largeur et de la hauteur de l’écran. Le rayon est 150, et la valeur de couleur 0 est passée comme niveau de gris. Dans les conventions 4 bits de gris typiques des pilotes E-paper, les valeurs numériques basses correspondent souvent à des pixels plus foncés, donc 0 est généralement utilisé pour le noir. Le dernier argument est framebuffer, ce qui précise que l’opération modifie le buffer mémoire sans mettre à jour immédiatement l’affichage.

  epd_draw_circle(EPD_WIDTH / 2, EPD_HEIGHT / 2, 150, 0, framebuffer);

Ensuite, nous préparons une chaîne C à afficher et positionnons le curseur. L’appel à writeln() dessine la chaîne avec la police FiraSans dans le buffer à la position spécifiée.

  const char *text= "Makerguides";
  int cursor_x = 355;
  int cursor_y = 270;
  writeln((GFXfont *)&FiraSans, text, &cursor_x, &cursor_y, framebuffer);

Une fois le cercle et le texte dessinés en RAM, le sketch effectue la mise à jour réelle de l’écran. L’appel à epd_draw_grayscale_image() envoie le buffer à l’affichage. Le premier argument, epd_full_screen(), indique que la région mise à jour est l’écran entier, ce qui correspond au fait que le sketch prépare un buffer complet. Enfin, epd_poweroff_all() coupe l’alimentation de l’E-paper, car l’écran peut maintenir l’image sans alimentation une fois la mise à jour terminée.

  epd_draw_grayscale_image(epd_full_screen(), framebuffer);
  epd_poweroff_all();
}

loop

La fonction loop() est vide car le sketch est conçu pour un rendu unique. L’appareil s’initialise, dessine dans le buffer, met à jour l’écran une fois, coupe l’alimentation du panneau, puis ne fait plus rien. Ce schéma est typique des projets E-paper alimentés par batterie qui se réveillent, rafraîchissent le contenu, puis retournent en deep-sleep.

Plus d’exemples

Pour plus d’exemples, par exemple comment dessiner des lignes, rectangles et images en niveaux de gris, consultez le dossier sous Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3/examples.

Exemple de code : Station météo

Dans ce dernier exemple, vous apprendrez à faire fonctionner une station météo sur le LilyGO TTGO T5-4.7 E-Paper. Les données météo sont reçues via Internet depuis le service OpenWeatherMap, qui est gratuit mais nécessite une inscription – plus d’informations plus tard.

Le code original que j’utilise ici est de David Bird de 2021 et différentes versions de ce code se trouvent par exemple à Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3, Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display et DzikuVx/LilyGo-EPD-4-7-OWM-Weather-Display. Cependant, aucun de ces exemples ne fonctionnait bien sur mon LilyGO TTGO T5-4.7 E-Paper. J’ai donc fait quelques modifications.

Modifications

D’abord, j’ai corrigé des problèmes de mise en page des données météo affichées. Si vous regardez l’affichage suivant créé par le code original, vous verrez que le texte des températures n’est pas bien aligné :

J’ai donc déplacé un peu les éléments de texte pour améliorer la mise en page :

J’ai aussi intégré l’image de la lune et les icônes de coucher et lever de soleil du DzikuVx/LilyGo-EPD-4-7-OWM-Weather-Display dans le code Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display.

Charge de la batterie

Ensuite, j’ai remarqué que l’affichage ne fonctionne pas et que l’icône de charge de batterie ne s’affiche pas quand la carte est alimentée par batterie. Cela vient de 1) un blocage du code original jusqu’à ce que la communication série soit établie, ce qui ne se produit pas sans connexion USB à un ordinateur :

    Serial.begin(115200);
    while (!Serial) ;

Le code while (!Serial) doit être supprimé et remplacé par un court délai, par exemple delay(1000).

2) Le code original lit la tension batterie sur la broche 36, mais pour mes écrans, la tension batterie est mesurée sur la broche 14 :

float voltage = analogRead(14) / 4096.0 * 6.566 * (vref / 1000.0);

Avec ces modifications, vous pouvez alimenter votre LilyGO TTGO T5-4.7 E-Paper sur batterie et l’icône de batterie vous indiquera le niveau de charge restant.

Localisation de la ville

Le code original utilise le nom d’une ville pour récupérer les informations météo de cet endroit. Cependant, le service OpenWeatherMap permet aussi de récupérer les données météo actuelles pour une localisation donnée par sa latitude et sa longitude :

https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={API key}

Cela peut être plus précis et vous n’êtes pas obligé d’utiliser un nom de ville spécifique reconnu par OpenWeatherMap. Trouver la latitude et la longitude de votre emplacement est facile. Allez sur Google Maps et faites un clic droit. Une fenêtre popup apparaîtra avec les coordonnées latitude et longitude en haut. Voir la capture d’écran suivante :

Connexion USB

Enfin, le code original met à jour les données météo sur l’écran une fois par heure et passe en mode deep-sleep entre les mises à jour pour économiser la batterie. C’est très bien, mais cela complique les modifications de code, car la connexion USB est perdue en deep-sleep et vous ne pouvez pas flasher la carte.

Vous devez réinitialiser la carte et temporiser pour que le flashage commence alors que la connexion USB est encore active juste après le reset. Voir la section Upload ci-dessus. Comme c’est difficile, j’ai ajouté un code qui empêche l’entrée en deep-sleep quand le bouton programmable utilisateur SENSOP_VN est pressé :

  if(digitalRead(21)) {  // SENSOP_VN button NOT pressed
    BeginSleep();
  }

Cela signifie que si vous voulez flasher un nouveau code, il suffit d’appuyer et maintenir SENSOP_VN pendant le flashage. La carte ne passera pas en deep-sleep après le reset et la connexion USB restera active. Une fois flashée, vous pouvez simplement appuyer à nouveau sur RST pour redémarrer la carte avec le deep-sleep activé.

Open weather map

Le code utilise le service gratuit OpenWeatherMap pour recevoir les données météo depuis Internet. Cependant, avant de pouvoir utiliser les API OpenWeather, vous avez besoin d’une clé API et pour cela d’un compte. Pour créer un compte gratuit, allez sur le site sign-up page et saisissez vos informations.

Ensuite, allez sur la page de création de clé API api-key et créez une clé API. La clé API est cette longue chaîne « sdfd87fakeby6apikeysf4z » que vous voyez dans la capture d’écran ci-dessous. Votre clé sera différente.

Une fois que vous avez votre clé API (et la latitude et longitude de votre emplacement), vous pouvez la tester dans votre navigateur. Entrez l’URL suivante, avec votre clé API, dans votre navigateur :

https://api.openweathermap.org/data/2.5/weather?lat=44.34&lon=10.99&appid={API key}

Notez que le navigateur Chrome dispose d’un bouton Pretty Print que vous pouvez cliquer pour afficher les données météo récupérées en JSON bien formaté :

Ainsi, vous pouvez tester votre clé API et vos valeurs de latitude et longitude. Si vous avez besoin d’aide, consultez notre tutoriel : Simple ESP32 Internet Weather Station.

Télécharger le code et configurer les paramètres

Une fois votre clé API vérifiée, vous pouvez télécharger le code de la station météo au format ZIP : weather_lilygo_t5_epd.zip . Décompressez-le et ouvrez le fichier « weather_lilygo_t5_epd.ino » dans le dossier « weather_lilygo_t5_epd » avec votre IDE Arduino.

En dernier lieu, vous devez configurer les identifiants Wi-Fi et les paramètres météo. Cliquez sur l’onglet « owm_credentials.h » et renseignez votre SSID, mot de passe, clé API et les informations de localisation :

Selon votre emplacement, vous pouvez aussi modifier les paramètres Langue, Hémisphère, Unités et Fuseau horaire.

Il existe aussi un exemple de code pour configurer la station météo via une interface web : Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display/tree/web, si vous préférez cela plutôt que de coder en dur les réglages.

Une fois les réglages ajustés, flashez le code sur votre LilyGO TTGO T5-4.7 et après un court clignotement, vous devriez voir les données météo apparaître à l’écran :

Connexion de la batterie 18650

La carte LilyGO TTGO T5-4.7 E-Paper est équipée d’un connecteur et d’un circuit de charge pour une batterie LiPo externe. J’ai connecté une batterie rechargeable 18650. Vous pouvez aussi utiliser une batterie LiPo plus petite (plate), mais elles sont souvent plus chères ou ont moins de capacité. La photo ci-dessous montre comment connecter la batterie 18650 :

Autonomie

Une batterie 18650 typique a une capacité de 2300 à 3600mAh et le courant de pointe que l’ESP32 tire en Wi-Fi peut atteindre 400mA. Le courant en deep-sleep de la carte LilyGO TTGO T5-4.7 est apparemment autour de 170µA, mais je ne l’ai pas mesuré.

Si on utilise une 18650 de 3300mAh, et qu’on active le Wi-Fi une seconde toutes les heures pour télécharger les données météo, on obtient une autonomie estimée de plus d’un an sur une charge.

Voici le calcul : avec un courant moyen de 400mA × 1s / 3600s = 0,111mA pour le Wi-Fi et un courant en deep-sleep de 0,17mA, le courant moyen total est 0,111mA + 0,17mA = 0,281mA. Avec une batterie de 3300mAh, l’autonomie estimée est donc 3300mAh / 0,281mA ≈ 11744h ≈ 1,34 ans.

Conclusions

Dans ce tutoriel, vous avez appris à construire une station météo avec l’écran LilyGO TTGO T5-4.7 E-Paper. Pour plus d’informations sur le LilyGO TTGO T5, consultez le Wiki et les exemples de code à Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3/examples.

La documentation mentionne que l’écran ne doit pas être rafraîchi partiellement pendant longtemps, car cela laisse des images résiduelles irréversibles. Soyez donc prudent lors de la création d’applications utilisant Partial Refresh.

Pour plus d’exemples sur les écrans E-paper, consultez nos Weather Station on e-Paper Display, Simple ESP32 Internet Weather Station, Temperature Plotter on e-Paper Display, Monthly Calendar on E-Paper Display et Digital Clock on e-Paper Display tutoriels.

Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.

Bon bricolage 😉