Raspberry Pi et GPIO

Connecter un écran LCD 16x2 au Raspberry Pi

Le but de ce projet est de contrôler un écran LCD (Liquid Cristal Display) capable d’afficher 16 caractères en largeur et 2 caractères en hauteur. Les modèles disponibles en vente sur Internet intègrent pratiquement tous un microcontrôleur Hitachi HD44780, composant essentiel et nécessaire pour communiquer avec l’écran.

Pour mener à bien ce projet, équipez-vous des outils suivants :

Le modèle choisi est celui mis en vente par la société Adafruit et constitué d’un brochage à 18 connecteurs :

Le brochage de l’écran LCD est rappelé au dos du modèle. Pour éviter toute confusion, la procédure expliquée dans ce livre ignore le raccordement des connecteurs 17 et 18 aux broches GPIO du Raspberry Pi car les écrans à 16 connecteurs sont les modèles les plus courants sur le marché. La différence majeure entre les modèles à 16 et ceux à 18 connecteurs se situe au niveau de la couleur de l’arrière-plan du LCD :...

Projet #1 : communiquer avec l’écran LCD

En temps normal, la bibliothèque censée être utilisée pour envoyer des informations aux broches GPIO est celle livrée de base avec Raspberry Pi OS : RPi.GPIO. Son utilisation est très proche du système et nécessite de manipuler des octets pour indiquer à l’écran LCD les caractères à envoyer. Fort heureusement, une autre bibliothèque existe déjà et simplifie grandement toute cette partie. Il s’agit de RPLCD. La page d’accueil du projet se trouve sur Github à l’adresse suivante : https://github.com/dbrgn/RPLCD/. Comme d’habitude, il faudra passer par une invocation de pip3 pour installer cette bibliothèque externe sur le Raspberry Pi :

pi@raspberrypi:~ $ sudo pip3 install RPLCD 

L’utilisation de la bibliothèque s’articule autour de la classe CharLCD. Cette classe se compose de trois fonctions essentielles :

Pour simplifier l’élaboration des trois programmes de ce chapitre, la classe LCD16x2 a été écrite en héritant de CharLCD (Chapitre_10/lcd16x2.py) :

1 #!/usr/bin/env python3 
2 import RPi.GPIO as GPIO 
3 from RPLCD.gpio import CharLCD ...

Projet #2 : créer un tube FIFO dédié à l’écran LCD

Les scripts détaillés jusqu’à présent impliquent de devoir écrire du code en Python pour pouvoir forger un message et l’envoyer à l’écran. Éliminer cette étape permettrait de réduire la complexité d’envoi de messages. Pour ce faire, la solution repose sur le standard traditionnel IPC (Inter-Process Communication) à travers l’usage d’un fichier spécial, aussi appelé tube FIFO (First In First Out) et placé dans le répertoire /dev du système de fichiers du Raspberry Pi. En théorie, un tube FIFO est un vase communicant dans lequel deux processus s’échangent des messages. Ainsi, Processus 1 écrit dans le tube pendant que Processus 2 écoute et lit les données envoyées dans le tube :

La manipulation d’un tube FIFO est possible directement depuis le shell via la commande mkfifo :

pi@rasberrypi:~$ mkfifo fifo 
pi@rasberrypi:~$ ls -l fifo 
prw-rw-r-- 1 pi pi 0 mai   9 09:49 fifo 
pi@rasberrypi:~$ cat fifo 

À l’issue de la commande cat, celle-ci se retrouve en suspension dans l’attente que des données soient envoyées dans le tube. Pour ce faire, il suffit d’ouvrir un deuxième shell et d’écrire dans le tube :

pi@raspberrypi:~$ echo 'Ceci est un test' > fifo  
pi@raspberrypi:~$ 

Une fois la commande exécutée, un coup d’œil dans le premier shell montre que la commande cat n’est plus en suspension...

Projet #3 : écrire des messages depuis une interface en ligne de commande

Ce projet met en œuvre la bibliothèque cmd, déjà étudiée dans le chapitre Persistance de données sur le Raspberry Pi, avec notre classe LCD16x2, afin d’envoyer des messages depuis la ligne de commande. Voici le code (Chapitre 10/lcmd.py) :

1 #!/usr/bin/env python3 
2 from lcd16x2 import LCD16x2 
3 import time 
4 import cmd 
5 
6 
7 class LCmD(cmd.Cmd): 
8     def __init__(self): 
9         cmd.Cmd.__init__(self) 
10         self.prompt = ">> " 
11         self.intro = "Bienvenue dans LCmD !" 
12         self.lcd = LCD16x2() 

L’instanciation de la classe LCmD entraîne l’initialisation de la classe LCD16x2 et la connexion au LCD.

14     def do_ecrire(self, ligne):  
15         """Écrit un message dans l'écran du LCD."""  
16         self.lcd.write_string(ligne)  
17  
18     def do_nettoyer(self, ligne):  
19         """Nettoie les caractères du LCD."""  
20        ...

Projet #4 : piloter l’écran LCD depuis une interface graphique tkinter

Pour le dernier exemple de cette série d’applications, quoi de mieux que de créer une énième interface graphique pour les frileux de la ligne de commande. Cet exemple compile les fonctionnalités mises à disposition pour l’écran LCD expliquées jusqu’à présent, qui sont d’écrire et d’envoyer des messages à l’écran ou de les effacer. C’est encore et toujours la bibliothèque tkinter qui est utilisée afin de proposer une interface légère et fluide sur le Raspberry Pi. Le contenu de ce programme est le suivant (Chapitre_10/lcditeur.py) :

1 #!/usr/bin/env python3 
2 from tkinter.messagebox import askyesno 
3 from lcd16x2 import LCD16x2 
4 from tkinter import Button, Frame, Text 
5 from tkinter import SUNKEN, LEFT, RIGHT 
6 from tkinter import BOTH, WORD, YES, END 
7 
8 
9 class LCDiteur(Frame): 
10     def __init__(self, parent=None): 
11         Frame.__init__(self, parent) 
12         self.pack(expand=YES, fill=BOTH) 
13         self.nom_editeur = self.__class__.__name__ 
14         self.creer_composants() ...