SaveSavedRemoved 0

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.

Les écrans ePaper (eInk) de Waveshare

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)
1.54 pouces	noir, blanc	2	200×200	27.60 × 27.60	48.0 × 33.0	2	SPI	x
1.54 pouces (B)	rouge, noir, blanc	2	200×200	27.60 × 27.60	48.0 × 33.0	8	SPI	x
2.13 pouces	noir, blanc	2	250×122	48.55 × 23.71	65.0 × 30.2	2	SPI	√
2.13 pouces (B)	rouge, noir, blanc	2	212×104	48.55 × 23.71	65.0 × 30.2	15	SPI	√
2.7 pouces	noir, blanc	2	264×176	57.29 × 38.19	85.0 × 56.0	6	SPI	√
2.7 pouces (B)	rouge, noir, blanc	2	264×176	57.29 × 38.19	85.0 × 56.0	15	SPI	√
2.9 pouces	noir, blanc	2	296×128	66.89 × 29.05	89.5 × 38.0	2	SPI	x
2.9 pouces (B)	rouge, noir, blanc	2	296×128	66.89 × 29.05	89.5 × 38.0	15	SPI	x
4.2 pouces	noir, blanc	2	400×300	84.80 × 63.60	103.0 × 78.5	4	SPI	x
4.2 pouces (B)	rouge, noir, blanc	2	400×300	84.80 × 63.60	103.0 × 78.5	15	SPI	x
4.3 pouces	noir, blanc	4	800×600	88.00 × 66.00	118.0 × 75.0	1.5	UART	x
7.5 pouces	noir, blanc	2	640×384	163.20×97.92	170.2×111.2	6	SPI	√
7.5 pouces (B)	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.

200x200, 1.54 pouces E-ink affichage module avec contrôleur embarqué Communiquer via SPI interface Prend En Charge divers cartes contrôleur

15,94€ ~~17,33€~~

51,82€ ~~56,33€~~

Voir l'offre

AliExpress

Dernière mise à jour des prix le 26 mai 2018 1 h 57 min

Test de l’écran 2,7” Waveshare sur un Raspberry Pi 3

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

1	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

1 2	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

1	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

1	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

1	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

1	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

1	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

1	7za e 2.7inch-e-paper-hat-code.7z

Allez ensuite dans le répertoire des exemple python

cd /raspberrypi/python

1	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()

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()

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.

fr Ok, Merci Je cherche de ce côté.... Anémomètre et girouette connectés DIY à base d'ESP8266

Tostaki Bonjour, Il semble qu'il y ait d'abord et avant tout un souci avec l'I2C sur... Anémomètre et girouette connectés DIY à base d'ESP8266

Jean-Pierre Herrenknecht Super tuto, Merci beaucoup et bravo pour votre site!... Programmer l'ESP8266 avec l'IDE Arduino : librairies, GPIO, Web Serveur, Client Web

fr Bonjour, Je me pose des questions SDA du AS504B sur D2 de l'esp8266, SCL sur ... Anémomètre et girouette connectés DIY à base d'ESP8266

Jeff Merci encore à Projet DIY, 3 ans que j'utilise domoticz, je décide de réinstal... Installer Domoticz sur un Raspberry Pi 3 fonctionnant sous Rapbian Stretch

Box Domotique DIY

Serveurs Open Source

Interfaces

Equipements

Protocoles

Objets Connectés

Firmware Arduino/ESP8266

Dashboard, programmation, bases de données

Arduino

ESP8266 et ESP32

Firmwares

Raspberry pi

Orange Pi

Autres articles

Quoi faire avec le Raspberry Pi ?

#Test de l’écran ePaper (eInk) Waveshare 2,7 pouces sur Raspberry Pi en Python

Principe des écrans ePaper / eInk, avantages et inconvénients

Les écrans ePaper (eInk) de Waveshare

Test de l’écran 2,7” Waveshare sur un Raspberry Pi 3

Installation de l’écran sur le Raspberry Pi

Configuration de Raspbian

Installation des librairies python

Récupérer le driver epd

Premier test, affichage d’un carré plein au centre de l’écran

Bonus, récupérer les événements des 4 boutons de fonction

Inscrivez-vous à la newsletter hebdomadaire

Comparateur de prix

Domotique

Sécurité | énergie | santé

Arduino/Genuino | Compatibles

ESP8266 | ESP32

Mini PC

Accessoires Raspberry Pi 3

Accessoires Raspberry Pi Zero W

Matériels, composants, outillage

Capteurs

Actionneurs

Bons plans

Fabriquer une borne d'arcade retrogaming DIY avec joystick et 8 boutons Recalbox ou Retropie pour moins de 85€

Station météo avec affichage ePaper (Dashboard) pour Jeedom sur Raspberry Pi (via l'API JSON RPC)