CrowPanel E-Paper 4.2 pouces avec GxEPD2

Dans ce blog, je vous montre comment utiliser la bibliothèque GxEPD2 pour dessiner sur un écran E-Paper CrowPanel de 4,2 pouces.

Les écrans E-Paper CrowPanel d’Elecrow sont livrés avec un code d’exemple qui montre comment dessiner sur l’écran. Cependant, les fonctionnalités de ce code sont assez limitées. Ce serait bien mieux si nous pouvions utiliser la bibliothèque plus performante GxEPD2 Libary. Malheureusement, en décembre 2024, il n’existe pas de support direct pour les écrans E-Paper CrowPanel dans la bibliothèque GxEPD2 (voir GxEPD2_display_selection_new_style.h).

Cependant, avec un petit ajustement, nous pouvons faire fonctionner la bibliothèque GxEPD2 sur l’écran E-Paper CrowPanel 4,2 pouces, et dans les sections suivantes, je vous montrerai comment procéder.

Overview

Pièces requises

Vous aurez besoin d’un écran E-Paper CrowPanel. Dans ce tutoriel, je me concentre sur la version 4,2 pouces, qui est celle que vous devriez choisir. Il existe d’autres tailles d’écran et les exemples de code devraient fonctionner en grande partie, mais vous devrez faire des modifications en raison des différences de résolution et de pilote d’affichage.

Écran E-Paper CrowPanel 4,2 pouces

Find at Elecrow

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

Écran E-Paper CrowPanel 4,2 pouces

L’écran E-Paper 4,2 pouces de CrowPanel est un écran noir et blanc, avec une résolution de 400×300 pixels. Il est livré en module intégré contenant une puce ESP32-S3, plusieurs boutons pour contrôler l’écran, et plus encore. La photo suivante montre le devant de l’écran avec trois boutons de contrôle sur le côté :

Front of CrowPanel 4.2-inch E-Paper Display — Face avant de l’écran E-Paper CrowPanel 4,2 pouces (source)

Boutons

Les boutons MENU et EXIT sont des boutons-poussoirs simples, tandis que le commutateur rotatif supporte les fonctions Haut, Bas et Confirmer/OK. Les boutons sont entièrement programmables. Le tableau suivant montre quels GPIO sont connectés à quels boutons :

Bouton	GPIO
MENU	IO2
Commutateur rotatif Bas	IO4
Commutateur rotatif Haut	IO6
Commutateur rotatif CONF	IO5
EXIT	IO1

Caractéristiques

Par ailleurs, le module d’affichage contient un emplacement pour carte TF, une interface batterie LiPo (SH1.0-2Pin) avec capacité de charge, et une interface GPIO. La programmation (et l’alimentation) se fait via un port USB-C.

Interna of CrowPanel 4.2-inch E-Paper Display — Intérieur de l’écran E-Paper CrowPanel 4,2 pouces (source)

GPIO

Pour le GPIO, les broches suivantes sont disponibles : IO3 ; IO9 ; IO15 ; IO17 ; IO19 ; IO21 ; IO8 ; IO14 ; IO16 ; IO18 ; IO20 ; IO38, et le brochage du port GPIO est indiqué sur la sérigraphie ainsi qu’au dos du module :

Reset et Boot

À l’arrière du module se trouvent les boutons Boot et Reset. Malheureusement, ils dépassent du boîtier et sont facilement pressés accidentellement lorsqu’on pose le module sur une table. Je vous conseille de les raccourcir un peu (avec une pince) pour éviter cela.

Back of CrowPanel 4.2-inch E-Paper Display — Dos de l’écran E-Paper CrowPanel 4,2 pouces (source)

Autres écrans E-Paper CrowPanel

L’écran 4,2 pouces fait partie d’une série d’écrans E-Paper similaires mais avec différentes résolutions, puces ESP32 et pilotes. Voir le tableau ci-dessous pour un aperçu :

CrowPanel E-Paper Displays — Écrans E-Paper CrowPanel (source)

Pour ce tutoriel, j’ai utilisé l’écran 4,2 pouces, mais la plupart du code fonctionne probablement aussi pour les autres tailles d’écran. Cependant, vous devrez trouver un pilote correspondant dans la bibliothèque GxEPD2. Plus d’informations dans la section suivante.

Bibliothèque GxEPD2

La GxEPD2 Libary est une bibliothèque Arduino/ESP32 pour les écrans E-Paper SPI. Comme mentionné, elle supporte de nombreux écrans E-Paper différents mais pas encore directement les écrans CrowPanel.

Cependant, comparée au code de démonstration fourni avec les écrans CrowPanel, la GxEPD2 Libary est préférable. Elle offre plus de functions et une meilleure documentation, car elle dérive de la Adafruit-GFX-Library, et peut être installée et utilisée facilement.

Surtout, vous pouvez (ré)utiliser du code écrit avec la GxEPD2 Libary sur une large gamme d’écrans E-Paper différents, sans avoir à le réécrire pour des écrans spécifiques.

Téléverser le code sur l’écran E-Paper CrowPanel

Téléverser du code sur le module E-Paper via l’IDE Arduino est simple. Il suffit de connecter le câble USB et de sélectionner « ESP32S3 Dev Module » comme carte :

Selecting ESP32S3 Dev Module — Sélection du module ESP32S3 Dev

Dans « Tools », sélectionnez de préférence « Huge App » pour le Partition Scheme et « OPI PSRAM » pour les réglages PSRAM. Ce n’est pas essentiel pour le code de ce tutoriel, mais ce sont les réglages recommandés.

Board settings for CrowPanel E-Paper display — Paramètres de la carte pour l’écran E-Paper CrowPanel

Code pour utiliser la bibliothèque GxEPD2 avec l’écran E-Paper CrowPanel

Dans cette section, je vous montre comment faire fonctionner la bibliothèque GxEPD2 avec l’écran E-Paper CrowPanel. Il y a deux étapes importantes. D’abord, il faut trouver un pilote GxEPD2 qui a la même résolution et supporte la même puce pilote que l’écran CrowPanel.

L’écran 4,2 pouces utilise la puce pilote SSD1683 et a une résolution de 400×300 pixels. Si vous consultez la liste des pilotes supportés dans GxEPD2_display_selection_new_style.h, vous trouverez deux correspondances :

//#define GxEPD2_DRIVER_CLASS GxEPD2_420_GDEY042T81 // GDEY042T81 400x300, SSD1683 (no inking)
//#define GxEPD2_DRIVER_CLASS GxEPD2_420_GYE042A87  // GYE042A87, 400x300, SSD1683 (HINK-E042-A07-FPC-A1)

Cependant, si vous essayez ces pilotes, vous n’obtenez qu’une image très faible de ce que vous dessinez sur l’écran. J’ai examiné de plus près le demo code et il s’avère qu’il faut aussi activer l’alimentation de l’écran. Cela se fait en mettant la sortie GPIO7 à HIGH.

L’exemple suivant affiche le texte « Makerguides » au centre de l’écran E-Paper 4,2 pouces. Jetez un coup d’œil rapide, puis nous discuterons des détails :

#include "GxEPD2_BW.h"

#define PWR 7
#define BUSY 48
#define RES 47
#define DC 46
#define CS 45

GxEPD2_BW<GxEPD2_420_GYE042A87, GxEPD2_420_GYE042A87::HEIGHT> epd(GxEPD2_420_GYE042A87(CS, DC, RES, BUSY));

void epdPower(int state) { 
  pinMode(PWR, OUTPUT);  
  digitalWrite(PWR, state);  
}

void epdInit() {  
  epd.init(115200, true, 50, false);
  epd.setRotation(0);
  epd.setTextColor(GxEPD_BLACK);
  epd.setTextSize(4);
  epd.setFullWindow();
}

void setup() {
  epdPower(HIGH);
  epdInit();
  epd.fillScreen(GxEPD_WHITE);
  epd.drawRect(0, 0, 400, 300, GxEPD_BLACK);
  epd.setCursor(70, 130);
  epd.print("Makerguides");
  epd.display();
  epd.hibernate(); 
  epdPower(LOW);
}

void loop() {}

Inclure

D’abord, nous incluons la GxEPD2 Libary et comme nous utilisons un écran E-Paper noir et blanc, nous incluons « GxEPD2_BW.h » :

#include "GxEPD2_BW.h"

Si vous n’avez pas encore installé la GxEPD2 Libary, vous devrez le faire pour que ce code fonctionne. Vous aurez aussi besoin de la bibliothèque Adafruit_GFX. Il suffit de install the libraries de la manière habituelle. Après l’installation, elles apparaîtront dans le Library Manager comme suit.

Adafruit_GFX and GxEPD2 libraries in Library Manager — Bibliothèques Adafruit_GFX et GxEPD2 dans le Library Manager

Vous n’avez pas besoin des demo code fournis avec les écrans CrowPanel.

Définitions des broches

Ensuite, il faut définir les broches SPI utilisées par l’écran pour communiquer avec l’ESP32.

#define PWR 7
#define BUSY 48
#define RES 47
#define DC 46
#define CS 45

J’ai trouvé ces broches en regardant le Schematics of the CrowPanel 4.2-inch E-Paper display. Voici la section pertinente du schéma qui décrit la connexion à l’écran E-Paper :

Objet Display

Comme mentionné, il n’y a pas de support direct pour l’écran E-Paper CrowPanel 4,2 pouces dans la GxEPD2 Libary. Nous utilisons donc un modèle proche pour créer l’objet epd qui représente notre écran E-Paper :

GxEPD2_BW<GxEPD2_420_GYE042A87, GxEPD2_420_GYE042A87::HEIGHT> epd(GxEPD2_420_GYE042A87(CS, DC, RES, BUSY));

Alternativement, vous pouvez aussi utiliser la classe GxEPD2_420_GDEY042T81. Les deux semblent fonctionner, mais dans le code suivant, j’ai utilisé la classe GxEPD2_420_GYE042A87.

Fonction epdPower

La fonction epdPower() est critique et spéciale. Pour d’autres écrans E-Paper, elle n’est pas nécessaire, mais pour le CrowPanel, oui. Elle met GPIO7 à haut ou bas et active ou désactive ainsi l’écran E-Paper.

void epdPower(int state) { 
  pinMode(PWR, OUTPUT);  
  digitalWrite(PWR, state);  
}

Notez que vous pouvez désactiver l’écran E-Paper (epdPower(LOW)) une fois que vous avez dessiné dessus. Il continuera à afficher l’image même sans alimentation.

Fonction epdInit

La fonction epdInit() effectue la configuration initiale habituelle pour la gestion graphique, comme la rotation de l’écran, la couleur du texte, la taille du texte et le mode de rafraîchissement.

void epdInit() {  
  epd.init(115200, true, 50, false);
  epd.setRotation(0);
  epd.setTextColor(GxEPD_BLACK);
  epd.setTextSize(4);
  epd.setFullWindow();
}

Fonction setup

Dans la fonction setup(), nous alimentons l’écran, remplissons l’écran en blanc, dessinons un cadre, affichons le texte « Makerguides », affichons le contenu, puis éteignons l’écran.

void setup() {
  epdPower(HIGH);
  epdInit();
  epd.fillScreen(GxEPD_WHITE);
  epd.drawRect(0, 0, 400, 300, GxEPD_BLACK);
  epd.setCursor(70, 130);
  epd.print("Makerguides");
  epd.display();
  epd.hibernate(); 
  epdPower(LOW);
}

Si vous téléversez et exécutez ce code, vous devriez voir la sortie suivante sur l’écran E-Paper :

Sortie test sur l’écran E-Paper CrowPanel 4,2 pouces

Ainsi, avec l’ajout de la fonction epdPower(), vous pouvez utiliser la GxEPD2 Libary comme d’habitude pour dessiner et écrire sur l’écran E-Paper CrowPanel 4,2 pouces. Dans la section suivante, nous testons le rafraîchissement partiel.

Rafraîchissement partiel de l’écran E-Paper CrowPanel

Dans le code ci-dessus, nous avons effectué un rafraîchissement complet du contenu de l’écran E-Paper. Ce rafraîchissement complet est parfois nécessaire pour éliminer les images fantômes, mais il est lent (plusieurs secondes) et provoque beaucoup de scintillement.

Pour la plupart des applications, vous souhaitez mettre à jour seulement une partie de l’écran, sans scintillement et beaucoup plus rapidement. Par exemple, pour afficher les chiffres d’une horloge en marche. Un rafraîchissement partiel permet cela. Pour plus de détails, consultez le tutoriel Partial Refresh of e-Paper Display.

Le code suivant est essentiellement le même que celui utilisé dans ce tutoriel. Il effectue d’abord un rafraîchissement complet pour nettoyer l’écran et affiche le texte « msec: ». Ensuite, il effectue continuellement un rafraîchissement partiel et met à jour les millisecondes en cours. Voici une capture d’écran de la sortie :

Display output for full- and partial refresh — Sortie d’affichage pour rafraîchissement complet et partiel

Voici le code complet pour ce test. La seule différence avec celui du Partial Refresh of e-Paper Display est que nous devons utiliser à nouveau la fonction epdPower() pour allumer l’écran. Et bien sûr, le pilote d’écran est différent.

#include "GxEPD2_BW.h"

#define PWR 7
#define BUSY 48
#define RES 47
#define DC 46
#define CS 45

GxEPD2_BW<GxEPD2_420_GYE042A87, GxEPD2_420_GYE042A87::HEIGHT> epd(GxEPD2_420_GYE042A87(CS, DC, RES, BUSY));

void epdPower(int state) { 
  pinMode(PWR, OUTPUT);  
  digitalWrite(PWR, state);  
}

void drawFull(const void* pv) {
  epd.setFullWindow();
  epd.setCursor(40, 60);
  epd.print("msec: ");
}

void drawPartial(const void* pv) {
  uint16_t x = 120, y = 50, w = 130, h = 34;
  epd.setPartialWindow(x, y, w, h);
  epd.setCursor(x + 30, y + 10);
  epd.print(millis());
  epd.drawRect(x, y, w, h, GxEPD_BLACK);
}

void setup() {
  epdPower(HIGH);
  epd.init(115200, true, 50, false);
  epd.setRotation(0);
  epd.setTextSize(2);
  epd.setTextColor(GxEPD_BLACK);
  epd.drawPaged(drawFull, 0);  
}

void loop() {
  epd.drawPaged(drawPartial, 0);
  epd.hibernate();
}

Si vous téléversez et exécutez ce code, vous devriez voir la sortie suivante. Notez que les millisecondes sont mises à jour en moins de 0,5 seconde et qu’il y a presque pas de scintillement (juste un peu autour du cadre) :

Partial refresh on CrowPanel 4.2-inch E-Paper — Rafraîchissement partiel sur l’écran E-Paper CrowPanel 4,2 pouces

Ainsi, les rafraîchissements complet et partiel fonctionnent bien sur l’écran E-Paper CrowPanel 4,2 pouces avec le pilote GxEPD2 choisi GxEPD2_420_GYE042A87.

Dans la section suivante et finale, je vous montre comment utiliser le rafraîchissement partiel et les boutons de l’écran CrowPanel pour implémenter un menu simple qui contrôle trois LEDs.

Contrôle GPIO via menu sur l’écran E-Paper CrowPanel

Une des démos pour l’écran CrowPanel présente un menu simple avec des éléments pouvant être activés ou désactivés via les boutons.

Ici, nous allons construire quelque chose de similaire. Mais nous utiliserons la bibliothèque GxEPD2 et nos boutons contrôleront trois LEDs. La capture d’écran ci-dessous montre à quoi ressemblera le menu :

Menu de sélection LED sur l’écran CrowPanel

Nous pourrons naviguer dans le menu avec les boutons haut et bas du commutateur rotatif et sélectionner un élément avec le bouton de confirmation. Si un élément est sélectionné, une LED de la couleur correspondante connectée au GPIO s’allume, par exemple sélectionner « Red » allumera une LED rouge :

Red LED selected in Menu — LED rouge sélectionnée dans le menu

Schéma de câblage

Le schéma de câblage ci-dessous montre comment connecter les trois LEDs au port GPIO de l’écran CrowPanel. La cathode de chaque LED est reliée à la masse (GND). L’anode de la LED rouge est connectée à GPIO3, la LED verte à GPIO9 et la bleue à GPIO15. J’ai utilisé une résistance de limitation de courant de 220Ω pour chaque LED :

Connecting three LEDs to CrowPanel Display — Connexion de trois LEDs à l’écran CrowPanel

Code pour naviguer dans le menu et contrôler les LEDs

Voici le code pour naviguer dans le menu, sélectionner et désélectionner des éléments et contrôler les LEDs en conséquence :

#include "GxEPD2_BW.h"
#include <Fonts/FreeMonoBold24pt7b.h>

#define PWR 7
#define BUSY 48
#define RES 47
#define DC 46
#define CS 45
#define W 400
#define H 300

#define HOME_KEY 2
#define EXIT_KEY 1
#define PREV_KEY 6
#define NEXT_KEY 4
#define OK_KEY 5

int cursor = 0;
const int xoff = 70;
const int n_items = 3;
const char* items[] = { "Red", "Green", "Blue" };
const int pins[] = { 3, 9, 15 };
bool states[] = { false, false, false };
const int ypos[] = { 100, 100 + 60, 100 + 2 * 60 };

GxEPD2_BW<GxEPD2_420_GYE042A87, GxEPD2_420_GYE042A87::HEIGHT> epd(GxEPD2_420_GYE042A87(CS, DC, RES, BUSY));


void epdPower(int state) { 
  pinMode(PWR, OUTPUT);  
  digitalWrite(PWR, state);  
}

void drawCursor() {
  int16_t s = 12;
  int16_t x0 = xoff - s;
  int16_t y0 = ypos[cursor] - 12;
  int16_t x1 = x0 - s;
  int16_t y1 = y0 - s;
  int16_t x2 = x0 - s;
  int16_t y2 = y0 + s;
  epd.fillTriangle(x0, y0, x1, y1, x2, y2, GxEPD_BLACK);
}

void updateCursor(const void* pv) {
  epd.setPartialWindow(0, 0, xoff, 300);
  drawCursor();
}

void drawItem(int index) {
  int16_t xb, yb;
  uint16_t wb, hb;
  epd.setCursor(xoff + 5, ypos[index]);
  epd.getTextBounds(items[index], xoff + 5, ypos[index], &xb, &yb, &wb, &hb);
  if (states[index]) {
    epd.setTextColor(GxEPD_WHITE);
    epd.fillRect(xb - 5, yb - 3, W - 2 * xoff, hb + 6, GxEPD_BLACK);
  } else {
    epd.setTextColor(GxEPD_BLACK);
    epd.fillRect(xb - 5, yb - 3, W - 2 * xoff, hb + 6, GxEPD_WHITE);
  }
  epd.print(items[index]);
}

void updateItems(const void* pv) {
  epd.setPartialWindow(xoff, 0, W - xoff, 300);
  drawItems();
}

void drawItems() {
  for (int i = 0; i < n_items; i++) {
    drawItem(i);
  }
}

void initEPD() {
  epdPower(HIGH);
  epd.init(115200, true, 50, false);
  epd.setRotation(0);
  epd.setTextColor(GxEPD_BLACK);
  epd.setFont(&FreeMonoBold24pt7b);
  epd.setFullWindow();
  epd.fillScreen(GxEPD_WHITE);
}

void initButtons() {
  pinMode(HOME_KEY, INPUT);
  pinMode(EXIT_KEY, INPUT);
  pinMode(PREV_KEY, INPUT);
  pinMode(NEXT_KEY, INPUT);
  pinMode(OK_KEY, INPUT);
}

void initPins() {
  for (int i = 0; i < n_items; i++) {
      pinMode(pins[i], OUTPUT);
  }    
}

void setup() {
  initEPD();
  initButtons();
  initPins();
  drawItems();
  drawCursor();
  epd.display();
}

void loop() {
  if (!digitalRead(PREV_KEY)) {
    cursor = --cursor < 0 ? n_items - 1 : cursor;
    epd.drawPaged(updateCursor, 0);
  }
  if (!digitalRead(NEXT_KEY)) {
    cursor = ++cursor >= n_items ? 0 : cursor;
    epd.drawPaged(updateCursor, 0);
  }
  if (!digitalRead(OK_KEY)) {
    states[cursor] = !states[cursor];
    epd.drawPaged(updateItems, 0);
    digitalWrite(pins[cursor], states[cursor] ? HIGH : LOW);
  }
  if (!digitalRead(HOME_KEY)) {
    cursor = 0;
    epd.drawPaged(updateCursor, 0);
  }  
  if (!digitalRead(EXIT_KEY)) {
    for (int i = 0; i < n_items; i++) {
      states[i] = false;
      digitalWrite(pins[i], LOW);  
    }      
    epd.drawPaged(updateItems, 0);
  }
  delay(100);
}

Décomposons le code en ses composants pour mieux comprendre.

Bibliothèques et constantes

Nous commençons par inclure les bibliothèques nécessaires pour l’écran E-Paper et fonts. Les constantes définissent les broches utilisées pour l’écran et les boutons, ainsi que les dimensions de l’écran.

#include "GxEPD2_BW.h"
#include <Fonts/FreeMonoBold24pt7b.h>

#define PWR 7
#define BUSY 48
#define RES 47
#define DC 46
#define CS 45
#define W 400
#define H 300

Définitions des boutons

Nous définissons les broches des boutons qui seront utilisés pour naviguer dans le menu. Chaque bouton est assigné à une fonction spécifique : HOME, EXIT, PREV, NEXT et OK.

#define HOME_KEY 2
#define EXIT_KEY 1
#define PREV_KEY 6
#define NEXT_KEY 4
#define OK_KEY 5

Variables

Plusieurs variables sont déclarées pour gérer l’état du menu. cursor garde la sélection actuelle, items contient les noms des LEDs, et states suit si chaque LED est allumée ou éteinte. ypos spécifie où les éléments du menu sont affichés sur l’écran.

int cursor = 0;
const char* items[] = { "Red", "Green", "Blue" };
const int pins[] = { 3, 9, 15 };
bool states[] = { false, false, false };
const int ypos[] = { 100, 160, 220 };

Objet écran E-Paper

Comme avant, l’objet écran E-Paper est créé avec la classe GxEPD2_BW. Cela configure l’écran avec les broches spécifiées. Si vous avez un autre écran CrowPanel, vous devrez modifier cette ligne.

GxEPD2_BW<GxEPD2_420_GYE042A87, GxEPD2_420_GYE042A87::HEIGHT> epd(GxEPD2_420_GYE042A87(CS, DC, RES, BUSY));

Fonction de contrôle d’alimentation

La fonction epdPower() contrôle l’alimentation de l’écran E-Paper. Elle configure la broche d’alimentation en sortie et écrit l’état spécifié (HIGH ou LOW).

void epdPower(int state) { 
  pinMode(PWR, OUTPUT);  
  digitalWrite(PWR, state);  
}

Fonction de dessin du curseur

La fonction drawCursor() représente visuellement la sélection actuelle dans le menu en dessinant un triangle à la position correspondante.

void drawCursor() {
  int16_t s = 12;
  int16_t x0 = xoff - s;
  int16_t y0 = ypos[cursor] - 12;
  epd.fillTriangle(x0, y0, x1, y1, x2, y2, GxEPD_BLACK);
}

Notez que la fonction updateCursor() effectue un rafraîchissement partiel et ne met à jour que la partie de l’écran où le curseur est affiché. Elle est appelée lorsque les boutons Haut ou Bas sont pressés, par exemple.

void updateCursor(const void* pv) {
  epd.setPartialWindow(0, 0, xoff, 300);
  drawCursor();
}

Fonction de dessin d’élément

La fonction drawItem() affiche un élément dans le menu. Elle vérifie l’état de la LED et change le fond en noir si l’élément est sélectionné.

void drawItem(int index) {
  epd.setCursor(xoff + 5, ypos[index]);
  if (states[index]) {
    epd.setTextColor(GxEPD_WHITE);
    epd.fillRect(...);
  } else {
    epd.setTextColor(GxEPD_BLACK);
    epd.fillRect(...);
  }
  epd.print(items[index]);
}

Pour dessiner tous les éléments du menu, la fonction drawItems() est utilisée :

void drawItems() {
  for (int i = 0; i < n_items; i++) {
    drawItem(i);
  }
}

Et l’état de tous les éléments est mis à jour en effectuant un rafraîchissement partiel de l’écran, là où se trouvent les éléments du menu :

void updateItems(const void* pv) {
  epd.setPartialWindow(xoff, 0, W - xoff, 300);
  drawItems();
}

Fonctions d’initialisation

Plusieurs fonctions d’initialisation sont définies : initEPD() initialise l’écran E-Paper, initButtons() configure les broches des boutons en entrée, et initPins() configure les broches des LEDs en sortie.

void initEPD() {
  epdPower(HIGH);
  ...
}

void initButtons() {
  pinMode(HOME_KEY, INPUT);
  ...
}

void initPins() {
  for (int i = 0; i < n_items; i++) {
      pinMode(pins[i], OUTPUT);
  }    
}

Fonction setup

La fonction setup() est appelée une fois au démarrage du programme. Elle initialise l’écran E-Paper, les boutons et les broches des LEDs, et dessine les éléments initiaux et le curseur sur l’écran.

void setup() {
  initEPD();
  initButtons();
  initPins();
  drawItems();
  drawCursor();
  epd.display();
}

Fonction loop

La fonction loop() tourne en continu. Elle vérifie l’état des boutons et met à jour la position du curseur ou bascule l’état des LEDs selon les entrées utilisateur. L’écran est mis à jour en utilisant un redessin paginé avec rafraîchissement partiel.

void loop() {
  if (!digitalRead(PREV_KEY)) {
    ...
  }
  if (!digitalRead(NEXT_KEY)) {
    ...
  }
  if (!digitalRead(OK_KEY)) {
    ...
  }
  if (!digitalRead(HOME_KEY)) {
    ...
  }  
  if (!digitalRead(EXIT_KEY)) {
    ...
  }
  delay(100);
}

Le bouton PREV_KEY déplace le curseur d’un élément vers le haut et le bouton NEXT_KEY le déplace d’un élément vers le bas. Si le début ou la fin du menu est atteint, le curseur revient à l’autre extrémité.

Avec le bouton OK_KEY, vous pouvez basculer l’état d’un élément. Le bouton HOME_KEY déplace le curseur sur le premier élément du menu et le bouton EXIT_KEY désélectionne tous les éléments.

Démo du code

En résumé, ce code fournit une interface utilisateur sur un écran E-Paper pour contrôler trois LEDs. L’utilisateur peut naviguer dans les options et activer ou désactiver les LEDs avec des boutons physiques. La courte vidéo suivante montre à quoi cela ressemble :

Contrôle des LEDs avec menu sur écran E-Paper

Conclusions

Dans ce tutoriel, vous avez appris à utiliser la bibliothèque GxEPD2 pour dessiner et écrire sur un écran E-Paper CrowPanel 4,2 pouces.

Si vous avez besoin de plus d’informations sur les écrans E-Paper, consultez le Interfacing Arduino with E-ink Display et le tutoriel Partial Refresh of e-Paper Display.

Aussi, si vous cherchez d’autres applications, les tutoriels Weather Station on e-Paper Display, Temperature Plotter on e-Paper Display, Digital Clock on e-Paper Display et Analog Clock on e-Paper Display peuvent vous intéresser.

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

Liens

Voici quelques liens autour de l’écran E-Paper CrowPanel 4,2 pouces que j’ai trouvés utiles lors de la rédaction de ce tutoriel :

Stefan Maetschke