Nous avons l’habitude d’utiliser les écrans OLED ou LCD pour nos projets d’objets connectés. Si la consommation d’énergie est un problème crucial pour vos projets, les écrans e-paper (également appelé e-Ink) sont une alternative très intéressante. L’affichage est obtenu par l’orientation de sphères colorées (noir et blanche ou noir, blanche, rouge) sous l’effet d’un champ électrique. Une fois que l’affichage a été actualisé, l’écran n’a besoin d’aucune source d’énergie pour maintenir l’affichage. Je vous propose de tester dans ce tutoriel un écran e-Paper de la société chinoise Waveshare qui propose une gamme complète d’écrans eInk. Nous allons tester un écran de 2,7” de diagonale. Il est livré sous la forme d’une carte d’extension (HAT) compatible avec tous les modèles et générations de Raspberry Pi. On communique avec l”écran via le bus SPI. Nous verrons dans les prochains tutoriels comment utiliser ce même écran sur Arduino, ESP8266 et ESP32.
Sommaire
- 1 Principe des écrans ePaper / eInk, avantages et inconvénients
- 2 Les écrans ePaper (eInk) de Waveshare
- 3 Test de l’écran 2,7” Waveshare sur un Raspberry Pi 3
- 4 Installation de l’écran sur le Raspberry Pi
- 5 Configuration de Raspbian
- 6 Installation des librairies python
- 7 Récupérer le driver epd
- 8 Premier test, affichage d’un carré plein au centre de l’écran
- 9 Bonus, récupérer les événements des 4 boutons de fonction
Principe des écrans ePaper / eInk, avantages et inconvénients
Inutile de rentrer trop dans les détails techniques des écrans ePaper. Tout est déjà très bien expliqué sur Wikipédia ici et cet article publié en 2013 sur framboise314. L’écran est constitué de billes, un coté noir, l’autre blanc, comme un oeuf de grenouille 😉 En appliquant une tension électrique entre les deux faces de l’écran, on provoque l’orientation des billes. Certains écrans ont même trois orientations, ce qui permet d’avoir un affichage en trois couleurs. En général, blanc – noir – rouge. La technologie existe depuis les années 1970.
Source : Wikipedia, https://fr.wikipedia.org/wiki/Papier_%C3%A9lectronique
L’énorme avantage d’un écran ePaper est qu’il ne consomme absolument rien. Il n’y a pas de rétro-éclairage (source de consommation d’énergie). L’affichage étant obtenue par un changement d’orientation de bulles colorées, l’affichage persistent même en l’absence de courant. C’est un énorme avantage par rapport aux écrans OLED et cristaux liquides.
Cependant, l’orientation des billes est assez lente. Ce sont les mêmes écrans qui sont utilisés pour les liseuses numériques (Kindle d’Amazon ou de la Fnac). Pour afficher une nouvelle page (image), il faut d’abord repositionner toutes les billes dans la même direction avant de pouvoir orienter les billes pour créer le motif (texte, formes géométriques, image…). L’opération dure une à deux secondes.
Les écrans e-Paper sont donc très bien adaptés pour réaliser des affichages qui nécessitent pas un rafraichissement fréquent. Par exemple, la température, le taux d’humidité, la pression atmosphérique, la teneur en CO2 dans une pièce, les prévisions météos pour les 5 jours à venir, la réception d’un colis dans la boite au lettre… sont des données qui évoluent très lentement. Ce n’est pas en scandale de mettre à jour l’affichage une fois par heure.
Par contre, on utilisera plutôt un écran LCD/TFT tactile pour réaliser un dashbord (tableau de bord) pour un serveur domotique.
Lorsqu’on recherche des écrans e-Paper pour des projets Arduino ou Raspberry Pi, on trouve deux principaux fabricants. Adafruit et Waveshare. Il est assez difficile de se procurer des écrans Adafruit (à part habiter aux USA). Les écrans Waveshare sont commercialisés sur les principaux sites marchands asiatiques ainsi que sur Amazon. J’ai commandé le miens sur la boutique de Waveshare sur AliExpress. A dimension équivalente, les écrans e-Paper coûtent quasiment le même prix qu’un écran LCD/TFT. Comptez environ 47€ pour un écran de 7,5 pouces.
Waveshare a développé une gamme très complète. Le tableau ci-dessous récapitule tous les écrans disponibles. Tous les écrans sont disponibles avec un affichage 3 couleurs (blanc, rouge, noir), à l’exception du modèle 4,3” UART. Le (B) dans la référence permet de les repérer. Attention, le temps de rafraîchissement est beaucoup plus long pour les écrans 3 couleurs. Par exemple, le temps de rafraîchissement pour un écran de 1,54” passe de 2 secondes à 8 secondes. Le temps de rafraîchissement passe même à 31 secondes pour un écran de 7,5 pouces. Il n’y a qu’un seul écran capable de communiquer via le port série UART. Tous les autres écrans communiquent à l’aide du bus SPI sur 3 ou 4 fils (par défaut).
|
Ecran |
Couleurs |
Niveau de gris |
Résolution (pixels) |
Taille écran (mm) |
Taille totale (mm) |
Temps de rafraîchissement (s) |
Interface |
Compatible HAT(1) |
|
noir, blanc |
2 |
200×200 |
27.60 × 27.60 |
48.0 × 33.0 |
2 |
SPI |
x |
|
|
rouge, noir, blanc |
2 |
200×200 |
27.60 × 27.60 |
48.0 × 33.0 |
8 |
SPI |
x |
|
|
noir, blanc |
2 |
250×122 |
48.55 × 23.71 |
65.0 × 30.2 |
2 |
SPI |
√ |
|
|
rouge, noir, blanc |
2 |
212×104 |
48.55 × 23.71 |
65.0 × 30.2 |
15 |
SPI |
√ |
|
|
noir, blanc |
2 |
264×176 |
57.29 × 38.19 |
85.0 × 56.0 |
6 |
SPI |
√ |
|
|
rouge, noir, blanc |
2 |
264×176 |
57.29 × 38.19 |
85.0 × 56.0 |
15 |
SPI |
√ |
|
|
noir, blanc |
2 |
296×128 |
66.89 × 29.05 |
89.5 × 38.0 |
2 |
SPI |
x |
|
|
rouge, noir, blanc |
2 |
296×128 |
66.89 × 29.05 |
89.5 × 38.0 |
15 |
SPI |
x |
|
|
noir, blanc |
2 |
400×300 |
84.80 × 63.60 |
103.0 × 78.5 |
4 |
SPI |
x |
|
|
rouge, noir, blanc |
2 |
400×300 |
84.80 × 63.60 |
103.0 × 78.5 |
15 |
SPI |
x |
|
|
noir, blanc |
4 |
800×600 |
88.00 × 66.00 |
118.0 × 75.0 |
1.5 |
UART |
x |
|
|
noir, blanc |
2 |
640×384 |
163.20×97.92 |
170.2×111.2 |
6 |
SPI |
√ |
|
|
rouge, noir, blanc |
2 |
640×384 |
163.20×97.92 |
170.2×111.2 |
31 |
SPI |
√ |
(1) Connecteur compatible avec Raspberry Pi 2B/3B/Zero/Zero W. Les autres écrans doivent être connectés à l’aide de Jumpers.
AliExpress
Waveshare met à disposition plusieurs exemples sur son Wiki. En plus du code pour Arduino et STM32, Waveshare propose trois exemples. Deux exemple en C++. Le premier utilise la librairie BCM, le second la librairie WiringPi. Ici, je vous propose de découvrir le fonctionnement de l’écran en Python.
Installation de l’écran sur le Raspberry Pi
En fonction de la taille de l’écran, Waveshare intègre le contrôleur SPI à l’écran. Pour certains modèles (dimension), il est possible d’acheter séparément le contrôleur et l’écran. Le HAT 2,7” pour Raspberry Pi est similaire aux écrans LCD/FTF. Il vient simplement s’insérer sur le GPIO du Raspberry Pi. Contrairement à certaines cartes, le GPIO est condamné. Si vous avez utilisez le GPIO pour d’autres fonctions, rien ne vous empêche d’utiliser des jumpers pour câbler l’écran. Il existe également un second connecteur 8 broches sur le bord de l’écran.
Par défaut, l’écran est configuré pour un bus SPI sur 4 fils. Il est possible de modifier la configuration à l’aide du câble livré avec l’écran. Celui-ci vient se connecté en dessous de l’écran. L’écran est livré avec un jeu d’entretoise qui permet de rendre solidaire l’écran du Raspberry Pi.
Configuration de Raspbian
Avant d’installer les librairies Python nécessaires, il faut activer le bus SPI et I2C sur Raspbian. Commencez par mettre à jour le système.
sudo apt update
Maintenant lancez l’outil de configuration avec la commande sudo raspi-config . Allez à l’option (5) Interfacing Option puis activez successivement le bus SPI et I2C. Acceptez le redémarrage lorsque vous quittez raspi-config pour activer les bus.
Une fois redémarré, ouvrez le fichier de configuration des drivers avec la commande sudo nano /etc/modules . Vérifiez que les drivers suivants sont bien présents. Redémarrez Raspbian pour recharger les drivers (sudo reboot).
i2c-bcm2708 i2c-dev
Installation des librairies python
On trouve quelques infos utiles sur le WiFi de Waveshare mais il faut un peu fouiller pour s’y retrouver surtout pour trouver les librairies Python à installer. J’ai passé pas mal de temps à trouver les bonne librairies. Si vous rencontrez des difficultés, n’hésitez pas à me les remonter dans les commentaires.
Voici ce que j’ai installer pour développer en Python. Exécutez la commande suivante qui va installer python-dev et les librairies python-pil et python-imaging. En fait, le drivers livré dans les exemples “se contente” d’afficher une image que l’on aura au préalable construite à l’aide de la librairie Python Imaging. L’avantage, c’est qu’on dispose de toutes les primitives de la librairie, à savoir les formes géométriques (ligne, rectangle…), texte, gestion des fontes et de la taille d’écriture…
sudo apt-get install python-dev python-pil python-imaging
Ensuite, il faut installer les librairies pour gérer la communication SPI
sudo apt-get install python-smbus python-serial
Et la dernière à l’aide de la commande pip qui installe la librairie spidev
sudo pip install spidev
Voilà, tout est prêt, passons aux choses sérieuses maintenant !
Récupérer le driver epd
Pour cette étape, vous aurez plus facile de vous connecter au Raspberry Pi en SSH. Vous pourrez facilement coller les liens et du code depuis votre ordinateur habituel. Suivez ce tutoriel pour apprendre comment faire.
Il n’y a pas de drivers universel. Waveshare a développé (et configuré) un drivers pour chaque écran. Celui-ci est livré avec les exemples. Allez sur le WiKi et allez sur la page qui correspond à votre écran. La page de l’écran 2,7 pouce est ici. En bas de chaque page, on trouve un lieu vers la page des exemples (Demo code). Ouvrez la page de l’exemple pour récupérer le lien vers le fichier compressé à l’aide d’un clic droit sur le lien.
Depuis le Terminal sur le Raspberry Pi, créer un répertoire de travail, par exemple mkdir epaper puis ouvre celui-ci cd epaper . Ensuite, à l’aide de la commande wget, on va récupérer le fichier d’exemple.
wget https://www.waveshare.com/w/upload/f/f5/2.7inch-e-paper-hat-code.7z
Pour le décompresser, nous allons utiliser l’outil p7zip. Exécutez la commande suivante pour l’installer
sudo apt-get install p7zip-full
Il ne nous reste plus qu’à décompresser l’archive avec la commande 7z x nom_du_fichier.7z comme ceci
7za e 2.7inch-e-paper-hat-code.7z
Allez ensuite dans le répertoire des exemple python
cd /raspberrypi/python
Premier test, affichage d’un carré plein au centre de l’écran
Ouvrez un nouveau script nommé rectangle.py avec la commande nano rectangle.py et collez le code suivant. Au minimum, on a besoin d’importer le drivers epd (ici eps2in7 pour 2,7”), ainsi que les librairies Python Image et ImageDraw.
Que fait ce code :
- On créé un objet epd et on l’initialise. Cet objet permettra d’accéder aux fonctions de gestion de l’écran. La seule réellement important est la méthode d’actualisation display_frame()
- On créé ensuite un objet de type Image ayant comme dimension la largeur (width) et la hauteur (height) de l’écran en pixels. Ici 176×264 pixels.
- On dessine ensuite un rectangle au centre de l’écran en se basant sur la largeur et la hauteur de ce dernier
- Enfin on appel la méthode display_frame() pour actualiser l’affichage.
import epd2in7
import Image
import ImageDraw
def main():
#Init driver
epd = epd2in7.EPD()
epd.init()
#Image de la dimension de l ecran - Image with screen size
#255: fond blanc - clear the image with white
image = Image.new('1', (epd2in7.EPD_WIDTH, epd2in7.EPD_HEIGHT), 255)
#Objet image sur lequel on va dessiner - Object image on which we will draw
draw = ImageDraw.Draw(image)
#Dessine un rectangle au centre de l ecran - draw a rectangle in the center of the screen
draw.rectangle((epd2in7.EPD_WIDTH/2-10, epd2in7.EPD_HEIGHT/2-10, epd2in7.EPD_WIDTH/2+10, epd2in7.EPD_HEIGHT/2+10), fill = 0)
#Actualise affichage - Update display
epd.display_frame(epd.get_frame_buffer(image))
if __name__ == '__main__':
main()
Enregistrez le script avec la combinaison CTRL + X puis O (ou Y). Exécuter le script avec la commande python rectangle.py
Vous devez obtenir ce joli rectangle au centre de l’écran epaper. Vous pouvez voir le processus de rafraichissement par la même occasion
Bonus, récupérer les événements des 4 boutons de fonction
Vous avez du remarquer la présence de 4 boutons sur le coté de l’écran (key 1 à key 4). Il est possible de récupérer dans le code python un appui sur un bouton et déclencher par exemple le rafraîchissement de l’écran. On pourra également s’en servir pour d’autres fonctions. On pourrait également déclencher un scénario sur un serveur domotique.
Chaque bouton est connecté sur une broche du GPIO du Raspberry Pi.
- Key 1 sur broche 12
- Key 2 sur la broche 16
- Key 3 sur la broche 18
- Key 4 sur la broche 4
En fonction de votre écran, les broches peuvent changer, on trouve l’info sur le schéma technique. Par exemple ici pour l’écran 2,7”
Créez un nouveau script nano demo.py et collez le code suivant
Il intercepte un appui sur chaque bouton. Un appui sur le bouton 4 actualise l’affichage
import epd2in7
import Image
import ImageFont
import ImageDraw
import time
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
epd = epd2in7.EPD()
epd.init()
image = Image.new('1', (epd2in7.EPD_WIDTH, epd2in7.EPD_HEIGHT), 255) # 255: clear the image with white
key1 = 5
key2 = 6
key3 = 13
key4 = 19
GPIO.setup(key1, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key2, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key3, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key4, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def updateDisplay(string):
draw = ImageDraw.Draw(image)
font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf', 18)
draw.text((20, 50), string, font = font, fill = 0)
#draw.rectangle((epd2in7.EPD_WIDTH/2-10, epd2in7.EPD_HEIGHT/2-10, epd2in7.EPD_WIDTH/2+10, epd2in7.EPD_HEIGHT/2+10), fill = 0)
print('update display')
epd.display_frame(epd.get_frame_buffer(image))
def main():
while True:
key1state = GPIO.input(key1)
key2state = GPIO.input(key2)
key3state = GPIO.input(key3)
key4state = GPIO.input(key4)
if key1state == False:
print('Key1 Pressed')
time.sleep(0.2)
if key2state == False:
print('Key2 Pressed')
time.sleep(0.2)
if key3state == False:
print('Key3 Pressed')
time.sleep(0.2)
if key4state == False:
print('Key4 Pressed')
updateDisplay('Key4 pressed')
time.sleep(0.2)
if __name__ == '__main__':
main()
Comme vous pouvez le constater, le texte est créé horizontalement sur l’image. Lisez l’article suivant pour apprendre comment orienter correctement l’image générée
Voilà, c’est terminé pour ce tutoriel. Nous verrons dans les prochains articles comment l’utiliser sur un micro-contrôleur Arduino (et probablement ESP32, ESP8266). Nous verrons comment récupérer des infos depuis un serveur domotique Jeedom et Domoticz pour créer un petit afficheur.
- Affichage OLED SSD1306 I2C sur Raspberry Pi. Code Python d’une mini station météo connectée à Jeedom avec la librairie Adafruit
- #Test de l’écran LCD 3.5” HDMI tactile (via le GPIO) avec boitier acrylique pour Raspberry Pi 3 sous Raspbian (480×320 à 1920×1080 pixels)
- #Test de l’écran LCD tactile 7 pouces 1024×600 pixels Waveshare avec support acrylique pour Raspberry Pi
- Station météo avec affichage ePaper (Dashboard) pour Jeedom sur Raspberry Pi (via l’API JSON RPC)
- #Test de l’écran ePaper (eInk) Waveshare 2,7 pouces sur Raspberry Pi en Python
Merci pour cette présentation, je viens d’investir dans un Pi Zero W et un epaper 2.7″ pour en faire un afficheur relié à Domoticz. J’attends avec impatience les tutos suivants 🙂
Merci beaucoup Guiguig. J’ai été impressionné par la qualité de l’affichage, je suis vraiment fan ce ces écrans. J’ai trouvé comment afficher du texte dans la bonne direction. Je vais essayer de rédiger un article pour la semaine prochaine. J’espère que tu pourras nous envoyer une ou deux photos de ta réalisation. Bon week end