Dans mon article précédent, je vous présentai la carte LILYGO T-Display. Je vous présente ici sa grande sœur, la LILYGO T-Display S3. Cette carte de développement basée sur un microcontrôleur ESP32-S3 est équipée d’un écran LCD de 1.9″ offrant une résolution de 170 x 320 pixels.

Voici un rapide comparatif entre ces deux cartes :

Schéma des broches

Voici la schéma des broches de la carte, qui met en évidence les broches utilisées la communication parallèle avec l’écran ST7789 (LCD_D0 à LCD_D7, LCD_WR et LCD_RD). La commande du rétroéclairage est contrôlée via la broche LCD_BL (GPIO38) et l’allumage de l’écran est contrôlé par la broche LCD_Power_On (GPIO15).

Installation du gestionnaire de cartes ESP32

La carte étant basé sur le microcontrôleur ESP32 il faut installer le support des cartes Espressif ESP32 dans l’IDE Arduino.

Dans le menu préférences de l’IDE Arduino, ajoutez l’URL suivante dans le gestionnaire de carte :

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

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

Voici une capture d’écran des étapes à suivre :

Installez le paquet de gestion de cartes esp32 de Espressif Systems.

Une fois le gestionnaire de cartes installé, sélectionnez la carte ESP32S3 Dev Module dans la liste des cartes esp32 disponibles, et appliquer cette configuration :

Note : avec la configuration Lilygo T-Display S3, la PSRAM ne semble pas correctement configurée.

Installation des librairies pour l’écran LCD

Installer la librairie TFT_eSPI by Bodmer.

Éditer le fichier User_Setup_Select.h qui se trouve dans le sous-répertoire Librairies du répertoire Arduino, et appliquer les modifications suivantes :

Commenter la ligne suivante :

//#include <User_Setup.h>           // Default setup is root library folder

//#include <User_Setup.h>           // Default setup is root library folder

Et dé-commenter la ligne suivante :

#include <User_Setups/Setup206_LilyGo_T_Display_S3.h>     // For the LilyGo T-Display S3 based ESP32S3 with ST7789 170 x 320 TFT

#include <User_Setups/Setup206_LilyGo_T_Display_S3.h>     // For the LilyGo T-Display S3 based ESP32S3 with ST7789 170 x 320 TFT

Afficher un texte sur l’écran du LilyGo T-Display

Pour vérifier que les bibliothèques et la configuration de la carte sont correctement installées, nous allons afficher sur l’écran la taille des mémoires Flash et PSRAM détectées :

// LilyGo T-Display S3
// Site : https://tutoduino.fr/
// Licence : Copyleft 2025
// Inclusion de la bibliothèque TFT_eSPI pour gérer l'affichage TFT
// Cette bibliothèque permet de contrôler les écrans TFT compatibles avec les contrôleurs comme le ST7789V
#include <TFT_eSPI.h>
// Création d'un objet TFT_eSPI nommé "tft" pour interagir avec l'écran
// Cet objet encapsule toutes les fonctions nécessaires pour dessiner sur l'écran
TFT_eSPI tft = TFT_eSPI();
// -----------------------------------------------------------------------------
//  Mise en veille profonde de l'ESP32 et de l'ecran LCD
// -----------------------------------------------------------------------------
void enterDeepSleep() {
  // Configure la sortie de veille par appui sur le bouton
  esp_sleep_enable_ext0_wakeup((gpio_num_t)14, LOW);
  // Éteindre écran et désactiver son alimentation
  digitalWrite(38, LOW);
  digitalWrite(15, LOW);
  // Activer la veille profonde du microcontrolleur
  esp_deep_sleep_start();
}
void setup() {
  // Configuration de la broche 38 (rétroéclairage) en sortie
  pinMode(38, OUTPUT);
  // Allumer le rétroéclairage (HIGH = allumé)
  digitalWrite(38, HIGH);
  // Configuration de la broche 15 (activation de l'écran) en sortie
  pinMode(15, OUTPUT);
  // Activer l'écran (HIGH = activé)
  digitalWrite(15, HIGH);
  
  // Initialisation de l'écran TFT
  tft.init();
  // Rotation de l'écran (horizontal connecteur usb à gauche)
  tft.setRotation(3);
  // Effacer l'écran en le remplissant de noir
  tft.fillScreen(TFT_BLACK);
  // Affichage des différents messages sur l'écran
  tft.setTextColor(TFT_GREEN);
  tft.setTextSize(2);
  tft.setCursor(10, 20);
  tft.println("https://tutoduino.fr");
  tft.setTextColor(TFT_MAGENTA);
  tft.setCursor(10, 50);
  tft.println("Lilygo T-Display S3");
  // Lire et afficher la taille de la mémoire Flash
  uint32_t flashSize = ESP.getFlashChipSize();
  tft.setTextColor(TFT_ORANGE);
  tft.setCursor(10, 80);
  tft.print("Flash: ");
  tft.print(flashSize / (1024 * 1024));  // Conversion en Mo (1 Mo = 1024 Ko = 1024 * 1024 octets)
  tft.println(" Mo");
  // Vérifier si la PSRAM est présente
  if (psramFound()) {
    // Lire la taille de la PSRAM et l'afficher sur l'écran
    uint32_t psramSize = ESP.getPsramSize();
    tft.setCursor(10, 110);
    tft.setTextColor(TFT_CYAN);
    tft.print("PSRAM: ");
    tft.print(psramSize / (1024 * 1024));  // Conversion en Mo
    tft.println(" Mo");
  } else {
    // Si la PSRAM n'est pas détectée, afficher un message
    tft.setCursor(10, 110);
    tft.setTextColor(TFT_CYAN);
    tft.println("No PSRAM detected");
  }
}
void loop() {
  // Attendre 1 minute et entrer en veille profonde
  delay(60000);
  enterDeepSleep();
}

// LilyGo T-Display S3
// Site : https://tutoduino.fr/
// Licence : Copyleft 2025

// Inclusion de la bibliothèque TFT_eSPI pour gérer l'affichage TFT
// Cette bibliothèque permet de contrôler les écrans TFT compatibles avec les contrôleurs comme le ST7789V
#include <TFT_eSPI.h>

// Création d'un objet TFT_eSPI nommé "tft" pour interagir avec l'écran
// Cet objet encapsule toutes les fonctions nécessaires pour dessiner sur l'écran
TFT_eSPI tft = TFT_eSPI();

// -----------------------------------------------------------------------------
//  Mise en veille profonde de l'ESP32 et de l'ecran LCD
// -----------------------------------------------------------------------------
void enterDeepSleep() {
  // Configure la sortie de veille par appui sur le bouton
  esp_sleep_enable_ext0_wakeup((gpio_num_t)14, LOW);

  // Éteindre écran et désactiver son alimentation
  digitalWrite(38, LOW);
  digitalWrite(15, LOW);

  // Activer la veille profonde du microcontrolleur
  esp_deep_sleep_start();
}

void setup() {
  // Configuration de la broche 38 (rétroéclairage) en sortie
  pinMode(38, OUTPUT);
  // Allumer le rétroéclairage (HIGH = allumé)
  digitalWrite(38, HIGH);

  // Configuration de la broche 15 (activation de l'écran) en sortie
  pinMode(15, OUTPUT);
  // Activer l'écran (HIGH = activé)
  digitalWrite(15, HIGH);
  
  // Initialisation de l'écran TFT
  tft.init();

  // Rotation de l'écran (horizontal connecteur usb à gauche)
  tft.setRotation(3);

  // Effacer l'écran en le remplissant de noir
  tft.fillScreen(TFT_BLACK);

  // Affichage des différents messages sur l'écran
  tft.setTextColor(TFT_GREEN);
  tft.setTextSize(2);
  tft.setCursor(10, 20);
  tft.println("https://tutoduino.fr");

  tft.setTextColor(TFT_MAGENTA);
  tft.setCursor(10, 50);
  tft.println("Lilygo T-Display S3");

  // Lire et afficher la taille de la mémoire Flash
  uint32_t flashSize = ESP.getFlashChipSize();
  tft.setTextColor(TFT_ORANGE);
  tft.setCursor(10, 80);
  tft.print("Flash: ");
  tft.print(flashSize / (1024 * 1024));  // Conversion en Mo (1 Mo = 1024 Ko = 1024 * 1024 octets)
  tft.println(" Mo");

  // Vérifier si la PSRAM est présente
  if (psramFound()) {
    // Lire la taille de la PSRAM et l'afficher sur l'écran
    uint32_t psramSize = ESP.getPsramSize();
    tft.setCursor(10, 110);
    tft.setTextColor(TFT_CYAN);
    tft.print("PSRAM: ");
    tft.print(psramSize / (1024 * 1024));  // Conversion en Mo
    tft.println(" Mo");

  } else {
    // Si la PSRAM n'est pas détectée, afficher un message
    tft.setCursor(10, 110);
    tft.setTextColor(TFT_CYAN);
    tft.println("No PSRAM detected");
  }
}

void loop() {
  // Attendre 1 minute et entrer en veille profonde
  delay(60000);
  enterDeepSleep();
}

Si tout se déroule normalement, votre Lilygo T-Display S3 devrait afficher les messages suivants :

Mesure de la tension de la batterie

Le Lilygo T-Display S3 peut être alimenté par une batterie Lithium-Ion de 3,7 V par son connecteur JST PH 2.0 (JST 2 broches avec un pas de 2 mm). Une batterie de 800 mAh peut être positionnée à l’intérieur du boîtier.

Il est possible de mesurer la tension de la batterie via la broche LCD_BAT_VOLT (GPIO4), ce qui permet d’estimer son niveau de charge (4,2 V =100% et 3,0 V = 0%).

La tension fournie par la batterie dépasse la plage de mesure admissible d’une entrée analogique de l’ESP32. Afin de permettre sa mesure, un pont diviseur de tension est intégré au circuit, ce qui abaisse la tension à un niveau compatible avec l’entrée ADC utilisée (GPIO4 dans ce cas).

Le schéma électrique de la carte indique que ce pont diviseur présente un rapport de division de 2. Toutefois, en raison des tolérances des composants et des imprécisions propres à la référence ADC de l’ESP32, un ajustement empirique a été nécessaire. Un coefficient correctif ADC_CORR de 1,051 a ainsi été appliqué afin d’obtenir une correspondance fidèle entre la tension réelle mesurée au multimètre et la valeur calculée par l’ESP32 sur le module LilyGO T-Display S3.

Voici le code qui permet d’afficher la tension de la batterie sur l’écran :

// LilyGo T-Display S3
// Site : https://tutoduino.fr/
// Licence : Copyleft 2025
// Inclusion de la bibliothèque pour gérer l'écran TFT
#include <TFT_eSPI.h>
// Création de l'objet pour contrôler l'écran TFT
TFT_eSPI tft = TFT_eSPI();
// Définition des broches utilisées
#define LCD_BAT_VOLT 4  // Broche de mesure de la tension batterie
#define PIN_BUTTON 14   // Broche du bouton
#define TFT_ON 15       // Broche d'activation de l'écran
#define TFT_BL 38       // Broche du rétroéclairage
#define ADC_REF 3.30
#define ADC_CORR 1.051  // calibration terrain
#define ADC_MAX 4095.0
#define DIVIDER 2.0
// Configuration de la mesure de tension
void initVoltageMeasurement() {
  // Résolution 12 bits et atténuation 11 dB (mesure jusqu'à 2600 mV)
  // Il s'agit des valeurs par défaut, objectif uniquement pédagogique
  analogSetPinAttenuation(LCD_BAT_VOLT, ADC_11db);
  analogReadResolution(12);
}
// Lecture de la tension batterie
float readBatteryVoltage() {
  int adcValue = analogRead(LCD_BAT_VOLT);
  return (adcValue / ADC_MAX) * ADC_REF * DIVIDER * ADC_CORR;
}
void setup() {
  // Configurer rétroéclairage et écran en sortie
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);  // Allumer rétroéclairage
  pinMode(TFT_ON, OUTPUT);
  digitalWrite(TFT_ON, HIGH);  // Activer écran
  // Initialiser la mesure de tension
  initVoltageMeasurement();
  // Initialiser l'écran TFT
  tft.init();
  // Rotation de l'écran (connecteur USB à gauche)
  tft.setRotation(3);
}
void loop() {
  // Mesurer et afficher la tension batterie toutes les 10 secondes
  tft.fillScreen(TFT_BLACK);
  tft.setCursor(10, 50);
  tft.setTextColor(TFT_CYAN);
  tft.printf("VBAT = %.2f V", readBatteryVoltage());
  delay(10000);
}

// LilyGo T-Display S3
// Site : https://tutoduino.fr/
// Licence : Copyleft 2025

// Inclusion de la bibliothèque pour gérer l'écran TFT
#include <TFT_eSPI.h>

// Création de l'objet pour contrôler l'écran TFT
TFT_eSPI tft = TFT_eSPI();

// Définition des broches utilisées
#define LCD_BAT_VOLT 4  // Broche de mesure de la tension batterie
#define PIN_BUTTON 14   // Broche du bouton
#define TFT_ON 15       // Broche d'activation de l'écran
#define TFT_BL 38       // Broche du rétroéclairage

#define ADC_REF 3.30
#define ADC_CORR 1.051  // calibration terrain
#define ADC_MAX 4095.0
#define DIVIDER 2.0

// Configuration de la mesure de tension
void initVoltageMeasurement() {
  // Résolution 12 bits et atténuation 11 dB (mesure jusqu'à 2600 mV)
  // Il s'agit des valeurs par défaut, objectif uniquement pédagogique
  analogSetPinAttenuation(LCD_BAT_VOLT, ADC_11db);
  analogReadResolution(12);
}

// Lecture de la tension batterie
float readBatteryVoltage() {
  int adcValue = analogRead(LCD_BAT_VOLT);
  return (adcValue / ADC_MAX) * ADC_REF * DIVIDER * ADC_CORR;
}

void setup() {
  // Configurer rétroéclairage et écran en sortie
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);  // Allumer rétroéclairage
  pinMode(TFT_ON, OUTPUT);
  digitalWrite(TFT_ON, HIGH);  // Activer écran

  // Initialiser la mesure de tension
  initVoltageMeasurement();

  // Initialiser l'écran TFT
  tft.init();
  // Rotation de l'écran (connecteur USB à gauche)
  tft.setRotation(3);
}

void loop() {
  // Mesurer et afficher la tension batterie toutes les 10 secondes
  tft.fillScreen(TFT_BLACK);
  tft.setCursor(10, 50);
  tft.setTextColor(TFT_CYAN);
  tft.printf("VBAT = %.2f V", readBatteryVoltage());
  delay(10000);
}

Le chiffrement consiste à rendre les données illisibles pour toute personne ne possédant pas la clé de déchiffrement, assurant ainsi leur confidentialité.

Ce principe vous est sans doute familier grâce au petit cadenas affiché dans la barre d’adresse de votre navigateur : il indique que la communication entre votre appareil et le site web utilise le protocole sécurisé HTTPS. Ainsi, même si un attaquant intercepte le trafic, il ne pourra pas en lire le contenu.

Toutefois, la protection des données ne se limite pas aux échanges réseau. Dans le cas des objets connectés, il est tout aussi crucial de chiffrer la mémoire Flash, afin d’empêcher l’accès ou la modification non autorisés des informations stockées localement.

Pourquoi chiffrer la mémoire Flash d’un objet connecté IoT ?

Le “cerveau” d’un objet connecté IoT (Internet of Things) est un micro-contrôleur, qui stocke ses données persistantes (programme, configuration Wi-Fi…) dans une mémoire Flash. Ce type de mémoire conserve en effet les données même sans alimentation.

Une personne ayant un accès physique à un objet connecté peut dès lors lire le contenu de cette mémoire et en extraire des secrets, informations cruciales pour la sécurité de votre réseau (certificats de sécurité, mot de passe de l’application, mots de passe Wi-Fi…). Il est donc indispensable de chiffrer cette mémoire afin de rendre ces secrets illisibles pour un attaquant. Il existe d’ailleurs maintenant des puces spécialisées pour le stockage des secrets (ex : TPM).

La plupart des objets connectés “grand public”, comme les capteurs de température ou les caméras de vidéo-surveillance, ne sont pas équipés de puce TPM et leur mémoire Flash est rarement chiffrée. Or ces objets sont généralement connectés à un réseaux Wi-Fi.

Les communications sur les réseaux Wi-Fi sont maintenant relativement sécurisés avec une clé de chiffrement WPA2-PSK. Mais un attaquant qui a un accès physique à un objet connecté (un capteur dans une usine, une caméra dans votre jardin), peut facilement extraire cette clé de la mémoire Flash non chiffrée de cet objet.

Voici un exemple minimaliste de code pour un objet connecté basé sur un microcontrôleur ESP32, qui se connecte au réseau Wi-Fi TP-Link_21B7 (SSID) avec le mot de passe R3seauS3cur1t3IoT! :

// Example used to show how Wi-Fi password
// can be extracted from Flash memory
//
// https://tutoduino.fr/
#include <WiFi.h>
const char *ssid = "TP-Link_21B7";
const char *passphrase = "R3seauS3cur1t3IoT!";
void setup() {
  Serial.begin(115200);
  delay(100);
  WiFi.begin(ssid, passphrase);
  Serial.println();
  Serial.println();
  Serial.print("Waiting for WiFi... ");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}
void loop() {
  delay(1000);
}

// Example used to show how Wi-Fi password
// can be extracted from Flash memory
//
// https://tutoduino.fr/

#include <WiFi.h>

const char *ssid = "TP-Link_21B7";
const char *passphrase = "R3seauS3cur1t3IoT!";

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

  WiFi.begin(ssid, passphrase);

  Serial.println();
  Serial.println();
  Serial.print("Waiting for WiFi... ");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  delay(1000);
}

Le nom du réseau Wi-Fi (ssid) et son mot de passe (passphrase) sont des constantes qui vont être stockées dans la mémoire Flash du microcontrôleur.

Après avoir connecté l’objet via son port USB à un ordinateur sous Linux, il est trivial d’extraire les identifiants Wi-Fi de sa mémoire Flash :

Voici cet exemple illustré en vidéo :

Comment chiffrer la mémoire Flash sur un ESP32 ?

Le framework ESP-IDF permet de chiffrer la mémoire flash des ESP32 avec une procédure relativement simple.

Voici les principales étapes :

#1. Générer une clé de chiffrement

Vous pouvez utiliser la clé de chiffrement matérielle intégrée à l’ESP32 (unique pour chaque puce) ou générer votre propre clé de chiffrement personnalisée. Chaque méthode présente ses avantages et ses inconvénients. Dans ce tutoriel, à des fins pédagogiques, j’ai choisi de générer ma propre clé de chiffrement.

Voici comment générer votre propre clé de chiffrement :

espsecure.py generate_flash_encryption_key my_key.bin

espsecure.py generate_flash_encryption_key my_key.bin

Cette clé a une taille de 256 bits, qui permettra de chiffrer avec un bon niveau de sécurité vos firmwares. Attention cette clé sera nécessaire pour toute les futures modifications de firmware de votre objet connecté, elle doit être conservée précieusement.

#2. Brûlez-la clé de chiffrement dans un eFuse du micro-contrôleur

Votre clé de chiffrement doit être écrite dans l’ESP32. Afin de garantir la confidentialité absolue de la clé et d’empêcher toute lecture ou modification ultérieure, le dispositif utilise le mécanisme de programmation eFuse.

Un eFuse (fusible électronique) est un composant matériel intégré directement dans la puce de l’ESP32. Contrairement à la mémoire flash standard, c’est une mémoire OTP (One-Time Programmable) : une fois un bit activé, il ne peut plus être modifié ni effacé. Cette opération est donc permanente et irréversible.

espefuse --port /dev/ttyUSB0 burn_key flash_encryption my_key.bin

espefuse --port /dev/ttyUSB0 burn_key flash_encryption my_key.bin

Voici le résultat de cette commande si tout se déroule bien :

steph@F15:~/esp/esp-idf-5.5.1$ espefuse --port /dev/ttyUSB0 burn_key flash_encryption my_key.bin
espefuse v4.11.dev2
Connecting.....
Detecting chip type... ESP32
=== Run "burn_key" command ===
Sensitive data will be hidden (see --show-sensitive-info)
Burn keys to blocks:
 - BLOCK1 -> [?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ??]
	Reversing the byte order
	Disabling read to key block
	Disabling write to key block
Burn keys in efuse blocks.
The key block will be read and write protected (no further changes or readback) 
Check all blocks for burn...
idx, BLOCK_NAME,          Conclusion
[00] BLOCK0               is not empty
	(written ): 0x0000000400000000000014380000b00000a5840d8e19b63400000000
	(to write): 0x00000000000000000000000000000000000000000000000000010080
	(coding scheme = NONE)
[01] BLOCK1               is empty, will burn the new value
. 
This is an irreversible operation!
Type 'BURN' (all capitals) to continue.
BURN
BURN BLOCK1  - OK (write block == read block)
BURN BLOCK0  - OK (all write block bits are set)
Reading updated efuses...
Successful

steph@F15:~/esp/esp-idf-5.5.1$ espefuse --port /dev/ttyUSB0 burn_key flash_encryption my_key.bin
espefuse v4.11.dev2
Connecting.....
Detecting chip type... ESP32

=== Run "burn_key" command ===
Sensitive data will be hidden (see --show-sensitive-info)
Burn keys to blocks:
 - BLOCK1 -> [?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ??]
	Reversing the byte order
	Disabling read to key block
	Disabling write to key block

Burn keys in efuse blocks.
The key block will be read and write protected (no further changes or readback) 


Check all blocks for burn...
idx, BLOCK_NAME,          Conclusion
[00] BLOCK0               is not empty
	(written ): 0x0000000400000000000014380000b00000a5840d8e19b63400000000
	(to write): 0x00000000000000000000000000000000000000000000000000010080
	(coding scheme = NONE)
[01] BLOCK1               is empty, will burn the new value
. 
This is an irreversible operation!
Type 'BURN' (all capitals) to continue.
BURN
BURN BLOCK1  - OK (write block == read block)
BURN BLOCK0  - OK (all write block bits are set)
Reading updated efuses...
Successful

Votre clé de chiffrement de 256 bits est stockée dans le BLOCK1 des fusibles, elle est protégée en lecture/écriture.

Nous pouvons vérifier par la suite que nous n’avons aucun accès en lecture à la clé de chiffrement :

espefuse --port /dev/ttyUSB0 summary

espefuse --port /dev/ttyUSB0 summary

Renvoie des points d’interrogation pour BLOCK1, la clé de chiffrement est correctement protégée en lecture.

BLOCK1 (BLOCK1)                                    Flash encryption key                              
   = ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? -/- 

BLOCK1 (BLOCK1)                                    Flash encryption key                              
   = ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? -/- 

#3. Activer le chiffrement de la flash dans le micro-contrôleur (attention, ceci est irréversible)

Deux eFuse spécifiques doivent être brûlés pour activer le chiffrement de la flash :

• FLASH_CRYPT_CNT : Compteur qui limite le nombre de tentatives pour activer le chiffrement, empêchant toute réinitialisation non autorisée du chiffrement. Sa valeur doit être impair pour activer le chiffrement.
• FLASH_CRYPT_CONFIG : Définit les paramètres du chiffrement. La valeur 0x0F active le chiffrement AES-256 pour toutes les données stockées dans la mémoire Flash (y compris le bootloader, l’application et les données utilisateur).

espefuse --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CNT 1
espefuse --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CONFIG 0x0F

espefuse --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CNT 1
espefuse --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CONFIG 0x0F

Vérifions les valeurs des fusibles électroniques à cette étape :

espefuse --port /dev/ttyUSB0 summary

espefuse --port /dev/ttyUSB0 summary

FLASH_CRYPT_CNT est défini sur 1 et FLASH_CRYPT_CONFIG est défini sur 0xf, cela semble correct.

Flash fuses:
FLASH_CRYPT_CNT (BLOCK0)                           Flash encryption is enabled if this field has an o = 1 R/W (0b0000001)
                                                   dd number of bits set                             
FLASH_CRYPT_CONFIG (BLOCK0)                        Flash encryption config (key tweak bits)           = 15 R/W (0xf)

Flash fuses:
FLASH_CRYPT_CNT (BLOCK0)                           Flash encryption is enabled if this field has an o = 1 R/W (0b0000001)
                                                   dd number of bits set                             
FLASH_CRYPT_CONFIG (BLOCK0)                        Flash encryption config (key tweak bits)           = 15 R/W (0xf)

#4. Activer le chiffrement de la partition NVS

La partition NVS (Non-Volatile Storage) est une partition spéciale de la flash. Son rôle principal est de stocker des données de configuration persistantes qui doivent survivre à un redémarrage ou à une coupure d’alimentation. La partition NVS doit être chiffrée afin de protéger les données sensibles comme les mots de passe.

Le chiffrement de la partition NVS se fait de la manière suivante dans l’IDE Arduino :

• Sélectionner le schéma de partition “Custom“
• Créer le fichier “partitions.csv” dans le répertoire où est stocké votre croquis sur votre ordinateur
• Configurer le schéma de partition souhaité au format csv dans ce fichier
• Ajouter le flag “encrypted” pour la partition NVS
• Compiler le programme dans l’IDE Arduino (il peut être utile de supprimer auparavant le répertoire cache arduino)

#5. Chiffrer le firmware

Après avoir compilé le programme sous l’IDE Arduino, il faut exporter les fichiers binaires générés.

Cela positionne tous les fichiers nécessaires dans le sous-répertoire build du répertoire où est stocké votre croquis Arduino.

Le fichier flash_args contient le nom des fichiers qu’il va falloir chiffrer et à quel offset il va falloir ensuite les flasher dans la mémoire de l’ESP32 :

Chiffrer tous ces fichiers binaires avec votre clé de chiffrement en indiquant en paramètre leur adresse dans la mémoire Flash.

$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0x1000 \
  --output bootloader_enc.bin \
  bootloader.bin  
$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0x8000 \
  --output partitions_enc.bin \
  partitions.bin  
  
$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0xe000 \
  --output boot_app0_enc.bin \
  boot_app0.bin    
    
$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0x10000 \
  --output firmware_enc.bin \
  firmware.bin  

$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0x1000 \
  --output bootloader_enc.bin \
  bootloader.bin  

$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0x8000 \
  --output partitions_enc.bin \
  partitions.bin  
  
$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0xe000 \
  --output boot_app0_enc.bin \
  boot_app0.bin    
    
$ espsecure encrypt_flash_data \
  --keyfile my_key.bin \
  --address 0x10000 \
  --output firmware_enc.bin \
  firmware.bin  

#6. Flasher le firmware chiffré dans la mémoire Flash de l’ESP32

Flasher tous les binaires chiffrés à l’étape précédente dans la mémoire flash de l’ESP32 :

esptool --chip esp32 --port /dev/ttyUSB0 \
  write_flash \
  0x1000  bootloader_enc.bin \
  0x8000  partitions_enc.bin \
  0xe000  boot_app0_enc.bin \
  0x10000 firmware_enc.bin

esptool --chip esp32 --port /dev/ttyUSB0 \
  write_flash \
  0x1000  bootloader_enc.bin \
  0x8000  partitions_enc.bin \
  0xe000  boot_app0_enc.bin \
  0x10000 firmware_enc.bin

Le chiffrement assure la confidentialité des données !

En répétant la procédure du début de ce tutoriel, il devient impossible d’extraire les données en clair de la mémoire Flash.

Le firmware est également chiffré, il n’est plus possible de réaliser d’ingénierie inverse dessus :

Conclusion

Le chiffrement de la mémoire Flash assure la confidentialité des données qu’elle stocke et apporte de nombreux bénéfices aux niveau de la cybersécurité de votre objet connecté IoT :

✅ Bootloader chiffré

• Empêche l’exécution de code malveillant au démarrage.
• Protège contre les attaques par modification du bootloader (ex. : injection de malware).
• Garantit l’intégrité du processus de démarrage.

✅ Application protégée

• Rend le code illisible sans la clé de chiffrement.
• Empêche l’ingénierie inverse (reverse engineering) pour voler la propriété intellectuelle.
• Sécurise les algorithmes sensibles (ex. : protocoles de communication, logiques métiers).

✅ Mot de passe Wi-Fi inextractible

• Empêche la récupération du mot de passe même avec un accès physique à la mémoire.
• Réduit les risques de piratage du réseau via l’extraction des identifiants.
• Protège la confidentialité des données transmises sur le réseau.

✅ Clone du firmware impossible sans la clé de chiffrement

• Empêche la duplication non autorisée du firmware (protection contre la contrefaçon).
• Garantit l’authenticité du matériel (seuls les appareils légitimes peuvent fonctionner).
• Protège les revenus et la réputation en évitant les copies illégales.

En résumé : Le chiffrement de la mémoire Flash renforce la sécurité, protège la propriété intellectuelle et limite les risques de piratage ou de contrefaçon. Un must pour les appareils connectés ! 🔒

Avez-vous déjà remarqué les options de l’IDE Arduino permettant d’activer la PSRAM ou de sélectionner un schéma de partitionnement pour un ESP32 ? Savez-vous à quoi elles servent ?

Dans ce tutoriel, consacré à l’ESP32-C5, je vous expliquerai leur signification et comment les utiliser efficacement. Je présenterai d’abord les principaux types de mémoire (FLASH, SRAM, PSRAM et EEPROM), puis les différents schémas de partitionnement.

Le partitionnement est crucial car une configuration bien pensée permet d’exploiter pleinement les fonctionnalités de l’ESP32, comme le stockage de fichiers (par exemple, des pages web pour serveurs embarqués), les mises à jour OTA du firmware et la persistance des paramètres. Une mauvaise configuration peut entraîner des problèmes d’espace disque insuffisant, la perte de fonctionnalités ou une corruption de la mémoire, comme on peut le constater lors de débordements de tampon dans des programmes.

Avant d’explorer les fonctionnalités avancées de gestion de la mémoire de l’ESP32, nous reviendrons sur les bases à l’aide de l’exemple Arduino Uno afin de comprendre où sont stockées les données et comment optimiser l’espace disponible pour chaque type de mémoire.

Comprendre les mémoires d’un microcontrôleur avec l’exemple de l’Arduino Uno

Les microcontrôleurs utilisent différents types de mémoires à des fins différentes :

• EEPROM : mémoire non volatile qui conserve les données même sans alimentation. Ce type de mémoire de petite capacité est optimisée pour des écritures fréquentes (100.000 cycles).
• FLASH : comme la mémoire EEPROM, la mémoire FLASH est non volatile et conserve les données même sans alimentation. Ce type de mémoire a généralement une plus grande capacité, mais permet moins de cycles d’écriture (10.000 cycles).
• SRAM : mémoire volatile ultra-rapide qui s’efface dès coupure alimentation.

L’arduino UNO R3 est basé sur le microcontrôleur ATMEGA 328P, équipé des mémoires suivantes selon la documentation de ce microcontrôleur :

• 32 ko de mémoire FLASH
• 1 ko de mémoire EEPROM
• 2 ko de mémoire SRAM

Prenons par exemple le programme suivant, et expliquons l’utilisation de la mémoire :

// Exemple illustrant l'utilisation des differentes memoires
// d'un Arduino UNO R3
//
// https://tutoduino.fr/
char* pointeur = NULL; // le compilateur reserve 2 octets en SRAM pour stocker ce pointeur
void setup() {
  Serial.begin(115200);
  pointeur = (char*)malloc(200 * sizeof(char));  // allocation dynamique de 200 octets en SRAM
  if (pointeur == NULL) {
    Serial.println("Erreur d'allocation mémoire!");
  } else {
    free(pointeur);
    pointeur = NULL;
  }
}
void loop() {
  delay(1000);
}

// Exemple illustrant l'utilisation des differentes memoires
// d'un Arduino UNO R3
//
// https://tutoduino.fr/

char* pointeur = NULL; // le compilateur reserve 2 octets en SRAM pour stocker ce pointeur

void setup() {
  Serial.begin(115200);
  pointeur = (char*)malloc(200 * sizeof(char));  // allocation dynamique de 200 octets en SRAM
  if (pointeur == NULL) {
    Serial.println("Erreur d'allocation mémoire!");
  } else {
    free(pointeur);
    pointeur = NULL;
  }
}

void loop() {
  delay(1000);
}

Une fois compilé, le programme occupe 2264 octets de Flash. Les variables globales utilisent 228 octets de SRAM, laissant 1820 octets de disponibles sur les 2 ko de mémoire SRAM totale.

Sketch uses 2264 bytes (7%) of program storage space. Maximum is 32256 bytes.
Global variables use 228 bytes (11%) of dynamic memory, leaving 1820 bytes for local variables. Maximum is 2048 bytes.

Sketch uses 2264 bytes (7%) of program storage space. Maximum is 32256 bytes.
Global variables use 228 bytes (11%) of dynamic memory, leaving 1820 bytes for local variables. Maximum is 2048 bytes.

Note : Sur les 32 768 octets (32 ko) de Flash, 512 octets sont réservés au bootloader Arduino, laissant 32256 octets maximum pour le programme utilisateur.

Si le programme essaie d’allouer plus de mémoire que disponible en SRAM, l’allocation va échouer. Exemple ici avec une tentative d’allocation de 1900 octets :

Il n’y a pas de schéma de partition configurable dans l’IDE Arduino pour l’Arduino UNO R3. En effet, son microcontrôleur utilise une mémoire flash fixe de 32 Ko, sans système de fichiers ni support OTA natif. Mais commençons par comprendre les différents types de mémoire utilisées par les microcontrôleurs :

Mémoires du XIAO ESP32-C5

Le module XIAO ESP32-C5 est basé sur le micro-contrôleur ESP32-C5 équipé d’une SRAM externe de 8 Mo ainsi que d’une FLASH externe de 8 Mo.

Le micro-contrôleur ESP32-C5 possède la mémoire interne suivante :

• 384 ko de SRAM haute performance (HP), utilisée par le cœur haute performance (HP core), qui fonctionne à une fréquence élevée (240 MHz).
• 16 ko de SRAM basse consommation (LP), associée au cœur basse consommation (LP core), qui fonctionne à une fréquence beaucoup plus basse (40 MHz).
• 320 ko de ROM, mémoire immuable en lecture seule, dédiée aux fonctions de base et au démarrage du système.

L’adresse virtuelle est mappée à l’espace d’adressage physique de la mémoire externe via l’unité de gestion de la mémoire (MMU). Le tableau suivant présente les adresses virtuelles des différentes mémoires de l’ESP32-C5.

Note : Sur le XIAO ESP32-C5, la PSRAM externe et la Flash partagent l’espace d’adresses virtuelles 0x42000000–0x43FFFFFF car le SoC ESP32-C5 utilise un sous-système cache/MMU pour mapper les mémoires externes dans un espace d’adresses virtuelles commun. La Flash et la PSRAM sont mappées dynamiquement dans cette plage via les mappings de pages MMU plutôt que d’occuper des régions d’adresses virtuelles distinctes.

Mémoire SRAM interne et PSRAM externe du XIAO ESP32-C5

Pour revenir au début de ce tutoriel, rappelons que l’allocation dynamique de mémoire s’effectue dans la SRAM. Or, la SRAM interne du microcontrôleur ESP32-C5 est limitée à 384 Ko.

Si votre programme nécessite une allocation dynamique de mémoire plus importante, la PSRAM de 8 Mo du module XIAO ESP32-C5 entre en jeu. La PSRAM est une mémoire externe, connectée via SPI, conçue pour émuler la SRAM mais utilisant la technologie DRAM (Dynamic RAM).

Cependant, la PSRAM n’est pas activée par défaut dans la configuration ESP32 de l’IDE Arduino ; vous devez l’activer explicitement dans les paramètres de l’IDE.

Cet exemple démontre comment l’ESP32-C5 sélectionne automatiquement la SRAM pour les petites allocations (1 octet) et la PSRAM pour les grandes (1 Mo), les grandes allocations échouant lorsque la PSRAM est désactivée.

// Example illustrating the use of SRAM and PSRAM
// on a XIAO ESP32C5
// https://tutoduino.fr/en/partition-esp32-arduino-en/
#include <Arduino.h>
#include "esp_heap_caps.h"
#include "esp_system.h"
/**
 * Function to display the memory address of any variable
 * @param variableName Name of the variable for display
 * @param variable Pointer to the variable to check
 */
void printAddress(const char* variableName, void* variable) {
  Serial.print("Memory address of '");
  Serial.print(variableName);
  Serial.print("' is: 0x");
  Serial.println((uintptr_t)variable, HEX);
}
void setup() {
  int* one_byte_pointer;   // Pointer for small allocation test (1 byte)
  int* one_mbyte_pointer;  // Pointer for large allocation test (1 MB)
  Serial.begin(115200);
  while (!Serial)
    ;  // Wait for Serial Monitor to connect
  Serial.println("\n=== SRAM vs PSRAM usage on ESP32C5 ===");
  // CHECK PSRAM AVAILABILITY AND STATUS
  size_t psram_total = ESP.getPsramSize();
  size_t psram_free = ESP.getFreePsram();
  if (psram_total == 0) {
    Serial.println("❌ PSRAM not enabled or not detected");
    Serial.println("   Enable PSRAM in Arduino IDE Tools → PSRAM: 'Enabled'");
  } else {
    Serial.println("✅ PSRAM enabled and detected");
    Serial.printf("   PSRAM Total: %d bytes (%.1f MB)\n", psram_total, psram_total / 1024.0 / 1024.0);
    Serial.printf("   PSRAM Free:  %d bytes (%.1f MB)\n", psram_free, psram_free / 1024.0 / 1024.0);
  }
  Serial.println("\n--- Testing small allocation (1 byte) ---");
  // TRY TO ALLOCATE 1 BYTE - Should use internal SRAM (384KB on ESP32-C5)
  one_byte_pointer = (int*)malloc(0x1);  // Allocate 1 byte
  if (one_byte_pointer != NULL) {
    Serial.println("✅ Small allocation (1 byte) succeeded - Uses SRAM");
    printAddress("one_byte_pointer", (void*)one_byte_pointer);
    psram_free = ESP.getFreePsram();
    Serial.printf("\PSRAM Free: %d bytes (%.1f MB)\n", psram_free, psram_free / 1024.0 / 1024.0);
  } else {
    Serial.println("❌ Memory allocation failed for one_byte_pointer");
  }
  Serial.println("\n--- Testing large allocation (1 MB) ---");
  // TRY TO ALLOCATE 1MB - Should use PSRAM (8MB on XIAO ESP32C5)
  one_mbyte_pointer = (int*)malloc(0x100000);  // Allocate 1 megabyte (1048576 bytes)
  if (one_mbyte_pointer != NULL) {
    Serial.println("✅ Large allocation (1 MB) succeeded - Uses PSRAM");
    printAddress("one_mbyte_pointer", (void*)one_mbyte_pointer);
    psram_free = ESP.getFreePsram();
    Serial.printf("\PSRAM Free: %d bytes (%.1f MB)\n", psram_free, psram_free / 1024.0 / 1024.0);
    // Free the large allocation to avoid memory leaks
    free(one_mbyte_pointer);
    one_mbyte_pointer = NULL;
  } else {
    Serial.println("❌ Memory allocation failed for one_mbyte_pointer");
    Serial.println("   This happens if PSRAM is not enabled or allocation exceeds available space");
  }
}
void loop() {
  // Empty loop - all tests run once in setup()
  delay(1000);
}

// Example illustrating the use of SRAM and PSRAM
// on a XIAO ESP32C5
// https://tutoduino.fr/en/partition-esp32-arduino-en/

#include <Arduino.h>
#include "esp_heap_caps.h"
#include "esp_system.h"

/**
 * Function to display the memory address of any variable
 * @param variableName Name of the variable for display
 * @param variable Pointer to the variable to check
 */
void printAddress(const char* variableName, void* variable) {
  Serial.print("Memory address of '");
  Serial.print(variableName);
  Serial.print("' is: 0x");
  Serial.println((uintptr_t)variable, HEX);
}

void setup() {
  int* one_byte_pointer;   // Pointer for small allocation test (1 byte)
  int* one_mbyte_pointer;  // Pointer for large allocation test (1 MB)

  Serial.begin(115200);
  while (!Serial)
    ;  // Wait for Serial Monitor to connect
  Serial.println("\n=== SRAM vs PSRAM usage on ESP32C5 ===");

  // CHECK PSRAM AVAILABILITY AND STATUS
  size_t psram_total = ESP.getPsramSize();
  size_t psram_free = ESP.getFreePsram();

  if (psram_total == 0) {
    Serial.println("❌ PSRAM not enabled or not detected");
    Serial.println("   Enable PSRAM in Arduino IDE Tools → PSRAM: 'Enabled'");
  } else {
    Serial.println("✅ PSRAM enabled and detected");
    Serial.printf("   PSRAM Total: %d bytes (%.1f MB)\n", psram_total, psram_total / 1024.0 / 1024.0);
    Serial.printf("   PSRAM Free:  %d bytes (%.1f MB)\n", psram_free, psram_free / 1024.0 / 1024.0);
  }

  Serial.println("\n--- Testing small allocation (1 byte) ---");
  // TRY TO ALLOCATE 1 BYTE - Should use internal SRAM (384KB on ESP32-C5)
  one_byte_pointer = (int*)malloc(0x1);  // Allocate 1 byte

  if (one_byte_pointer != NULL) {
    Serial.println("✅ Small allocation (1 byte) succeeded - Uses SRAM");
    printAddress("one_byte_pointer", (void*)one_byte_pointer);
    psram_free = ESP.getFreePsram();
    Serial.printf("\PSRAM Free: %d bytes (%.1f MB)\n", psram_free, psram_free / 1024.0 / 1024.0);
  } else {
    Serial.println("❌ Memory allocation failed for one_byte_pointer");
  }

  Serial.println("\n--- Testing large allocation (1 MB) ---");
  // TRY TO ALLOCATE 1MB - Should use PSRAM (8MB on XIAO ESP32C5)
  one_mbyte_pointer = (int*)malloc(0x100000);  // Allocate 1 megabyte (1048576 bytes)

  if (one_mbyte_pointer != NULL) {
    Serial.println("✅ Large allocation (1 MB) succeeded - Uses PSRAM");
    printAddress("one_mbyte_pointer", (void*)one_mbyte_pointer);
    psram_free = ESP.getFreePsram();
    Serial.printf("\PSRAM Free: %d bytes (%.1f MB)\n", psram_free, psram_free / 1024.0 / 1024.0);
    // Free the large allocation to avoid memory leaks
    free(one_mbyte_pointer);
    one_mbyte_pointer = NULL;
  } else {
    Serial.println("❌ Memory allocation failed for one_mbyte_pointer");
    Serial.println("   This happens if PSRAM is not enabled or allocation exceeds available space");
  }
}

void loop() {
  // Empty loop - all tests run once in setup()
  delay(1000);
}

Lorsque la PSRAM est désactivée, l’allocation d’1 octet réussit dans la SRAM interne, mais l’allocation d’1 Mo échoue :

=== SRAM vs PSRAM usage on ESP32C5 ===
❌ PSRAM not enabled or not detected
   Enable PSRAM in Arduino IDE Tools → PSRAM: 'Enabled'
--- Testing small allocation (1 byte) ---
✅ Small allocation (1 byte) succeeded - Uses SRAM
Memory address of 'one_byte_pointer' is: 0x4085C834 (internal SRAM memory)
PSRAM Free: 0 bytes (0.0 MB)
--- Testing large allocation (1 MB) ---
❌ Memory allocation failed for one_mbyte_pointer
   This happens if PSRAM is not enabled or allocation exceeds available space

=== SRAM vs PSRAM usage on ESP32C5 ===
❌ PSRAM not enabled or not detected
   Enable PSRAM in Arduino IDE Tools → PSRAM: 'Enabled'

--- Testing small allocation (1 byte) ---
✅ Small allocation (1 byte) succeeded - Uses SRAM
Memory address of 'one_byte_pointer' is: 0x4085C834 (internal SRAM memory)
PSRAM Free: 0 bytes (0.0 MB)

--- Testing large allocation (1 MB) ---
❌ Memory allocation failed for one_mbyte_pointer
   This happens if PSRAM is not enabled or allocation exceeds available space

Lorsque la PSRAM est activée, l’allocation de 1 octet s’effectue dans la SRAM interne tandis que l’allocation de 1 Mo s’effectue dans la PSRAM externe :

=== SRAM vs PSRAM usage on ESP32C5 ===
✅ PSRAM enabled and detected
   PSRAM Total: 8388608 bytes (8.0 MB)
   PSRAM Free:  8386296 bytes (8.0 MB)
--- Testing small allocation (1 byte) ---
✅ Small allocation (1 byte) succeeded - Uses SRAM
Memory address of 'one_byte_pointer' is: 0x4085C868 (internal SRAM memory)
PSRAM Free: 8386296 bytes (8.0 MB)
--- Testing large allocation (1 MB) ---
✅ Large allocation (1 MB) succeeded - Uses PSRAM
Memory address of 'one_mbyte_pointer' is: 0x42050908 (external PSRAM memory)
PSRAM Free: 7337704 bytes (7.0 MB)

=== SRAM vs PSRAM usage on ESP32C5 ===
✅ PSRAM enabled and detected
   PSRAM Total: 8388608 bytes (8.0 MB)
   PSRAM Free:  8386296 bytes (8.0 MB)

--- Testing small allocation (1 byte) ---
✅ Small allocation (1 byte) succeeded - Uses SRAM
Memory address of 'one_byte_pointer' is: 0x4085C868 (internal SRAM memory)
PSRAM Free: 8386296 bytes (8.0 MB)

--- Testing large allocation (1 MB) ---
✅ Large allocation (1 MB) succeeded - Uses PSRAM
Memory address of 'one_mbyte_pointer' is: 0x42050908 (external PSRAM memory)
PSRAM Free: 7337704 bytes (7.0 MB)

L’allocation de 1 Mo utilise bien de la PSRAM externe, et c’est bien confirmé par sa plage d’adresses (0x42000000-0x43FFFFFF).

Le schéma de partition de la mémoire Flash dans l’IDE Arduino

Le menu Partition Scheme de l’IDE Arduino permet de définir comment doit être utilisée la mémoire FLASH externe des microcontrôleurs ESP32.

Pour bien choisir un schéma de partition sur un ESP32, il est essentiel de comprendre les acronymes et les rôles de chaque section de la mémoire flash :

• SPIFFS (Serial Peripheral Interface Flash File System) est un système de fichiers qui permet de créer, lire, modifier et supprimer des fichiers directement dans la mémoire flash. Ce système de fichiers gère l’usure, la fragmentation et la persistance des données, spécifique à la technologie flash. Ce système ne permet pas d’organiser les fichiers en dossiers (tous les fichiers sont à la racine).
• FATFS est un système de fichiers est une implémentation légère du système de fichiers FAT (File Allocation Table) conçue pour les systèmes embarqués. Permet d’organiser les fichiers en dossiers et sous-dossiers et permet de gérer des fichiers et des partitions bien plus grandes que SPIFFS.
• APP (Application) est la partition dédiée au stockage du firmware (programme compilé) de l’ESP32. La partition APP peut être divisée en plusieurs partitions (ex : app0, app1) pour permettre des mises à jour du firmware à distance (OTA). La partition app0 contient le firmware principal (version actuelle ou précédente) alors que la partition app1 contient une seconde copie du firmware. Pendant qu’une nouvelle version est téléchargée dans app1, app0 continue de fonctionner. Après la mise à jour, l’ESP32 redémarre sur app1.
• OTA (Over-The-Air) est la partition qui stocke les métadonnées pour les mises à jour OTA, comme l’état de la dernière mise à jour ou la partition active (app0 ou app1).

Les schémas de partition sont stockés dans le répertoire d’installation du core ESP32 pour Arduino. Par exemple sous Linux :

~/.arduino15/packages/esp32/hardware/esp32/3.3.6/tools/partitions

~/.arduino15/packages/esp32/hardware/esp32/3.3.6/tools/partitions

Voici un exemple des schémas de partitions disponibles pour la version 3.3.6 du core ESP32.

Ces fichiers au format CSV contiennent la définition des partitions :

• Name : Identifiant de la partition (ex : app0, spiffs).
• Type : Type de partition (app, data).
• SybType : Sous-type (ota_0, ota_1, spiffs, fatfs, etc.).
• Offset : Offset en hexadécimal dans la mémoire flash.
• Size : Taille de la partition en hexadécimal.
• Flags : Options supplémentaires (ex : encrypted).

Voici par exemple le contenu du fichier default_8MB.csv

L’IDE Arduino utilise le fichier de partition (.csv) sélectionné pour générer une table de partition binaire, intégrée au firmware. Cette table est écrite dans la mémoire flash de l’ESP32, à l’adresse 0x8000, lors du téléversement. Le bootloader de l’ESP32 lit cette table lors de son exécution pour savoir où se trouvent les partitions (APP, SPIFFS, OTA, etc.).

Je vous recommande la lecture de la documentation dédiée au tables de partition sur le site Espressif : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/partition-tables.html

Exemple de problème lié aux schémas de partition de la Flash

Vous souhaitez développer un projet de lampe connectée basée sur un ESP32-C5, vous allez exploiter les capacités de ce microcontrôleur pour créer un appareil compatible avec Home Assistant, en utilisant le protocole Matter sur Thread. Ce choix vous permet de concevoir un objet connecté sécurisé, interopérable et facilement intégrable dans un écosystème domotique existant. Je vous invite à lire mon tutoriel Intégrer un appareil Matter (Wi-Fi et Thread) dans Home Assistant.

Pour ce projet, vous partez de l’exemple MatterOnOffLight, fourni par Espressif. Cet exemple est spécialement conçu pour les applications de type “lampe connectée” et intègre la prise en charge du protocole Matter sur Thread, ce qui simplifie grandement l’intégration avec Home Assistant.

Essayons d’utiliser le schéma de partition Minimal pour ce programme :

Ce schéma de partition minimal.csv réserve une partition app0 de type app et de taille 0x140000 (1310720 octets) :

# Name,   Type, SubType, Offset,   Size, Flags
nvs,      data, nvs,     0x9000,   0x5000,
otadata,  data, ota,     0xe000,   0x2000,
app0,     app,  ota_0,   0x10000,  0x140000,
spiffs,   data, spiffs,  0x150000, 0xA0000,
coredump, data, coredump,0x1F0000, 0x10000,

# Name,   Type, SubType, Offset,   Size, Flags
nvs,      data, nvs,     0x9000,   0x5000,
otadata,  data, ota,     0xe000,   0x2000,
app0,     app,  ota_0,   0x10000,  0x140000,
spiffs,   data, spiffs,  0x150000, 0xA0000,
coredump, data, coredump,0x1F0000, 0x10000,

Une erreur apparaît lors de la compilation du programme. En effet, le programme compilé occupe 2193968 octets, ce qui est supérieur à la taille de la partition app configurée par le schéma de partition Minimal sélectionné (1310720 octets) :

Le croquis utilise 2193968 octets (167%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.

Le croquis utilise 2193968 octets (167%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.

Le fichier README de cet exemple indique bien qu’il faut sélectionner le schéma de partition Huge APP (3MB No OTA/1MB SPIFFS).

La partition app0 de type app est en effet bien configurée avec une taille 0x300000 (3145728 octets) dans le schéma de partition huge_app.csv :

# Name,   Type, SubType, Offset,  Size, Flags
nvs,      data, nvs,     0x9000,  0x5000,
otadata,  data, ota,     0xe000,  0x2000,
app0,     app,  ota_0,   0x10000, 0x300000,
spiffs,   data, spiffs,  0x310000,0xE0000,
coredump, data, coredump,0x3F0000,0x10000,

# Name,   Type, SubType, Offset,  Size, Flags
nvs,      data, nvs,     0x9000,  0x5000,
otadata,  data, ota,     0xe000,  0x2000,
app0,     app,  ota_0,   0x10000, 0x300000,
spiffs,   data, spiffs,  0x310000,0xE0000,
coredump, data, coredump,0x3F0000,0x10000,

Une fois compilé, le firmware occupe 2193976 octets de la mémoire flash. Ce qui est bien inférieur au maximum de 3145728 octets (3 Mo) réservé pour notre partition APP.

Le croquis utilise 2193976 octets (69%) de l'espace de stockage de programmes. Le maximum est de 3145728 octets.
Les variables globales utilisent 100740 octets (30%) de mémoire dynamique, ce qui laisse 226940 octets pour les variables locales. Le maximum est de 327680 octets.

Le croquis utilise 2193976 octets (69%) de l'espace de stockage de programmes. Le maximum est de 3145728 octets.
Les variables globales utilisent 100740 octets (30%) de mémoire dynamique, ce qui laisse 226940 octets pour les variables locales. Le maximum est de 327680 octets.

Vous voulez savoir combien de temps il vous reste avant l’arrivée de votre prochain bus ?

Si les panneaux d’affichage aux arrêts ou certaines applications smartphone permettent déjà de consulter ces informations, les avoir directement sur un petit écran dédié chez vous est encore plus pratique : vous pouvez partir au dernier moment et éviter toute attente inutile.

Dans cet article, je vous explique comment afficher en temps réel les horaires des prochains passages de bus à votre arrêt, directement sur un LilyGo T-Display.

Mais pour commencer, je vous invite à lire mon article d’introduction au LilyGo T-Display pour apprendre les bases de sa programmation.

Utilisation de la plateforme PRIM d’Île de France Mobilité

Île de France Mobilité met à disposition la Plateforme Régionale d’Information pour la Mobilité (PRIM). Elle rassemble de nombreuses données relatives à la mobilité en Île-de-France.

Il est nécessaire de vous créer un compte sur cette plateforme et de générer votre jeton authentification.

Il faut ensuite chercher les identifiants de l’arrêt et des lignes de bus et pour lesquelles vous souhaitez connaître les horaires des prochains passages :

• Les identifiants ID_Line de vos lignes de bus sont disponibles dans le référentiel des lignes
• L’identifiant ArRId de votre arrêt de bus est disponible dans le référentiel des arrêts

Exemple de recherche de l’identifiant de l’arrêt Pierre Semard dans la ville de Châtillon :

Il y a généralement deux arrêts qui portent le même nom. Afin de distinguer l’arrêt correspond au sens de circulation du bus pour atteindre votre destination, je vous conseille de chercher l’identifiant de l’arrêt à partir de la carte.

Exemple de recherche de l’identifiant de la ligne de bus 195 :

Une fois votre jeton d’authentification obtenu et l’identifiant de votre arrêt trouvé, vous pouvez interroger l’API PRIM pour récupérer les horaires des prochains passages de bus à cet arrêt.

Voici par exemple une commande curl permettant d’obtenir les prochains passages à l’arrêt Pierre Sémard (remplacez YOUR-TOKEN par votre clé API PRIM) :

curl -X 'GET' 'https://prim.iledefrance-mobilites.fr/marketplace/stop-monitoring?MonitoringRef=STIF:StopPoint:Q:28607:' -H 'accept: application/json' -H 'apikey: YOUR-TOKEN'

curl -X 'GET' 'https://prim.iledefrance-mobilites.fr/marketplace/stop-monitoring?MonitoringRef=STIF:StopPoint:Q:28607:' -H 'accept: application/json' -H 'apikey: YOUR-TOKEN'

Résultat affiché après l’exécution de la commande curl sous Linux :

La plateforme PRIM retourne les informations au format JSON. Vous trouvez dans le champ MonitoredStopVisit les informations relatives à l’arrêt (MonitoringRef). Dont la liste des bus avec leur identifiant de ligne (LineRef) ainsi que l’heure prévue du prochain départ (ExpectedDepartureTime).

Notez que les horaires sont fournis en heure universelle (UTC). Il conviendra donc d’ajuster ce horaire avec l’heure locale en prenant en compte le décalage entre l’heure d’été et l’heure d’hiver.

Le croquis pour IDE Arduino

Voici le croquis qui permet d’afficher les horaires des prochains passages des bus 195 et 388 l’arrêt Pierre Semard dans la ville de Chatillon.

// Recuperation des horaires des prochains passages de bus a un arret en Ile de France
// Les informations sont recuperees de la plateform PRIM geree par IdFM
// Affichage de ces informations sur un LilyGo T-Display
// https://tutoduino.fr/
// Copyleft 2025
#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <time.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <esp_sleep.h>
#include "secrets.h"
#include "line_mapping.h"
// Bouton qui permet de sortir de veille profonde
#define BUTTON_PIN 35
// Broches du ST7789 sur le LilyGo T-Display
#define TFT_MOSI 19
#define TFT_SCLK 18
#define TFT_CS 5
#define TFT_DC 16
#define TFT_RST 23
#define TFT_BL 4
// Objet sur l'ecran du LilyGo T-Display
Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
// Nombre de prochains passages a afficher
#define NB_BUS_DISPLAYED 3
// Nombre de prochains passages à lire dans la réponse du serveur PRIM
#define MAX_NB_BUS_SCHEDULE 6
// Structure pour stocker l'heure
struct myTime_t {
  int heure;
  int minute;
};
// Structure pour stocker les informations sur les prochains passages
struct busSchedule_t {
  String busLine;
  myTime_t busTime;
};
// URL du service, il doit etre completee par l'identifiant de l'arret de bus qui est stocke dans "secrets.h"
const char* serviceUrl = "https://prim.iledefrance-mobilites.fr/marketplace/stop-monitoring?MonitoringRef=";
// Variable globale utilisée pour la mise en veille
uint8_t loopCounter;
// ---------------------------------------------------------------------------
//  Vérifie si time1 est superieur ou egal a time2 (seulement heure/minute)
// ---------------------------------------------------------------------------
bool isMyTimeGreaterOrEqual(myTime_t time1, tm time2) {
  // Compare heures
  if (time1.heure != time2.tm_hour) {
    return time1.heure > time2.tm_hour;
  }
  // Heures égales → compare minutes
  return time1.minute >= time2.tm_min;
}
// ---------------------------------------------------------------------------
//  Synchronisation de l'heure NTP + fuseau France (DST auto)
// ---------------------------------------------------------------------------
void setupTime() {
  // Fuseau France normalisé : CET-1CEST,M3.5.0/2,M10.5.0/3
  configTzTime("CET-1CEST,M3.5.0/2,M10.5.0/3", "pool.ntp.org");
  Serial.println("Heure synchronisée (France)");
}
// ---------------------------------------------------------------------------
//  Convertit l'heure UTC en heure locale
// ---------------------------------------------------------------------------
myTime_t convertUTCtoLocal(myTime_t utcTime) {
  struct tm localTime = { 0 };
  char buffer[6];
  myTime_t myLocalTime;
  // Recuperation de l'heure locale en UTC pour vérifier si
  // nous sommes en heures d'hiver ou heure d'ete (isdst)
  if (!getLocalTime(&localTime)) {
    Serial.println("Erreur : impossible d'obtenir l'heure locale !");
    return utcTime;  // fallback
  }
  myLocalTime = utcTime;
  switch (localTime.tm_isdst) {
    case 0:  // heure d'hiver = UTC + 1
      myLocalTime.heure += 1;
      break;
    case 1:  // heure d'ete = UTC + 2
      myLocalTime.heure += 2;
      break;
    default:  // indetermine ou erreur, retourne l'heure UTC
      break;
  }
  // Gestion dépassement 24h
  if (myLocalTime.heure >= 24) {
    myLocalTime.heure -= 24;
  }
  if (myLocalTime.heure < 0) {
    myLocalTime.heure += 24;
  }
  return myLocalTime;
}
// ---------------------------------------------------------------------------
//  Extrait l'heure HH:MM d'une chaîne ISO 8601 "YYYY-MM-DDTHH:MM:SS.000Z"
// ---------------------------------------------------------------------------
myTime_t getTimeHHMM(const char* isoString) {
  myTime_t myTime;
  // JJ et MM sont a des positions fixes dans ISO 8601
  myTime.heure = (isoString[11] - '0') * 10 + (isoString[12] - '0');
  myTime.minute = (isoString[14] - '0') * 10 + (isoString[15] - '0');
  return myTime;
}
// -----------------------------------------------------------------------------
//  Appel de l'API PRIM pour obtenir les horaires des passages des prochains bus
//  Retourne le nombre d'horaires contenant des informations sur les lignes
//  qui nous interessent.
// -----------------------------------------------------------------------------
int getExpectedDepartureTime(busSchedule_t schedules[MAX_NB_BUS_SCHEDULE]) {
  // Nombre d'horaire retourné
  int nbScheduleInfo = 0;
  // Initialise les MAX_NB_BUS_SCHEDULE prochains bus
  for (int i = 0; i < MAX_NB_BUS_SCHEDULE; i++) {
    schedules[i].busLine = "";
    schedules[i].busTime.heure = 0;
    schedules[i].busTime.minute = 0;
  }
  // Verifie que le Wi-Fi est bien connecte
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("ERROR: Wi-Fi not connected.");
    return 0;
  }
  // Contruit la requete HTTP pour l'arret concerne
  HTTPClient http;
  String fullUrl = String(serviceUrl) + String(stopPointRef);
  http.begin(fullUrl);
  http.addHeader("apikey", apiKey);
  http.addHeader("accept", "application/json");
  // Envoir la requete et recupere la reponse (payload)
  int httpCode = http.GET();
  if (httpCode != HTTP_CODE_OK) {
    Serial.print("HTTP Error: ");
    Serial.println(httpCode);
    Serial.println(http.getString());
    http.end();
    return 0;
  }
  String payload = http.getString();
  http.end();
  Serial.println(payload);
  // La reponse au format JSON peut être volumineuse en fonction du nombre de lignes de bus a cet arret
  DynamicJsonDocument doc(40 * 1024);
  if (deserializeJson(doc, payload, DeserializationOption::NestingLimit(20))) {
    Serial.println("JSON parsing error !");
    return 0;
  }
  // Tableau de N elements contenant les informations sur le passage
  // dont le numero de la ligne et l'heure de départ
  JsonArray visits =
    doc["Siri"]["ServiceDelivery"]["StopMonitoringDelivery"][0]["MonitoredStopVisit"];
  // Recupere les informations (ligne de bus et heure de depart) pour les
  // prochains passages, en se limiant à MAX_NB_BUS_SCHEDULE elements
  for (JsonObject visit : visits) {
    if (nbScheduleInfo >= MAX_NB_BUS_SCHEDULE) {
      Serial.println("Maximum number of information collected, skip following ones");
      break;
    }
    // Identifiant de la ligne de bus
    const char* lineRef = visit["MonitoredVehicleJourney"]["LineRef"]["value"];
    // Horaire du prochain depart
    const char* expectedDepartureTime =
      visit["MonitoredVehicleJourney"]["MonitoredCall"]["ExpectedDepartureTime"];
    if (!lineRef || !expectedDepartureTime) {
      Serial.println("No data");
      continue;
    }
    // Vérifie que nous souhaitons les informations concernant cette ligne de bus
    bool isKnownLine = false;
    for (int i = 0; i < lineMappingsSize; i++) {
      if (lineMappings[i].ref == String(lineRef)) {
        isKnownLine = true;
        break;
      }
    }
    // Rertourner l'heure du prochain depart et le numero de la ligne si cette ligne
    // nous interesse
    if (isKnownLine) {
      schedules[nbScheduleInfo].busLine = mapLineRefToNumber(lineRef);
      schedules[nbScheduleInfo].busTime = convertUTCtoLocal(getTimeHHMM(expectedDepartureTime));
      nbScheduleInfo++;
    }
  }
  return nbScheduleInfo;
}
// -----------------------------------------------------------------------------
//  Mise en veille profonde de l'ESP32 et de l'ecran LCD
// -----------------------------------------------------------------------------
void enterDeepSleep() {
  // Configure la sortie de veille par appui sur bouton
  esp_sleep_enable_ext0_wakeup((gpio_num_t)BUTTON_PIN, LOW);
  // Éteindre écran et le mettre en veille
  digitalWrite(TFT_BL, LOW);
  tft.writeCommand(0x10);
  // Activer la veille profonde du microcontrolleur
  esp_deep_sleep_start();
}
// ---------------------------------------------------------------------------
//  SETUP
// ---------------------------------------------------------------------------
void setup() {
  Serial.begin(115200);
  delay(1000);
  // Le bouton est une entrée qui permet de sortir de veille
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  // Connexion Wi-Fi
  WiFi.begin(wifiSsid, wifiPassword);
  Serial.print("Connexion Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnecté au Wi-Fi");
  // Configure la recuperation de l'heure et le fuseau horaire
  setupTime();  // NTP + TZ
  // Allume le rétroéclairage
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);
  // Initialisation écran
  tft.init(135, 240);
  tft.setRotation(1);
  tft.setFont(&FreeSansBold18pt7b);
  delay(1000);
  loopCounter = 0;
}
// ---------------------------------------------------------------------------
//  BOUCLE PRINCIPALE
// ---------------------------------------------------------------------------
void loop() {
  busSchedule_t nextBuses[MAX_NB_BUS_SCHEDULE];
  struct tm timeinfo;
  char timeString[6];
  char buf[15];
  // Met l'ESP32 en veille profonde et eteind l'ecran
  // après 1 minutes (30 sec par loop)
  loopCounter++;
  if (loopCounter > 2) {
    enterDeepSleep();
  }
  tft.fillScreen(ST77XX_BLACK);
  // Affiche l'heure locale
  if (getLocalTime(&timeinfo)) {
    strftime(timeString, sizeof(timeString), "%H:%M", &timeinfo);
    Serial.print("Heure locale: ");
    Serial.println(timeString);
    tft.setTextColor(ST77XX_WHITE);
    tft.setCursor(70, 25);
    tft.print(timeString);
    tft.drawLine(0, 32, 240, 32, ST77XX_WHITE);
  }
  // Récupère les horaires des prochains bus
  int numBuses = getExpectedDepartureTime(nextBuses);
  Serial.printf("numBuses = %d\n", numBuses);
  if (numBuses > MAX_NB_BUS_SCHEDULE) {
    Serial.printf("Erreur\n");
    return;
  }
  // Affichage de la ligne et de l'heure de départ des prochains bus
  // Le nombre de bus affiches est limite a NB_BUS_DISPLAYED
  // Seuls les bus dont l'horaire de depart est posterieur a
  // l'heure courante sont affiches
  int nbBusDisplayed = 0;
  int nbBus = 0;
  while ((nbBus <= numBuses) && (nbBusDisplayed < NB_BUS_DISPLAYED)) {
    // N'affiche que les bus dont l'heure de depart est superieur a l'heure actuelle
    if (isMyTimeGreaterOrEqual(nextBuses[nbBus].busTime, timeinfo)) {
      Serial.printf("Ligne %s  %02d:%02d\n",
                    nextBuses[nbBus].busLine,
                    nextBuses[nbBus].busTime.heure,
                    nextBuses[nbBus].busTime.minute);
      snprintf(buf, sizeof(buf), "%s  %02d:%02d",
               nextBuses[nbBus].busLine, nextBuses[nbBus].busTime.heure, nextBuses[nbBus].busTime.minute);
      tft.setTextColor(ST77XX_CYAN);
      tft.setCursor(0, 65 + 30 * nbBusDisplayed);
      tft.print(buf);
      nbBusDisplayed++;
    }
    nbBus++;
  }
  // Réactualise toutes les 30 secondes
  delay(30 * 1000);
}

// Recuperation des horaires des prochains passages de bus a un arret en Ile de France
// Les informations sont recuperees de la plateform PRIM geree par IdFM
// Affichage de ces informations sur un LilyGo T-Display
// https://tutoduino.fr/
// Copyleft 2025

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <time.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <esp_sleep.h>
#include "secrets.h"
#include "line_mapping.h"

// Bouton qui permet de sortir de veille profonde
#define BUTTON_PIN 35

// Broches du ST7789 sur le LilyGo T-Display
#define TFT_MOSI 19
#define TFT_SCLK 18
#define TFT_CS 5
#define TFT_DC 16
#define TFT_RST 23
#define TFT_BL 4

// Objet sur l'ecran du LilyGo T-Display
Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);

// Nombre de prochains passages a afficher
#define NB_BUS_DISPLAYED 3
// Nombre de prochains passages à lire dans la réponse du serveur PRIM
#define MAX_NB_BUS_SCHEDULE 6

// Structure pour stocker l'heure
struct myTime_t {
  int heure;
  int minute;
};

// Structure pour stocker les informations sur les prochains passages
struct busSchedule_t {
  String busLine;
  myTime_t busTime;
};

// URL du service, il doit etre completee par l'identifiant de l'arret de bus qui est stocke dans "secrets.h"
const char* serviceUrl = "https://prim.iledefrance-mobilites.fr/marketplace/stop-monitoring?MonitoringRef=";

// Variable globale utilisée pour la mise en veille
uint8_t loopCounter;


// ---------------------------------------------------------------------------
//  Vérifie si time1 est superieur ou egal a time2 (seulement heure/minute)
// ---------------------------------------------------------------------------
bool isMyTimeGreaterOrEqual(myTime_t time1, tm time2) {
  // Compare heures
  if (time1.heure != time2.tm_hour) {
    return time1.heure > time2.tm_hour;
  }

  // Heures égales → compare minutes
  return time1.minute >= time2.tm_min;
}

// ---------------------------------------------------------------------------
//  Synchronisation de l'heure NTP + fuseau France (DST auto)
// ---------------------------------------------------------------------------
void setupTime() {
  // Fuseau France normalisé : CET-1CEST,M3.5.0/2,M10.5.0/3
  configTzTime("CET-1CEST,M3.5.0/2,M10.5.0/3", "pool.ntp.org");
  Serial.println("Heure synchronisée (France)");
}

// ---------------------------------------------------------------------------
//  Convertit l'heure UTC en heure locale
// ---------------------------------------------------------------------------
myTime_t convertUTCtoLocal(myTime_t utcTime) {
  struct tm localTime = { 0 };
  char buffer[6];
  myTime_t myLocalTime;

  // Recuperation de l'heure locale en UTC pour vérifier si
  // nous sommes en heures d'hiver ou heure d'ete (isdst)
  if (!getLocalTime(&localTime)) {
    Serial.println("Erreur : impossible d'obtenir l'heure locale !");
    return utcTime;  // fallback
  }

  myLocalTime = utcTime;

  switch (localTime.tm_isdst) {
    case 0:  // heure d'hiver = UTC + 1
      myLocalTime.heure += 1;
      break;
    case 1:  // heure d'ete = UTC + 2
      myLocalTime.heure += 2;
      break;
    default:  // indetermine ou erreur, retourne l'heure UTC
      break;
  }

  // Gestion dépassement 24h
  if (myLocalTime.heure >= 24) {
    myLocalTime.heure -= 24;
  }
  if (myLocalTime.heure < 0) {
    myLocalTime.heure += 24;
  }

  return myLocalTime;
}

// ---------------------------------------------------------------------------
//  Extrait l'heure HH:MM d'une chaîne ISO 8601 "YYYY-MM-DDTHH:MM:SS.000Z"
// ---------------------------------------------------------------------------
myTime_t getTimeHHMM(const char* isoString) {

  myTime_t myTime;

  // JJ et MM sont a des positions fixes dans ISO 8601
  myTime.heure = (isoString[11] - '0') * 10 + (isoString[12] - '0');
  myTime.minute = (isoString[14] - '0') * 10 + (isoString[15] - '0');

  return myTime;
}

// -----------------------------------------------------------------------------
//  Appel de l'API PRIM pour obtenir les horaires des passages des prochains bus
//  Retourne le nombre d'horaires contenant des informations sur les lignes
//  qui nous interessent.
// -----------------------------------------------------------------------------
int getExpectedDepartureTime(busSchedule_t schedules[MAX_NB_BUS_SCHEDULE]) {

  // Nombre d'horaire retourné
  int nbScheduleInfo = 0;

  // Initialise les MAX_NB_BUS_SCHEDULE prochains bus
  for (int i = 0; i < MAX_NB_BUS_SCHEDULE; i++) {
    schedules[i].busLine = "";
    schedules[i].busTime.heure = 0;
    schedules[i].busTime.minute = 0;
  }

  // Verifie que le Wi-Fi est bien connecte
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("ERROR: Wi-Fi not connected.");
    return 0;
  }

  // Contruit la requete HTTP pour l'arret concerne
  HTTPClient http;
  String fullUrl = String(serviceUrl) + String(stopPointRef);
  http.begin(fullUrl);
  http.addHeader("apikey", apiKey);
  http.addHeader("accept", "application/json");

  // Envoir la requete et recupere la reponse (payload)
  int httpCode = http.GET();
  if (httpCode != HTTP_CODE_OK) {
    Serial.print("HTTP Error: ");
    Serial.println(httpCode);
    Serial.println(http.getString());
    http.end();
    return 0;
  }

  String payload = http.getString();
  http.end();

  Serial.println(payload);

  // La reponse au format JSON peut être volumineuse en fonction du nombre de lignes de bus a cet arret
  DynamicJsonDocument doc(40 * 1024);

  if (deserializeJson(doc, payload, DeserializationOption::NestingLimit(20))) {
    Serial.println("JSON parsing error !");
    return 0;
  }

  // Tableau de N elements contenant les informations sur le passage
  // dont le numero de la ligne et l'heure de départ
  JsonArray visits =
    doc["Siri"]["ServiceDelivery"]["StopMonitoringDelivery"][0]["MonitoredStopVisit"];


  // Recupere les informations (ligne de bus et heure de depart) pour les
  // prochains passages, en se limiant à MAX_NB_BUS_SCHEDULE elements
  for (JsonObject visit : visits) {
    if (nbScheduleInfo >= MAX_NB_BUS_SCHEDULE) {
      Serial.println("Maximum number of information collected, skip following ones");
      break;
    }
    // Identifiant de la ligne de bus
    const char* lineRef = visit["MonitoredVehicleJourney"]["LineRef"]["value"];
    // Horaire du prochain depart
    const char* expectedDepartureTime =
      visit["MonitoredVehicleJourney"]["MonitoredCall"]["ExpectedDepartureTime"];

    if (!lineRef || !expectedDepartureTime) {
      Serial.println("No data");
      continue;
    }

    // Vérifie que nous souhaitons les informations concernant cette ligne de bus
    bool isKnownLine = false;
    for (int i = 0; i < lineMappingsSize; i++) {
      if (lineMappings[i].ref == String(lineRef)) {
        isKnownLine = true;
        break;
      }
    }

    // Rertourner l'heure du prochain depart et le numero de la ligne si cette ligne
    // nous interesse
    if (isKnownLine) {
      schedules[nbScheduleInfo].busLine = mapLineRefToNumber(lineRef);
      schedules[nbScheduleInfo].busTime = convertUTCtoLocal(getTimeHHMM(expectedDepartureTime));
      nbScheduleInfo++;
    }
  }

  return nbScheduleInfo;
}

// -----------------------------------------------------------------------------
//  Mise en veille profonde de l'ESP32 et de l'ecran LCD
// -----------------------------------------------------------------------------
void enterDeepSleep() {
  // Configure la sortie de veille par appui sur bouton
  esp_sleep_enable_ext0_wakeup((gpio_num_t)BUTTON_PIN, LOW);

  // Éteindre écran et le mettre en veille
  digitalWrite(TFT_BL, LOW);
  tft.writeCommand(0x10);

  // Activer la veille profonde du microcontrolleur
  esp_deep_sleep_start();
}

// ---------------------------------------------------------------------------
//  SETUP
// ---------------------------------------------------------------------------
void setup() {

  Serial.begin(115200);
  delay(1000);

  // Le bouton est une entrée qui permet de sortir de veille
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  // Connexion Wi-Fi
  WiFi.begin(wifiSsid, wifiPassword);
  Serial.print("Connexion Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnecté au Wi-Fi");

  // Configure la recuperation de l'heure et le fuseau horaire
  setupTime();  // NTP + TZ

  // Allume le rétroéclairage
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);

  // Initialisation écran
  tft.init(135, 240);
  tft.setRotation(1);
  tft.setFont(&FreeSansBold18pt7b);
  delay(1000);

  loopCounter = 0;
}


// ---------------------------------------------------------------------------
//  BOUCLE PRINCIPALE
// ---------------------------------------------------------------------------
void loop() {

  busSchedule_t nextBuses[MAX_NB_BUS_SCHEDULE];
  struct tm timeinfo;
  char timeString[6];
  char buf[15];

  // Met l'ESP32 en veille profonde et eteind l'ecran
  // après 1 minutes (30 sec par loop)
  loopCounter++;
  if (loopCounter > 2) {
    enterDeepSleep();
  }

  tft.fillScreen(ST77XX_BLACK);

  // Affiche l'heure locale
  if (getLocalTime(&timeinfo)) {
    strftime(timeString, sizeof(timeString), "%H:%M", &timeinfo);
    Serial.print("Heure locale: ");
    Serial.println(timeString);
    tft.setTextColor(ST77XX_WHITE);
    tft.setCursor(70, 25);
    tft.print(timeString);
    tft.drawLine(0, 32, 240, 32, ST77XX_WHITE);
  }

  // Récupère les horaires des prochains bus
  int numBuses = getExpectedDepartureTime(nextBuses);

  Serial.printf("numBuses = %d\n", numBuses);
  if (numBuses > MAX_NB_BUS_SCHEDULE) {
    Serial.printf("Erreur\n");
    return;
  }

  // Affichage de la ligne et de l'heure de départ des prochains bus
  // Le nombre de bus affiches est limite a NB_BUS_DISPLAYED
  // Seuls les bus dont l'horaire de depart est posterieur a
  // l'heure courante sont affiches
  int nbBusDisplayed = 0;
  int nbBus = 0;
  while ((nbBus <= numBuses) && (nbBusDisplayed < NB_BUS_DISPLAYED)) {
    // N'affiche que les bus dont l'heure de depart est superieur a l'heure actuelle
    if (isMyTimeGreaterOrEqual(nextBuses[nbBus].busTime, timeinfo)) {
      Serial.printf("Ligne %s  %02d:%02d\n",
                    nextBuses[nbBus].busLine,
                    nextBuses[nbBus].busTime.heure,
                    nextBuses[nbBus].busTime.minute);

      snprintf(buf, sizeof(buf), "%s  %02d:%02d",
               nextBuses[nbBus].busLine, nextBuses[nbBus].busTime.heure, nextBuses[nbBus].busTime.minute);
      tft.setTextColor(ST77XX_CYAN);
      tft.setCursor(0, 65 + 30 * nbBusDisplayed);
      tft.print(buf);
      nbBusDisplayed++;
    }
    nbBus++;
  }

  // Réactualise toutes les 30 secondes
  delay(30 * 1000);
}

Les identifiants de votre arrêt de bus ainsi que ceux des lignes à surveiller doivent être renseignés dans le fichier line_mapping.h.

#ifndef LINEMAPPING_H
#define LINEMAPPING_H
#include <Arduino.h>  // pour String
// Identifiant de l'arret
const char* stopPointRef = "STIF:StopPoint:Q:28607:";
// Structure pour stocker le mapping
struct LineMapping {
  String ref;     // LineRef PRIM
  String number;  // numero de la ligne
};
// Tableau de correspondance entre les references PRIM des lignes et le numero des lignes
static const LineMapping lineMappings[] = {
  // Cette table contient la liste des lignes de bus s'arretant a l'arret stop_point_ref
  // et dont vous souhaitez les horaires des prochains passages
  { "STIF:Line::C01215:", "195" },
  { "STIF:Line::C01314:", "388" },
};
// Taille du tableau
static const int lineMappingsSize = sizeof(lineMappings) / sizeof(LineMapping);
// Fonction pour récupérer le numéro public de la ligne de bus à partir de son identifiant LineRef
inline String mapLineRefToNumber(const String& lineRef) {
  for (int i = 0; i < lineMappingsSize; i++) {
    if (lineMappings[i].ref == lineRef) {
      return lineMappings[i].number;
    }
  }
  return "XXX";  // inconnu
}
#endif  // LINEMAPPING_H

#ifndef LINEMAPPING_H
#define LINEMAPPING_H

#include <Arduino.h>  // pour String

// Identifiant de l'arret
const char* stopPointRef = "STIF:StopPoint:Q:28607:";

// Structure pour stocker le mapping
struct LineMapping {
  String ref;     // LineRef PRIM
  String number;  // numero de la ligne
};

// Tableau de correspondance entre les references PRIM des lignes et le numero des lignes
static const LineMapping lineMappings[] = {
  // Cette table contient la liste des lignes de bus s'arretant a l'arret stop_point_ref
  // et dont vous souhaitez les horaires des prochains passages
  { "STIF:Line::C01215:", "195" },
  { "STIF:Line::C01314:", "388" },
};

// Taille du tableau
static const int lineMappingsSize = sizeof(lineMappings) / sizeof(LineMapping);

// Fonction pour récupérer le numéro public de la ligne de bus à partir de son identifiant LineRef
inline String mapLineRefToNumber(const String& lineRef) {
  for (int i = 0; i < lineMappingsSize; i++) {
    if (lineMappings[i].ref == lineRef) {
      return lineMappings[i].number;
    }
  }
  return "XXX";  // inconnu
}

#endif  // LINEMAPPING_H

Il est recommandé de stocker votre jeton d’authentification PRIM ainsi que le SSID et le mot de passe de votre réseau Wi-Fi dans le fichier secrets.h.

Mon programme utilise les librairies suivantes avec l’IDE Arduino :

• ArduinoJSON
• Adafruit-ST7735
• Adafruit-GFX

Exemple d’affichage sur le LilyGo T-Display des prochains passages à l’arrêt Pierre Sémard, à Châtillon, pour les lignes 195 et 388.

Quota de requêtes sur une API PRIM

Le nombre de requêtes par API sur la plateforme PRIM est limité, et le suivi de votre consommation est disponible sur cette page.

Par exemple, le nombre de requêtes unitaires pour récupérer les horaires des prochains passages est limité à 500 par jour (il s’agit de quota journalier).

Il est cependant possible d’augmenter ce quota pour cette API.

Le code de ce projet est disponible sur mon GitHub.

Le LILYGO T-Display est une carte de développement basée sur un microcontrôleur ESP32, équipée d’un écran LCD ST7789V de 1.14″ offrant une résolution de 135 x 240 pixels.

Schéma des broches

Voici la schéma des broches de la carte, qui met en évidence les broches utilisées la communication SPI avec l’écran ST7789 (MOSI, SCLK, CS, DC, RST) ainsi que la commande du rétroéclairage via la broche GPIO4.

Installation du gestionnaire de cartes ESP32

La carte étant basé sur le microcontrôleur ESP32 il faut installer le support des cartes Espressif ESP32 dans l’IDE Arduino.

Dans le menu préférences de l’IDE Arduino, ajoutez l’URL suivante dans le gestionnaire de carte :

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

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

Voici une capture d’écran des étapes à suivre :

Installez le paquet de gestion de cartes esp32 de Espressif Systems.

Une fois le gestionnaire de cartes installé, sélectionnez la carte LilyGo T-Display dans la liste des cartes esp32 disponibles.

Installation des librairies pour l’écran LCD

Installez la librairie Adafruit ST7735 and ST7789 Library.

Afficher un texte sur l’écran du LilyGo T-Display

Pour vérifier que les bibliothèques et la configuration de la carte sont correctement installées, nous allons afficher un message de test sur l’écran à l’aide du code suivant :

// LilyGo T-Display
// https://tutoduino.fr/
// Copyleft 2025
#include <Adafruit_GFX.h>             // Core graphics library
#include <Adafruit_ST7789.h>          // Hardware-specific library for ST7789
#include <Fonts/FreeSansBold18pt7b.h> // GFX Font
// ST7789 pinout on LilyGo T-Display
#define TFT_MOSI  19
#define TFT_SCLK  18
#define TFT_CS    5
#define TFT_DC    16
#define TFT_RST   23
#define TFT_BL    4
Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
void setup() {
  // Turn on backlight
  pinMode(TFT_BL, OUTPUT);      
  digitalWrite(TFT_BL, HIGH);
  // Init ST7789 135x240 resolution
  tft.init(135, 240); 
  // Display text
  tft.setRotation(1);
  tft.setFont(&FreeSansBold18pt7b);
  tft.setCursor(30, 70);
  tft.fillScreen(ST77XX_BLACK);
  tft.setTextColor(ST77XX_CYAN);
  tft.write("Tutoduino");
}
void loop() {
  delay(1000);
}

// LilyGo T-Display
// https://tutoduino.fr/
// Copyleft 2025

#include <Adafruit_GFX.h>             // Core graphics library
#include <Adafruit_ST7789.h>          // Hardware-specific library for ST7789
#include <Fonts/FreeSansBold18pt7b.h> // GFX Font

// ST7789 pinout on LilyGo T-Display
#define TFT_MOSI  19
#define TFT_SCLK  18
#define TFT_CS    5
#define TFT_DC    16
#define TFT_RST   23
#define TFT_BL    4

Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);

void setup() {

  // Turn on backlight
  pinMode(TFT_BL, OUTPUT);      
  digitalWrite(TFT_BL, HIGH);

  // Init ST7789 135x240 resolution
  tft.init(135, 240); 

  // Display text
  tft.setRotation(1);
  tft.setFont(&FreeSansBold18pt7b);
  tft.setCursor(30, 70);
  tft.fillScreen(ST77XX_BLACK);
  tft.setTextColor(ST77XX_CYAN);
  tft.write("Tutoduino");
}

void loop() {
  delay(1000);
}

Une fois le code compilé et téléversé sur le TTGO, et si tout s’est bien déroulé, vous devriez voir s’afficher Tutoduino sur son écran.

Pour aller plus loin, découvrez mon tutoriel complet sur l’affichage en temps réel des horaires de bus Île-de-France avec le LilyGo T-Display.

Dans mon tutoriel précédent Créer un capteur de température Zigbee sur batterie avec un ESP32C6, j’explique en détail comment programmer un capteur de température, basé sur un microcontrôleur ESP32-C6 et un capteur BME280, communiquant via le protocole Zigbee avec son serveur Home Assistant.

Dans ce nouveau tutoriel, je vous montre comment configurer ce capteur avec ESPHome. ESPHome est un framework open-source qui permet de générer le firmware de microcontrôleur comme les ESP32 ou ESP8266 à partir de simples fichiers de configuration YAML, sans nécessiter la moindre compétence en programmation.

Comme la prise en charge de Zigbee n’est pas encore intégrée à ESPHome, le capteur communiquera avec le serveur Home Assistant via Wi-Fi.

Le capteur fonctionnant sur batterie, j’ai concentré mes efforts sur l’optimisation de sa consommation énergétique.

Voici la configuration permettant au capteur de relever la température, la pression et l’hygrométrie toutes les 15 minutes, puis de transmettre ces données au serveur Home Assistant via le Wi-Fi :

esphome:
  name: capteur-temp-esp32c6
  friendly_name: capteur-temp-esp32c6   
esp32:
  board: esp32-c6-devkitc-1
  framework:
    type: esp-idf
# Enable logging only for warnings
logger:
  level: WARN
# Enable Home Assistant API
api:
  encryption:
    key: "your-key"
ota:
  - platform: esphome
    password: "your-pwd"
wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  fast_connect: true  # Disable Wi-Fi scanning, direct connection to ssid  
  on_connect:
    # Update sensors
    - component.update: bme280_measure
    - component.update: battery_voltage    
    - delay: 5s  # Delay to ensure that data is sent to HA
    - deep_sleep.enter: deep_sleep_1    
switch:
  - platform: gpio
    pin: GPIO3
    id: rf_switch
    name: "RF Switch"
    internal: true    
    restore_mode: ALWAYS_OFF
  - platform: gpio
    pin: GPIO14
    id: antenna_select
    name: "Antenna Select"
    internal: true    
    restore_mode: ALWAYS_ON # Uses external antenna
i2c:
  sda: GPIO22
  scl: GPIO23
  scan: False
sensor:
  - platform: bme280_i2c
    id: bme280_measure
    temperature:
      name: "Temperature BME280"
    pressure:
      name: "Pressure BME280"
    humidity:
      name: "Humidity BME280"
    address: 0x76
    update_interval: never    
  - platform: adc
    pin: GPIO0
    name: "Battery Voltage"
    id: battery_voltage
    update_interval: never
    attenuation: 12db  # For ADC inputs > 1.1V (extends range to ~2.45V)
    filters:
      - multiply: 2.0  # Voltage divider (div 2) compensation
# Deep sleep configuration to save power
deep_sleep:
  id: deep_sleep_1
  sleep_duration: 15min  # Sleep duration between wake-ups

esphome:
  name: capteur-temp-esp32c6
  friendly_name: capteur-temp-esp32c6   

esp32:
  board: esp32-c6-devkitc-1
  framework:
    type: esp-idf

# Enable logging only for warnings
logger:
  level: WARN

# Enable Home Assistant API
api:
  encryption:
    key: "your-key"

ota:
  - platform: esphome
    password: "your-pwd"

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  fast_connect: true  # Disable Wi-Fi scanning, direct connection to ssid  
  on_connect:
    # Update sensors
    - component.update: bme280_measure
    - component.update: battery_voltage    
    - delay: 5s  # Delay to ensure that data is sent to HA
    - deep_sleep.enter: deep_sleep_1    

switch:
  - platform: gpio
    pin: GPIO3
    id: rf_switch
    name: "RF Switch"
    internal: true    
    restore_mode: ALWAYS_OFF

  - platform: gpio
    pin: GPIO14
    id: antenna_select
    name: "Antenna Select"
    internal: true    
    restore_mode: ALWAYS_ON # Uses external antenna

i2c:
  sda: GPIO22
  scl: GPIO23
  scan: False

sensor:
  - platform: bme280_i2c
    id: bme280_measure
    temperature:
      name: "Temperature BME280"
    pressure:
      name: "Pressure BME280"
    humidity:
      name: "Humidity BME280"
    address: 0x76
    update_interval: never    

  - platform: adc
    pin: GPIO0
    name: "Battery Voltage"
    id: battery_voltage
    update_interval: never
    attenuation: 12db  # For ADC inputs > 1.1V (extends range to ~2.45V)
    filters:
      - multiply: 2.0  # Voltage divider (div 2) compensation

# Deep sleep configuration to save power
deep_sleep:
  id: deep_sleep_1
  sleep_duration: 15min  # Sleep duration between wake-ups

Optimisation de la configuration Wi-Fi

Dans cette configuration ESPHome, la définition de fast_connect sur true permet de désactiver le scan du réseau Wi-Fi et ainsi accélérer la connexion à votre réseau :

fast_connect: true  # Disable Wi-Fi scanning, direct connection to ssid  
  

fast_connect: true  # Disable Wi-Fi scanning, direct connection to ssid  
  

Le bloc on_connect permet d’exécuter des actions dès que la connexion Wi-Fi est établie. L’instruction component.update déclenche la mise à jour du capteur concerné. Ainsi, les mesures du BME280 ainsi que la tension de la batterie sont actualisées automatiquement grâce à cette configuration :

on_connect:
  # Update sensors
  - component.update: bme280_measure
  - component.update: battery_voltage

on_connect:
  # Update sensors
  - component.update: bme280_measure
  - component.update: battery_voltage

Cette mise à jour est suivie d’une temporisation de 5 secondes, le temps nécessaire pour que le capteur transmette ses données au serveur Home Assistant via le Wi-Fi. L’ESP32-C6 entre ensuite en veille profonde afin de minimiser au maximum la consommation de la batterie.

   
- delay: 5s  # Delay to ensure that data is sent to HA
- deep_sleep.enter: deep_sleep_1    

   
- delay: 5s  # Delay to ensure that data is sent to HA
- deep_sleep.enter: deep_sleep_1    

Configuration de la veille profonde

Généralement la veille profonde (deep_sleep) est configurée par deux paramètres :

• run_duration : Durée pendant laquelle l’ESP32C6 doit être actif, c’est-à-dire exécuter du code.
• sleep_duration : La durée pendant laquelle l’ESP32C6 reste en mode de sommeil profond.

Ici, seul le paramètre sleep_duration est configuré. En effet, la durée d’activité ne doit pas être définie si l’on souhaite que l’ESP32C6 passe en veille profonde via l’instruction deep_sleep.enter.

# Deep sleep configuration to save power
deep_sleep:
  id: deep_sleep_1
  sleep_duration: 15min  # Sleep duration between wake-ups

# Deep sleep configuration to save power
deep_sleep:
  id: deep_sleep_1
  sleep_duration: 15min  # Sleep duration between wake-ups

Mesure de la puissance du signal Wi-Fi

Afin de valider la bonne réception du signal Wi-Fi par le capteur, il est utile de configurer la remontée du RSSI dans Home Assistant.

Cette information est fournie par ESPHome, et a pour unité le dBm, voir mon article “C’est quoi… un dBm ?” pour en savoir plus. Pour l’obtenir, il suffit de déclarer le capteur wifi_signal dans la configuration d’ESPHome :

sensor:
  - platform: wifi_signal
    name: "Signal WiFi"
    id: wifi_signal_strength
    update_interval: never  

sensor:
  - platform: wifi_signal
    name: "Signal WiFi"
    id: wifi_signal_strength
    update_interval: never  

Le rafraîchissement de la mesure est faite lorsque l’ESP32-C6 est connectée au réseau Wi-Fi :

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  fast_connect: true  # Disable Wi-Fi scanning, direct connection to ssid  
  on_connect:
    # Update sensors
    - component.update: bme280_measure
    - component.update: battery_voltage    
    - component.update: wifi_signal_strength                  
    - delay: 5s  # Delay to ensure that data is sent to HA
    - deep_sleep.enter: deep_sleep_1  

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  fast_connect: true  # Disable Wi-Fi scanning, direct connection to ssid  
  on_connect:
    # Update sensors
    - component.update: bme280_measure
    - component.update: battery_voltage    
    - component.update: wifi_signal_strength                  
    - delay: 5s  # Delay to ensure that data is sent to HA
    - deep_sleep.enter: deep_sleep_1  

Configuration de l’antenne externe

Comme expliqué dans la Getting Started de l’ESP32C6, l’activation de l’antenne externe nécessite une configuration spécifique. Par défaut, l’ESP32C6 utilise son antenne céramique interne pour le Wi-Fi.

Le choix entre l’antenne interne et une antenne externe se fait via la broche GPIO14.

• GPIO14 à l’état bas (paramètre par défaut) : l’appareil utilise l’antenne céramique intégrée.
• GPIO14 à l’état haut : l’appareil bascule vers l’antenne externe.

Pour que cette sélection soit effective, il faut d’abord placer la broche GPIO3 à l’état bas, ce qui active le contrôle du commutateur RF.

Voici la configuration pour utiliser une antenne externe :

switch:
  - platform: gpio
    pin: GPIO3
    id: rf_switch
    name: "RF Switch"
    internal: true    
    restore_mode: ALWAYS_OFF
  - platform: gpio
    pin: GPIO14
    id: antenna_select
    name: "Antenna Select"
    internal: true    
    restore_mode: ALWAYS_ON # Uses external antenna

switch:
  - platform: gpio
    pin: GPIO3
    id: rf_switch
    name: "RF Switch"
    internal: true    
    restore_mode: ALWAYS_OFF

  - platform: gpio
    pin: GPIO14
    id: antenna_select
    name: "Antenna Select"
    internal: true    
    restore_mode: ALWAYS_ON # Uses external antenna

Pour utiliser l’antenne interne, il faut configurer restore_mode sur ALWAYS_OFF pour la GPIO14.

La remontée du RSSI vers Home Assistant permet de confirmer l’apport bénéfique de l’usage d’une antenne externe.

Consommation électrique

La capture suivante illustre la consommation du capteur lorsqu’il sort de veille, effectue les mesures, les transmet au serveur Home Assistant via le Wi-Fi, puis retourne en veille profonde.

On observe que lorsque le capteur est actif et qu’il communique ses données au serveur Home Assistant en Wi-Fi, sa consommation oscille entre 26-54 mA. Lorsque l’ESP32C6 est en veille profonde, sa consommation est réduite à 23 μA.

Je vous invite à consulter mes autres tutoriels ESPHome : Intégrer un reTerminal E1002 dans Home Assistant avec ESPHome et Home Assistant : Afficher les données Météo-France sur un reTerminal E1001 avec ESPHome.

J’espère que ce tutoriel vous a été utile. N’hésitez pas à me faire part de votre avis en cliquant sur les étoiles ci-dessous ou en laissant un commentaire.

Avant d’aborder le concept de dBm (décibel-milliwatt), il est essentiel de comprendre le concept de décibel.

Le décibel (dB)

Le décibel (dB) est une unité logarithmique qui exprime le rapport entre deux puissances.

Par exemple, si nous avons 2 puissances P₁ = 100 mW et P₀ = 50 mW, le rapport entre ces deux puissances est de 2, ce qui correspond à environ 3 dB.

Vous entendez ou entendrez souvent parler de ce nombre -3 dB. En effet, diviser par deux la puissance d’un signal correspond à une diminution de 3 dB. On dit qu’une atténuation de -3 dB signifie une puissance du signal divisée par 2.

Le décibel-milliwatt (dBm)

Le dBm (décibel-milliwatt) est une unité utilisée pour mesurer la puissance d’un signal électrique, en prenant comme référence fixe une puissance de 1 milliwatt (mW).

Cette unité est très largement utilisé pour mesurer la puissance des signaux mobiles (3/4/5G, Wi-Fi, LoRa…) afin de garantir une bonne réception et des performances optimales.

Exemple sur Linux, la commande iwconfig vous indique les informations sur votre connexion Wi-Fi (carte réseau Wi-Fi wlp45s0 dans cet exemple). On y voit la puissance du signal reçue qui est de -63 dBm.

On voit que mon PC reçoit un signal Wi-Fi de bonne qualité (-63 dBm) me permettant un débit élevé (234 Mbit/s).

En approchant le PC de ma box internet, le signal est de bien meilleur qualité (- 31 dBm) et permet des débits supérieurs. Au contraire, le signal devient de mauvaise qualité (-80 dBm) lorsque j’éloigne le PC de ma box, et le débit s’effondre à 6,5 Mb/s.

Voici quelques exemples de puissance de signal reçu et leur interprétation :

Vous voyez que la distance entre l’émetteur et le récepteur joue un rôle considérable dans la puissance du signal reçu. En effet, la perte en puissance varie avec le carré de la distance. Aussi avec le doublement de la distance entre l’émetteur et le récepteur, la puissance reçue est divisée par 4. Cette perte dépend également de la fréquence du signal.

Exemple de calcul de puissance de réception d’un signal Wi-Fi

Prenons comme exemple une box internet placée à 10 mètres de mon ordinateur et qui émet sur la fréquence 2,4 GHz.

La perte liée à la distance se calcule avec la formule Free Space Path Loss (FSPL) :

avec d = distance en mètres ; f = fréquence du signal en hertz ; c = célérité de la lumière en mètre par seconde

En appliquant cette formule, nous calculons une perte de –60 dBm pour une distance de 10 m avec une fréquence de 2400000000 Hz.

La puissance d’émission de la livebox est 100 mW, soit +20 dBm. En effet, P_dB=10*log(100 mW/1 mW)=10*2=20 dBm.

Le signal à l’arrivée sera donc de -40 dBm (+20dBm – 60 dBm).

Vous trouverez sur le site sosh.fr des exemples d’atténuation liés aux matériaux (cloison de plâtre = -7 dBm, mur porteur = -15 dBm…).

Dans ce tutoriel, je vais vous montrer comment afficher les données de l’intégration Météo‑France de Home Assistant sur un reTerminal E1001 à l’aide du framework ESPHome. Vous apprendrez à récupérer les informations météorologiques (température, conditions, prévisions) depuis Home Assistant et à les afficher sur l’écran e‑paper du reTerminal.

Pour mieux comprendre la configuration du reTerminal et l’affichage d’informations issues de Home Assistant, je vous recommande la lecture de mon précédent tutoriel Intégrer un reTerminal E1002 dans Home Assistant avec ESPHome.

Intégration Météo-France de Home Assistant

Commencez par ajouter l’intégration Météo-France dans Home Assistant, puis sélectionnez la ville correspondant à votre lieu de résidence ou celle pour laquelle vous souhaitez obtenir les prévisions météorologiques (Nantes par exemple).

L’intégration Météo‑France prend en charge les deux plateformes suivantes dans Home Assistant : Weather et Sensor, qui permettent d’accéder aux conditions et prévisions météorologiques :

• Weather : fournit des données météorologiques complètes, incluant la météo actuelle, les prévisions horaires détaillées ainsi que les prévisions journalières sur 2 semaines.
• Sensor : expose une série de capteurs spécifiques qui délivrent des mesures précises sur les conditions locales. Parmi ces capteurs, on retrouve la température, la pression atmosphérique, la vitesse et la direction du vent, le taux d’humidité, la probabilité de neige, ainsi que les alertes météorologiques officielles.

Nous allons d’abord vérifier les informations fournies par cette intégration, en utilisant l’onglet « États » des Outils de développement. En saisissant weather.nantes comme filtre, vous pouvez constater que cette entité possède la condition météorologique (rainy) comme état et plusieurs attributs (temperature, humidity, etc.). Il s’agit ici des informations exposée par la plateforme Sensor de l’intégration Météo-France.

Pour accéder aux prévisions météo il faut récupérer les données de la plateforme Weather de l’intégration Météo-France. Pour cela il faut aller dans l’onglet Actions et exécuter l’action weather.get_forecasts sur l’entité weather.nantes et en indiquant le type daily (pour les prévisions journalières) ou hourly (pour les prévisions horaires).

Voici la configuration YAML de cette action pour récupérer les prévisions journalières :

action: weather.get_forecasts
entity_id: weather.nantes
data:
  type: daily
target:
  entity_id: weather.nantes

action: weather.get_forecasts
entity_id: weather.nantes
data:
  type: daily
target:
  entity_id: weather.nantes

Les données de la plateforme Weather de l’intégration Météo-France s’afficheront, incluant les prévisions météorologiques de prochains jours : condition, temperature (max), templow (min), precipitation, humidity.

Affichage de la température extérieure

Pour afficher la température extérieure, j’utilise la température actuelle fournie par la plateforme Sensor de l’intégration Météo-France.

L’entité temperature de l’intégration Météo-France n’est pas activée par défaut. Il faut donc l’activer dans la configuration de l’intégration. Notez l’identifiant de cette entité, qui dans cet exemple est : sensor.nantes_temperature.

Il faut déclarer cette entité en tant que capteur (sensor) dans la configuration YAML de ESPHome :

# Declaration du capteur home assistant sensor.nantes_temperature
sensor:
  - platform: homeassistant
    id: temperature_nantes
    entity_id: sensor.nantes_temperature

# Declaration du capteur home assistant sensor.nantes_temperature
sensor:
  - platform: homeassistant
    id: temperature_nantes
    entity_id: sensor.nantes_temperature

Vous pouvez afficher la valeur de ce capteur sur l’écran du reTerminal E1001 via la configuration ESPHome suivante :

it.printf(20, 50, id(myFont), "Temperature: %.1f °C", id(temperature_nantes).state);

it.printf(20, 50, id(myFont), "Temperature: %.1f °C", id(temperature_nantes).state);

Affichage de la température intérieure

Pour afficher la température intérieure, j’utilise le capteur interne STH40 du reTerminal.

Le microcontrôleur ESP32-S3 du reTerminal E1001 communique avec le capteur STH40 au travers d’un bus I2C. Son adresse I2C est 0x44, et le bus I2C utilise les broches suivantes :

• Serial Data (SDA) : GPIO19
• Serial Clock (SCL) : GPIO20

Voici la configuration YAML qui permet de récupérer la température et l’humidité depuis ce capteur, à copier juste après la ligne captive_portal: du fichier de configuration ESPHome :

# define I2C interface
i2c:
  sda: GPIO19
  scl: GPIO20
  scan: false
# temperature and humidity sensor
sensor:
  - platform: sht4x
    temperature:
      name: "Temperature"
      id: sht4x_temperature
    humidity:
      name: "Humidity"
      id: sht4x_humidity    
    address: 0x44
    update_interval: 60s

# define I2C interface
i2c:
  sda: GPIO19
  scl: GPIO20
  scan: false
# temperature and humidity sensor
sensor:
  - platform: sht4x
    temperature:
      name: "Temperature"
      id: sht4x_temperature
    humidity:
      name: "Humidity"
      id: sht4x_humidity    
    address: 0x44
    update_interval: 60s

Vous pouvez afficher la valeur de ce capteur sur l’écran du reTerminal E1001 via la configuration ESPHome suivante :

it.printf(10, 10, id(myFont), BLUE, "Temperature: %.1f°C", id(sht4x_temperature).state);  
it.printf(10, 40, id(myFont), BLUE, "Humidity: %.1f%%", id(sht4x_humidity).state); 

it.printf(10, 10, id(myFont), BLUE, "Temperature: %.1f°C", id(sht4x_temperature).state);  
it.printf(10, 40, id(myFont), BLUE, "Humidity: %.1f%%", id(sht4x_humidity).state); 

Notez que le formatage %.1f indique qu’il faut afficher la température en nombre flottant avec 1 chiffre derrière la virgule (ex: 18.1).

Affichage de la température d’une autre pièce

Pour afficher la température d’une autre pièce, ici ma serre, j’utilise un capteur de température externe connecté en Zigbee à mon routeur Home Assistant.

Il est très simple de récupérer la valeur de ce capteur, il suffit de repérer son ID d’identité (ici sensor.lumi_lumi_weather_temperature_2) dans la configuration Home Assistant.

Puis de déclarer ce capteur dans la configuration ESPHome.

sensor:
  - platform: homeassistant
    name: "Temperature Serre"
    entity_id: sensor.lumi_lumi_weather_temperature_2
    id: temperature_serre

sensor:
  - platform: homeassistant
    name: "Temperature Serre"
    entity_id: sensor.lumi_lumi_weather_temperature_2
    id: temperature_serre

Il est possible d’afficher les températures minimum et maximum mesurées par ce capteur au cours des dernières 48h. Il suffit d’ajouter une intégration de type Statistics (helper) :

Vous pouvez ensuite créer un capteur de statistiques en indiquant l’entité auquel la statistique va s’appliquer (ici notre capteur de température de la serre) :

Puis configurer la caractéristique de la statistique souhaitée (ici sa valeur minimale) :

Et enfin la configuration de ce capteur statistique. Ici par exemple nous configurons l’age maximum à 48h, c’est à dire que ce capteur statistique va stocker la température minimale de la serre sur les 48 dernières heure :

Affichage des prévisions journalières

Je souhaite afficher les prévisions météorologiques journalières, incluant le jour, la condition, la température minimale/maximale et les précipitations pour aujourd’hui et les quatre prochains jours.

Pour afficher les prévisions quotidiennes, il est nécessaire de modifier le fichier de configuration de Home Assistant (configuration.yaml) afin de créer une automatisation qui exécute l’action weather.get_forecasts, ainsi qu’un modèle de capteur personnalisé (template sensor) pour récupérer les données de prévision météo.

Voici un exemple de configuration du capteur meteo_jour_nantes et de son automatisation, qui récupère les prévisions météo (jour, températures minimales et maximales, et conditions) pour aujourd’hui et les trois prochains jours :

template:
  - trigger:
      - platform: time_pattern
        hours: /1
      - platform: homeassistant
        event: start
    action:
      - service: weather.get_forecasts
        data:
          type: hourly
        target:
          entity_id: weather.nantes
        response_variable: hourly
    sensor:
      - name: "Prévisions Météo"
        unique_id: previsions_meteo_nantes
        state: "{{ hourly['weather.nantes'].forecast[0] }}"
        attributes:
          forecast: "{{ hourly['weather.nantes'].forecast }}"
        availability: "{{ states('weather.nantes') not in ['unknown', 'unavailable', 'none'] }}"
  - sensor:
      - name: "Météo Jour Nantes"
        unique_id: meteo_jour_nantes
        state: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0] }}"
        attributes:
          # Jour_0
          condition0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].condition | default(0) }}"
          jour0: >
            {{ ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'][as_timestamp(state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].datetime) | timestamp_custom('%w', true) | int] }}
          temperature0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].temperature | float(0) }}"
          templow0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].templow | float(0) }}"
          precipitation0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].precipitation | float(0) }}"          
          # Jour_1
          condition1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].condition | default(0) }}"
          jour1: >
            {{ ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'][as_timestamp(state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].datetime) | timestamp_custom('%w', true) | int] }}
          temperature1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].temperature | float(0) }}"
          templow1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].templow | float(0) }}"
          precipitation1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].precipitation | float(0) }}"                    

template:
  - trigger:
      - platform: time_pattern
        hours: /1
      - platform: homeassistant
        event: start
    action:
      - service: weather.get_forecasts
        data:
          type: hourly
        target:
          entity_id: weather.nantes
        response_variable: hourly

    sensor:
      - name: "Prévisions Météo"
        unique_id: previsions_meteo_nantes
        state: "{{ hourly['weather.nantes'].forecast[0] }}"
        attributes:
          forecast: "{{ hourly['weather.nantes'].forecast }}"
        availability: "{{ states('weather.nantes') not in ['unknown', 'unavailable', 'none'] }}"

  - sensor:
      - name: "Météo Jour Nantes"
        unique_id: meteo_jour_nantes
        state: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0] }}"
        attributes:
          # Jour_0
          condition0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].condition | default(0) }}"
          jour0: >
            {{ ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'][as_timestamp(state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].datetime) | timestamp_custom('%w', true) | int] }}
          temperature0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].temperature | float(0) }}"
          templow0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].templow | float(0) }}"
          precipitation0: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[0].precipitation | float(0) }}"          
          # Jour_1
          condition1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].condition | default(0) }}"
          jour1: >
            {{ ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'][as_timestamp(state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].datetime) | timestamp_custom('%w', true) | int] }}
          temperature1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].temperature | float(0) }}"
          templow1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].templow | float(0) }}"
          precipitation1: "{{ state_attr('sensor.previsions_meteo_nantes','daily_forecast')[1].precipitation | float(0) }}"                    

Pour vérifier la bonne configuration de ces capteurs, redémarrer Home Assistant et vérifier leur état en utilisant l’outil de développement.

Notez que l’attribut « jour » est affiché sous forme de nom du jour de la semaine grâce à l’argument %A de la fonction timestamp_custom(). Consultez la documentation du composant Time pour plus de détails.

Une fois que les capteurs sont configurés dan Home Assistant, il faut les déclarer dans la configuration ESPHome.

Comme le jour et les conditions météorologiques sont fournies sous forme de texte (par exemple, « Lundi », « ensoleillé »), elles doivent être définies comme text_sensor.

text_sensor:
  - platform: homeassistant
    name: "Jour0"
    entity_id: sensor.meteo_jour_nantes
    attribute: jour0
    id: jour0
  - platform: homeassistant
    name: "Jour1"
    entity_id: sensor.meteo_jour_nantes
    attribute: jour1
    id: jour1
    name: "ConditionJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: condition0
    id: conditionJ0
  - platform: homeassistant
    name: "ConditionJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: condition1
    id: conditionJ1
  - platform: homeassistant    

text_sensor:
  - platform: homeassistant
    name: "Jour0"
    entity_id: sensor.meteo_jour_nantes
    attribute: jour0
    id: jour0
  - platform: homeassistant
    name: "Jour1"
    entity_id: sensor.meteo_jour_nantes
    attribute: jour1
    id: jour1
    name: "ConditionJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: condition0
    id: conditionJ0
  - platform: homeassistant
    name: "ConditionJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: condition1
    id: conditionJ1
  - platform: homeassistant    

Les températures minimales et maximales étant des valeurs à virgule flottante, elle doivent être définies comme sensor.

sensor:
  - platform: homeassistant
    name: "TemperatureJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: temperature0
    id: temperatureJ0
    accuracy_decimals: 1  
  - platform: homeassistant
    name: "TemperatureJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: temperature1
    id: temperatureJ1
    accuracy_decimals: 1
    
  - platform: homeassistant
    name: "TemplowJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: templow0
    id: templowJ0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "TemplowJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: templow1
    id: templowJ1
    accuracy_decimals: 1
  - platform: homeassistant
    name: "PrecipitationJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: precipitation0
    id: precipitationJ0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "precipitationJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: precipitation1
    id: precipitationJ1
    accuracy_decimals: 1

sensor:
  - platform: homeassistant
    name: "TemperatureJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: temperature0
    id: temperatureJ0
    accuracy_decimals: 1  
  - platform: homeassistant
    name: "TemperatureJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: temperature1
    id: temperatureJ1
    accuracy_decimals: 1
    
  - platform: homeassistant
    name: "TemplowJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: templow0
    id: templowJ0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "TemplowJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: templow1
    id: templowJ1
    accuracy_decimals: 1


  - platform: homeassistant
    name: "PrecipitationJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: precipitation0
    id: precipitationJ0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "precipitationJ1"
    entity_id: sensor.meteo_jour_nantes
    attribute: precipitation1
    id: precipitationJ1
    accuracy_decimals: 1

Affichage des prévisions horaires

Nous souhaitons afficher les conditions météorologiques horaires, la température et les précipitations pour les douze prochaines heures.

Comme pour les prévisions quotidiennes, l’affichage des prévisions horaires nécessite de modifier le fichier de configuration de Home Assistant (configuration.yaml) afin de créer un capteur personnalisé meteo_heure_nantes et son automatisation :

Voici un exemple de configuration d’un capteur personnalisé et de son automatisation, qui récupère les prévision pour les heures H et H+1.

template:
  - trigger:
      - platform: time_pattern
        hours: /1
      - platform: homeassistant
        event: start
    action:
      - service: weather.get_forecasts
        data:
          type: hourly
        target:
          entity_id: weather.nantes
        response_variable: hourly
    sensor:
      - name: "Prévisions Météo"
        unique_id: previsions_meteo_nantes
        state: "{{ hourly['weather.nantes'].forecast[0] }}"
        attributes:
          forecast: "{{ hourly['weather.nantes'].forecast }}"
        availability: "{{ states('weather.nantes') not in ['unknown', 'unavailable', 'none'] }}"
  - sensor:
      - name: "Météo Heure Nantes"
        unique_id: meteo_heure_nantes
        state: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0] }}"
        attributes:
          # Heure_0
          condition0: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0].condition | default(0) }}"
          heure0: "{{ as_timestamp(state_attr('sensor.previsions_meteo_nantes','forecast')[0].datetime) | int(0) | timestamp_custom('%H:%M', true) }}"
          temperature0: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0].temperature | float(0) }}"
          precipitation0: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0].precipitation | float(0) }}"
          # Heure_1
          condition1: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[1].condition | default(0) }}"
          heure1: "{{ as_timestamp(state_attr('sensor.previsions_meteo_nantes','forecast')[1].datetime) | int(0) | timestamp_custom('%H:%M', true) }}"
          temperature1: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[1].temperature | float(0) }}"
          precipitation1: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[1].precipitation | float(0) }}"

template:
  - trigger:
      - platform: time_pattern
        hours: /1
      - platform: homeassistant
        event: start
    action:
      - service: weather.get_forecasts
        data:
          type: hourly
        target:
          entity_id: weather.nantes
        response_variable: hourly

    sensor:
      - name: "Prévisions Météo"
        unique_id: previsions_meteo_nantes
        state: "{{ hourly['weather.nantes'].forecast[0] }}"
        attributes:
          forecast: "{{ hourly['weather.nantes'].forecast }}"
        availability: "{{ states('weather.nantes') not in ['unknown', 'unavailable', 'none'] }}"

  - sensor:
      - name: "Météo Heure Nantes"
        unique_id: meteo_heure_nantes
        state: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0] }}"
        attributes:
          # Heure_0
          condition0: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0].condition | default(0) }}"
          heure0: "{{ as_timestamp(state_attr('sensor.previsions_meteo_nantes','forecast')[0].datetime) | int(0) | timestamp_custom('%H:%M', true) }}"
          temperature0: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0].temperature | float(0) }}"
          precipitation0: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[0].precipitation | float(0) }}"
          # Heure_1
          condition1: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[1].condition | default(0) }}"
          heure1: "{{ as_timestamp(state_attr('sensor.previsions_meteo_nantes','forecast')[1].datetime) | int(0) | timestamp_custom('%H:%M', true) }}"
          temperature1: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[1].temperature | float(0) }}"
          precipitation1: "{{ state_attr('sensor.previsions_meteo_nantes','forecast')[1].precipitation | float(0) }}"

Pour vérifier la bonne configuration de ces capteurs, redémarrer Home Assistant et vérifier leur état en utilisant l’outil de développement.

Notez que l’heure est au format heure locale grâce au second argument de timestamp_custom() positionné à true.

Une fois que les capteurs sont configurés dans Home Assistant, il faut les déclarer dans la configuration ESPHome.

Comme l’heure et les conditions météorologiques sont fournies sous forme de texte (par exemple, « 11:00 », « ensoleillé »), elles doivent être définies comme text_sensor.

text_sensor:
  - platform: homeassistant
    name: "Condition0"
    entity_id: sensor.meteo_heure_nantes
    attribute: condition0
    id: condition0
  - platform: homeassistant
    name: "Condition1"
    entity_id: sensor.meteo_heure_nantes
    attribute: condition1
    id: condition1
 
  - platform: homeassistant
    name: "Heure0"
    entity_id: sensor.meteo_heure_nantes
    attribute: heure0
    id: heure0
  - platform: homeassistant
    name: "Heure1"
    entity_id: sensor.meteo_heure_nantes
    attribute: heure1
    id: heure1    

text_sensor:
  - platform: homeassistant
    name: "Condition0"
    entity_id: sensor.meteo_heure_nantes
    attribute: condition0
    id: condition0
  - platform: homeassistant
    name: "Condition1"
    entity_id: sensor.meteo_heure_nantes
    attribute: condition1
    id: condition1
 
  - platform: homeassistant
    name: "Heure0"
    entity_id: sensor.meteo_heure_nantes
    attribute: heure0
    id: heure0
  - platform: homeassistant
    name: "Heure1"
    entity_id: sensor.meteo_heure_nantes
    attribute: heure1
    id: heure1    

Les précipitations et la température, étant des valeurs à virgule flottante, doivent être définies comme sensor.

Cet exemple illustre une configuration ESPHome pour des capteurs affichant la température et les précipitations pour les deux prochaines heures.

sensor:     
  - platform: homeassistant
    name: "Temperature0"
    entity_id: sensor.meteo_heure_nantes
    attribute: temperature0
    id: temperature0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "Temperature1"
    entity_id: sensor.meteo_heure_nantes
    attribute: temperature1
    id: temperature1
    accuracy_decimals: 1
    
  - platform: homeassistant
    name: "Precipitation0"
    entity_id: sensor.meteo_heure_nantes
    attribute: precipitation0
    id: precipitation0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "Precipitation1"
    entity_id: sensor.meteo_heure_nantes
    attribute: precipitation1
    id: precipitation1
    accuracy_decimals: 1

sensor:     
  - platform: homeassistant
    name: "Temperature0"
    entity_id: sensor.meteo_heure_nantes
    attribute: temperature0
    id: temperature0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "Temperature1"
    entity_id: sensor.meteo_heure_nantes
    attribute: temperature1
    id: temperature1
    accuracy_decimals: 1
    
  - platform: homeassistant
    name: "Precipitation0"
    entity_id: sensor.meteo_heure_nantes
    attribute: precipitation0
    id: precipitation0
    accuracy_decimals: 1
  - platform: homeassistant
    name: "Precipitation1"
    entity_id: sensor.meteo_heure_nantes
    attribute: precipitation1
    id: precipitation1
    accuracy_decimals: 1

Vous pouvez ensuite afficher les valeurs de ces capteurs sur l’écran du reTerminal E1001 via la configuration ESPHome suivant :

// Condition meteo H0 (texte)
it.printf(100, 50, id(myFont), "%s", id(condition0).state.c_str());
// Precipitations H0 (float, avec une décimale)
it.printf(100, 100, id(myFont), "%.1f", id(precipitation0).state);
// Temperature H0 (float, pas de décimale)
it.printf(100, 150, id(myFont), "%.0f", id(temperature0).state);

// Condition meteo H0 (texte)
it.printf(100, 50, id(myFont), "%s", id(condition0).state.c_str());
// Precipitations H0 (float, avec une décimale)
it.printf(100, 100, id(myFont), "%.1f", id(precipitation0).state);
// Temperature H0 (float, pas de décimale)
it.printf(100, 150, id(myFont), "%.0f", id(temperature0).state);

Affichage de la charge de la batterie

Pour récupérer le niveau de batterie du reTerminal, il faut activer la mesure de la tension de la batterie en configurant le GPIO21 (VBAT ENABLE) lors du boot du reTerminal. La lecture s’effectue ensuite sur le GPIO1 (VBAT ADC), qui est relié en interne à la batterie via un circuit de mesure.

esphome:
  name: reterminal
  friendly_name: reTerminal
  on_boot:
    priority: 600
    then:
      - output.turn_on: bsp_battery_enable
      - delay: 500ms   
      
captive_portal:
output:
  - platform: gpio
    pin: GPIO21
    id: bsp_battery_enable
    
sensor:
  # ADC for battery voltage measurement
  - platform: adc
    pin: GPIO1
    name: "Battery Voltage"
    id: battery_voltage
    update_interval: 600s      
    attenuation: 12db
    filters:
      - multiply: 2.0  # Voltage divider compensation

esphome:
  name: reterminal
  friendly_name: reTerminal
  on_boot:
    priority: 600
    then:
      - output.turn_on: bsp_battery_enable
      - delay: 500ms   
      
captive_portal:

output:
  - platform: gpio
    pin: GPIO21
    id: bsp_battery_enable
    
sensor:
  # ADC for battery voltage measurement
  - platform: adc
    pin: GPIO1
    name: "Battery Voltage"
    id: battery_voltage
    update_interval: 600s      
    attenuation: 12db
    filters:
      - multiply: 2.0  # Voltage divider compensation

En lisant la valeur analogique sur ce GPIO1, nous récupérons la tension de la batterie interne. La documentation technique montre que la tension est mesurée à l’aide d’un pont diviseur de tension, il faut donc appliquer un filtre pour compenser la division de la tension par deux liée à ce pont diviseur constitué de 2 résistances de 10kΩ.

Il faut configurer l’atténuation à 12 dB pour les entrées ADC lorsque la tension mesurée dépasse 1,1 V sur GPIO1. Ce réglage permet à l’ADC de l’ESP32-C6 de mesurer avec précision des niveaux de tension plus élevés, en étendant la plage d’entrée au-delà du défaut (atténuation à 0 dB) de 0 à 1,1 V. Une atténuation de -12 dB permet de mesurer des tensions de 0 à 2.5 V. Voir la documentation de l’ESP32 ou d’ESPHome pour plus de détails.

La tension aux bornes de la batterie interne permet d’en déduire son niveau de charge. La batterie lithium est considérée comme déchargée si sa tension est inférieure à 3.3 V. Une batterie bien chargée lorsque sa tension est supérieure à 4.0 V.

Afficher la puissance du signal Wi-Fi

L’affichage de la puissance de réception du signal Wi-Fi par le reTerminal peut être utile.

Cette information est fournie par ESPHome, et a pour unité le dBm, voir mon article “C’est quoi… un dBm ?” pour en savoir plus. Pour l’obtenir, il suffit de déclarer le capteur wifi_signal dans la configuration d’ESPHome :

sensor:
  - platform: wifi_signal
    name: "Signal WiFi ReTerminal"
    id: wifi_signal_strength
    update_interval: never     

sensor:
  - platform: wifi_signal
    name: "Signal WiFi ReTerminal"
    id: wifi_signal_strength
    update_interval: never     

Comme le Wi-Fi n’est pas disponible au démarrage, j’ai décidé de mettre à jour sa mesure lorsque le reTerminal reçoit les prévisions météorologiques quotidiennes. À ce moment-là, la connexion Wi-Fi est déjà établie. C’est également à ce moment-là que je commence à actualiser l’affichage, voir plus loin dans le chapitre “Rafraîchissement de l’affichage“.

  - platform: homeassistant
    name: "Precipitation11"
    entity_id: sensor.meteo_heure_antony
    attribute: precipitation11
    id: precipitation11
    accuracy_decimals: 1
    on_value:
      then:
        # Refresh the wifi signal measure and e-paper display whenever this sensor updates (wifi connected)
        - delay: 5s        
        - component.update: wifi_signal_strength      
        - component.update: epaper_display 

  - platform: homeassistant
    name: "Precipitation11"
    entity_id: sensor.meteo_heure_antony
    attribute: precipitation11
    id: precipitation11
    accuracy_decimals: 1
    on_value:
      then:
        # Refresh the wifi signal measure and e-paper display whenever this sensor updates (wifi connected)
        - delay: 5s        
        - component.update: wifi_signal_strength      
        - component.update: epaper_display 

Affichage des icônes

J’ai choisi d’afficher les icônes en n’utilisant pas d’image mais plutôt la police materialdesignicons-webfont.ttf. Il faut télécharger cette police et la placer dans le répertoire fonts de ESPHome avec le module complémentaire File Editor par exemple. Pour choisir vos propres icônes, vous pouvez utiliser le site pictogrammers.com et noter la référence de l’icône souhaitée.

Il faut ensuite déclarer les glyph correspondant aux icônes dans la font. Ici par exemple sur une font de taille 20 nous souhaitons utiliser les icônes représentant une batterie, une goutte d’eau, un thermomètre et une horloge.

  - file: "fonts/materialdesignicons-webfont.ttf"
    id: icon_font_20
    size: 20
    glyphs:
      - "\U000F12A3" # battery
      - "\U000F058C" # water
      - "\U000F050F" # thermometer
      - "\U000F1442" # clock

  - file: "fonts/materialdesignicons-webfont.ttf"
    id: icon_font_20
    size: 20
    glyphs:
      - "\U000F12A3" # battery
      - "\U000F058C" # water
      - "\U000F050F" # thermometer
      - "\U000F1442" # clock

Ensuite vous pouvez afficher l’icône à partir de son code de cette façon :

      it.printf(0, 0+85, id(icon_font_20), "\U000F050F");  // icone thermometre

      it.printf(0, 0+85, id(icon_font_20), "\U000F050F");  // icone thermometre

Veille profonde

Le reTerminal E1001 est configuré pour être en veille profonde pendant 30 minutes. Au bout de ces 3à minutes, il se réveille pendant 30 secondes afin de récupérer les informations météo et mettre à jour son écran. Il retourne ensuite en veille profonde pour 30 minutes.

Cette veille profonde est configurée de la sorte dans le fichier de configuration YAML de ESPHome :

# Deep sleep configuration to save power
deep_sleep:
  id: deep_sleep_1              # ID for deep sleep component
  run_duration: 30s             # Time to stay awake after wake-up
  sleep_duration: 30min         # Time to sleep between wake-ups
  wakeup_pin: GPIO3             # GPIO pin to wake up device
  wakeup_pin_mode: INVERT_WAKEUP # Inverted wake-up logic

# Deep sleep configuration to save power
deep_sleep:
  id: deep_sleep_1              # ID for deep sleep component
  run_duration: 30s             # Time to stay awake after wake-up
  sleep_duration: 30min         # Time to sleep between wake-ups
  wakeup_pin: GPIO3             # GPIO pin to wake up device
  wakeup_pin_mode: INVERT_WAKEUP # Inverted wake-up logic

Rafraîchissement de l’affichage

Lors de la sortie de veille profonde du reTerminal, il adopte le même comportement qu’au démarrage. Il faut donc assurer une chronologie précise des événement. L’écran du reTerminal doit être rafraichi uniquement une fois que les données du capteur interne et de Home Assistant sont récupérées (le WiFi met du temps à s’activer et donc les données de Home Assistant ne sont pas disponible immédiatement au boot).

Mettre à jour au moment du boot la mesure de la tension de la batterie et la mesure du capteur interne de température et d’humidité :

  on_boot:
    priority: 600
    then:
      # Turn on the GPIO output that powers the battery measurement circuit
      - output.turn_on: bsp_battery_enable
      # Wait a short delay to allow power stabilization
      - delay: 500ms
      # Manually update battery sensors (voltage and percentage)
      - component.update: battery_voltage
      # Manually read the internal temperature/humidity sensor
      - component.update: sht4x_component

  on_boot:
    priority: 600
    then:
      # Turn on the GPIO output that powers the battery measurement circuit
      - output.turn_on: bsp_battery_enable
      # Wait a short delay to allow power stabilization
      - delay: 500ms
      # Manually update battery sensors (voltage and percentage)
      - component.update: battery_voltage
      # Manually read the internal temperature/humidity sensor
      - component.update: sht4x_component

Désactiver la mise à jour automatic (update_interval: never) pour le capteur interne ST4X :

  # Internal SHT4x temperature/humidity sensor
  - platform: sht4x            # Sensor platform
    id: sht4x_component         # ID for the component
    temperature:                # Temperature sensor
      name: "Temperature"       # Sensor name
      id: sht4x_temperature     # ID for temperature sensor
    humidity:                   # Humidity sensor
      name: "Humidity"          # Sensor name
      id: sht4x_humidity        # ID for humidity sensor
    address: 0x44               # I2C address
    update_interval: never      # Disable automatic updates (manual read only)

  # Internal SHT4x temperature/humidity sensor
  - platform: sht4x            # Sensor platform
    id: sht4x_component         # ID for the component
    temperature:                # Temperature sensor
      name: "Temperature"       # Sensor name
      id: sht4x_temperature     # ID for temperature sensor
    humidity:                   # Humidity sensor
      name: "Humidity"          # Sensor name
      id: sht4x_humidity        # ID for humidity sensor
    address: 0x44               # I2C address
    update_interval: never      # Disable automatic updates (manual read only)

Désactiver le rafraichissement automatique (update_interval: never) de l’écran :

display:
  - platform: waveshare_epaper
    id: epaper_display
    model: 7.50inv2
    cs_pin: GPIO10
    dc_pin: GPIO11
    reset_pin:
      number: GPIO12
      inverted: false
    busy_pin:
      number: GPIO13
      inverted: true
    update_interval: never

display:
  - platform: waveshare_epaper
    id: epaper_display
    model: 7.50inv2
    cs_pin: GPIO10
    dc_pin: GPIO11
    reset_pin:
      number: GPIO12
      inverted: false
    busy_pin:
      number: GPIO13
      inverted: true
    update_interval: never

Et enfin rafraîchir l’écran une fois qu’une donnée Home Assistant est reçue :

  - platform: homeassistant
    name: "TemperatureJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: temperature0
    id: temperatureJ0
    accuracy_decimals: 1
    on_value:
      then:
        # Refresh the e-paper display whenever this sensor updates
        - component.update: epaper_display      

  - platform: homeassistant
    name: "TemperatureJ0"
    entity_id: sensor.meteo_jour_nantes
    attribute: temperature0
    id: temperatureJ0
    accuracy_decimals: 1
    on_value:
      then:
        # Refresh the e-paper display whenever this sensor updates
        - component.update: epaper_display      

Conclusion

Grâce au reTerminal E1001 et à son intégration dans Home Assistant, j’ai enfin la station météo parfaitement adaptée à mes attentes. Le framework ESPHome demande une courte phase d’apprentissage pour en maîtriser les principes, mais une fois ces notions acquises, il se révèle remarquablement puissant et flexible.

L’ensemble de la configuration Home Assistant et ESPHome utilisée dans ce tutoriel est disponible sur mon GitHub.

Je vous recommande la lecture du test des reTerminal E1001 et E1002 et je remercie son auteur WarC0zes pour son aide sur le forum HACF.

J’espère que ce tutoriel vous aura intéressé. N’hésitez pas à donner votre avis en cliquant sur les étoiles ci-dessous ou en laissant un commentaire.

Seeed Studio vient de présenter le reTerminal E1002, un appareil prêt à l’emploi doté d’un boîtier métallique robuste et d’un écran e-paper couleur de 7,3″ affichant en 800×480 pixels. Basé sur un microcontrôleur ESP32-S3, il intègre plusieurs fonctionnalités matérielles : trois boutons, un buzzer, une LED de statut (en plus de la LED d’alimentation), un capteur de température et de pression, un microphone ainsi qu’un lecteur de carte MicroSD. L’ensemble est alimenté par une batterie interne de 2000 mAh offrant jusqu’à trois mois d’autonomie.

Cet appareil est particulièrement bien adapté pour l’affichage des données issues du capteur Zigbee que j’ai développé dans mon tutoriel Créer un capteur de température Zigbee sur batterie avec un ESP32C6 et que j’ai intégré à Home Assistant.

Le reTerminal E1002 peut être configuré et personnalisé en adoptant trois approches distinctes :

• Approche 1 : Visuelle (drag & drop), avec SenseCraft HMI
• Approche 2 : Par configuration déclarative (fichiers YAML), comme dans mon tutoriel Intégrer un reTerminal E1002 dans Home Assistant avec ESPHome
• Approche 3 : Par programmation (IDE Arduino, C/C++)

C’est cette dernière approche que je vais utiliser dans cet article, car elle a l’avantage de ne pas vous imposer les limites des deux autres approches.

Configuration de l’IDE Arduino pour le reTerminal E1002

Il faut tout d’abord intégrer le support pour les microcontrôleurs ESP32 dans l’IDE Arduino, en ajoutant l’URL suivante dans le champ Additional Boards Manager URLs du menu File > Preferences :

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

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

Il faut ensuite installer le package ESP32, via le menu Tools > Board > Boards Manager, en recherchant “esp32” et installant le package esp32 by Espressif Systems (disponible sur github espressif).

Téléchargez ensuite la librairie GxEPD2 dans son format ZIP :

Et l’ajouter à l’IDE Arduino via le menu Sketch > Include Library > Add .ZIP Library…

Et pour finir, installer cette librairie GxEPD2 by Jean-Marc Zingg via le menu Tools > Manage libraries.

Premier programme “Hello World”

Voici le code qui affiche le célèbre “Hello World” sur l’écran du reTerminal E1002, qu’il faut installer sur l’appareil après avoir sélectionné la carte XIAO_ESP32S3 via le menu Tools > Board > ESP32 Arduino et choisi le port sur lequel le reTerminal est connecté.

/**
 * @file hello_world.ino
 * @brief Display "Hello World!" on Seeed reTerminal E1002 e-paper.
 * 
 *   https://tutoduino.fr/
 */
#include <GxEPD2_7C.h> // Include library for 7-color ePaper display management
#include <Fonts/FreeMonoBold12pt7b.h> // Include a bold monospaced font at 12pt (for text display)
// Define SPI connection pins between the microcontroller and the ePaper display
#define EPD_SCK_PIN  7     // SPI clock pin
#define EPD_MOSI_PIN 9     // SPI data pin (MOSI)
#define EPD_CS_PIN   10    // SPI Chip Select for the ePaper display
#define EPD_DC_PIN   11    // Data/Command control pin
#define EPD_RES_PIN  12    // Display Reset pin
#define EPD_BUSY_PIN 13    // Display Busy status pin
// Define the ePaper display driver and class (for a 7.3" color model)
#define GxEPD2_DISPLAY_CLASS GxEPD2_7C
#define GxEPD2_DRIVER_CLASS GxEPD2_730c_GDEP073E01 // Specific to the 7.3" Color display
// Set up a maximum display buffer size for RAM management
#define MAX_DISPLAY_BUFFER_SIZE 16000
// Macro to compute the maximum height, given display size and RAM constraints
#define MAX_HEIGHT(EPD) \
    (EPD::HEIGHT <= MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8) \
         ? EPD::HEIGHT \
         : MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8))
// Instantiate the ePaper display object with the chosen driver and pinouts
GxEPD2_DISPLAY_CLASS<GxEPD2_DRIVER_CLASS, MAX_HEIGHT(GxEPD2_DRIVER_CLASS)>
    display(GxEPD2_DRIVER_CLASS(/*CS=*/EPD_CS_PIN, /*DC=*/EPD_DC_PIN,
                                /*RST=*/EPD_RES_PIN, /*BUSY=*/EPD_BUSY_PIN));
// Create a dedicated SPI bus object for display communication
SPIClass hspi(HSPI);
/**
 * @brief Draws "Hello World!" in red at coordinates (100, 100) on the ePaper display.
 */
void helloWorld()
{
  display.setRotation(0);  // No rotation, natural orientation
  display.setFont(&FreeMonoBold12pt7b); // Use the bold 12pt monospace font
  display.setTextColor(GxEPD_RED);      // Set text color to red (one of supported display colors)
  display.setFullWindow();              // Use the full display area for drawing
  display.firstPage();                  // Start first drawing page (paged drawing saves RAM)
  do
  {
    display.fillScreen(GxEPD_WHITE);    // Fill the screen with white (background)
    display.setCursor(100, 100);        // Set the cursor to (100, 100) for text position
    display.print("Hello World!");      // Print "Hello World!" on the screen
  }
  while (display.nextPage());           // Continue until all pages are rendered (for paged displays)
}
/**
 * @brief Arduino setup function. Initializes the display and shows "Hello World!".
 */
void setup()
{
  pinMode(EPD_RES_PIN, OUTPUT);      // Configure reset pin as output
  pinMode(EPD_DC_PIN, OUTPUT);       // Configure data/command pin as output
  pinMode(EPD_CS_PIN, OUTPUT);       // Configure chip-select pin as output
  // Initialize SPI bus for display with specified pins, speed, and settings
  hspi.begin(EPD_SCK_PIN, -1, EPD_MOSI_PIN, -1);
  display.epd2.selectSPI(hspi, SPISettings(2000000, MSBFIRST, SPI_MODE0));
  // Initialize the ePaper display hardware and driver
  display.init(0);
  // Display "Hello World!" message
  helloWorld();
  // Put the display into low-power (hibernate) mode after rendering
  display.hibernate();
}
// No loop code needed. The display only updates once at startup in this demo.
void loop() {};

/**
 * @file hello_world.ino
 * @brief Display "Hello World!" on Seeed reTerminal E1002 e-paper.
 * 
 *   https://tutoduino.fr/
 */
#include <GxEPD2_7C.h> // Include library for 7-color ePaper display management
#include <Fonts/FreeMonoBold12pt7b.h> // Include a bold monospaced font at 12pt (for text display)

// Define SPI connection pins between the microcontroller and the ePaper display
#define EPD_SCK_PIN  7     // SPI clock pin
#define EPD_MOSI_PIN 9     // SPI data pin (MOSI)
#define EPD_CS_PIN   10    // SPI Chip Select for the ePaper display
#define EPD_DC_PIN   11    // Data/Command control pin
#define EPD_RES_PIN  12    // Display Reset pin
#define EPD_BUSY_PIN 13    // Display Busy status pin

// Define the ePaper display driver and class (for a 7.3" color model)
#define GxEPD2_DISPLAY_CLASS GxEPD2_7C
#define GxEPD2_DRIVER_CLASS GxEPD2_730c_GDEP073E01 // Specific to the 7.3" Color display

// Set up a maximum display buffer size for RAM management
#define MAX_DISPLAY_BUFFER_SIZE 16000

// Macro to compute the maximum height, given display size and RAM constraints
#define MAX_HEIGHT(EPD) \
    (EPD::HEIGHT <= MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8) \
         ? EPD::HEIGHT \
         : MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8))

// Instantiate the ePaper display object with the chosen driver and pinouts
GxEPD2_DISPLAY_CLASS<GxEPD2_DRIVER_CLASS, MAX_HEIGHT(GxEPD2_DRIVER_CLASS)>
    display(GxEPD2_DRIVER_CLASS(/*CS=*/EPD_CS_PIN, /*DC=*/EPD_DC_PIN,
                                /*RST=*/EPD_RES_PIN, /*BUSY=*/EPD_BUSY_PIN));

// Create a dedicated SPI bus object for display communication
SPIClass hspi(HSPI);

/**
 * @brief Draws "Hello World!" in red at coordinates (100, 100) on the ePaper display.
 */
void helloWorld()
{
  display.setRotation(0);  // No rotation, natural orientation
  display.setFont(&FreeMonoBold12pt7b); // Use the bold 12pt monospace font
  display.setTextColor(GxEPD_RED);      // Set text color to red (one of supported display colors)
  display.setFullWindow();              // Use the full display area for drawing
  display.firstPage();                  // Start first drawing page (paged drawing saves RAM)
  do
  {
    display.fillScreen(GxEPD_WHITE);    // Fill the screen with white (background)
    display.setCursor(100, 100);        // Set the cursor to (100, 100) for text position
    display.print("Hello World!");      // Print "Hello World!" on the screen
  }
  while (display.nextPage());           // Continue until all pages are rendered (for paged displays)
}

/**
 * @brief Arduino setup function. Initializes the display and shows "Hello World!".
 */
void setup()
{
  pinMode(EPD_RES_PIN, OUTPUT);      // Configure reset pin as output
  pinMode(EPD_DC_PIN, OUTPUT);       // Configure data/command pin as output
  pinMode(EPD_CS_PIN, OUTPUT);       // Configure chip-select pin as output

  // Initialize SPI bus for display with specified pins, speed, and settings
  hspi.begin(EPD_SCK_PIN, -1, EPD_MOSI_PIN, -1);
  display.epd2.selectSPI(hspi, SPISettings(2000000, MSBFIRST, SPI_MODE0));

  // Initialize the ePaper display hardware and driver
  display.init(0);

  // Display "Hello World!" message
  helloWorld();

  // Put the display into low-power (hibernate) mode after rendering
  display.hibernate();
}

// No loop code needed. The display only updates once at startup in this demo.
void loop() {};

Voici le résultat après téléversement sur le reTerminal :

Récupération d’une donnée depuis le serveur Home Assistant

L’objectif de ce tutoriel est d’afficher sur le reTerminal E1002 la température du capteur qui est disponible dans le serveur Home Assistant. Cette donnée sera récupérée via l’API RESTful du serveur Home Assistant disponible via l’URL http://ADRESSE_IP_HA:8123/api/. Cette API accepte et renvoie uniquement les objets codés en JSON. Nous utiliserons pour cela la librairie Arduinojson by Benoit Blanchon, que nous installons depuis le menu Tools > Manage Libraries de l’IDE Arduino.

Il faut récupérer, depuis la page web de Home Assistant, l’ID de l’entité que nous souhaitons afficher sur le reTerminal. Ici par exemple, la température du capteur correspond à l’entité dont l’ID est : sensor.tutoduino_esp32c6tempsensor_temperature.