Traduit de Anglais vers Français - www.onlinedoctranslator.

com

Programmation avec Node-RED

Figure 5.28 Configurer l'e-mail dans le nœud

• Créez un nœud de fonction nomméMARCHE/ARRÊT, ayant les instructions suivantes (voir

Figure 5.29). Ici, fonctionsous-titreest utilisé pour extraire les deux premiers caractères
de la commande email reçue. Si la commande estSUR, puis 1 est renvoyé pour activer le
buzzer. Sinon, si la commande estDE, puis 0 est renvoyé pour désactiver le buzzer. Cliquez
surFait:

var cmd = msg.payload.substr(0,2); var On =

{charge utile : "1"} ;
var Off = {charge utile : "0"} ;

si(cmd == "ON")
retournez;
sinon si(cmd == "OF")
retour Désactivé ;

Figure 5.29 Configuration du nœud de fonction

●94
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

• Créer unsortie rpi gpionœud et définissez le numéro de port sur GPIO 2. Rejoignez les 3 nœuds et
cliquez surDéployer

Le programme devrait maintenant vérifier le compte de messagerie toutes les 10 secondes. Tu

devrais voir les motsde liaisonetaller chercheraffiché sous leemail dansnœud juste avant la
vérification du compte. Dans ce projet, le buzzer doit retentir lorsqu'un e-mail est envoyé au compte
dogantest@gmail.com avec le contenu du courrier contenant le motSUR. De même, le buzzer doit
cesser de sonner lorsque le motDE(notez qu'il est OF et non OFF) est envoyé par email.

Juste pour rappel, si vous utilisez un compte Gmail, vous devrez l'activeraccès moins sécurisévia les
paramètres de votre compte Google. Vous pouvez également saisir ce qui suit dans votre navigateur
Web :

moncompte.google.com/u/1/lesssecureapps

Le buzzer de ce projet peut être remplacé par exemple par un relais si vous le souhaitez afin que les équipements
électriques (par exemple les appareils électroménagers) puissent être contrôlés à distance en envoyant des e-mails depuis
n'importe où dans le monde.

5 .8 Projet 18 – Confirmation de l'état du buzzer

Description:Dans le projet précédent, nous avons vu comment contrôler à distance un port GPIO du
Raspberry Pi en envoyant des emails. Le problème ici est que lorsque nous envoyons une commande au
Raspberry Pi, nous ne savons pas si le port GPIO a pris ou non la valeur requise. Dans ce projet, nous lisons
l'état du port GPIO et envoyons un email pour confirmer l'état de la broche du port. La confirmation est très
importante dans certaines applications, par exemple, si nous souhaitons activer notre chaudière
domestique à l'aide d'un relais, nous voulons nous assurer que la chaudière a effectivement été activée.

Si la commandeSURest envoyé pour activer le buzzer, puis le messageLe buzzer est allumésera
envoyé à l'adresse e-mail spécifiée lorsque le buzzer est effectivement activé. Si par contre
commandeDEest envoyé, alors le messageLe buzzer est éteintsera envoyé à l’adresse e-mail
indiquée.

But:Le but de ce projet est de montrer comment l'état d'une broche du port GPIO peut être lu, puis un
message peut être envoyé à un compte de messagerie pour confirmer l'état de la broche du port GPIO.

Diagramme: Le schéma fonctionnel du projet est tel que présenté dans la figure 5.23.

Schéma: Le schéma de circuit du projet est tel que présenté sur la figure 5.30. Ici, le buzzer est
connecté directement à la broche du port GPIO 2 du Raspberry Pi 4 comme dans le projet précédent,
et GPIO 2 est connecté au GPIO 3 où GPIO 3 est configuré comme entrée dans Node-RED. L'état du
buzzer sera lu par GPIO 3 et un message sera envoyé à un compte email.

●95
Programmation avec Node-RED

Figure 5.30 Schéma de circuit du projet

Programme de flux Node-RED :La figure 5.31 montre le programme de flux. Dans ce programme, 6 nœuds
sont utilisés : 3 nœuds pour recevoir l'e-mail et contrôler le buzzer en conséquence, et 3 nœuds pour
envoyer l'état du port du buzzer à l'adresse e-mail spécifiée.

Figure 5.31 Programme de flux du projet

Les étapes sont les suivantes:

• Les 3 premiers nœuds utilisés pour recevoir les emails sont les mêmes que dans le projet
précédent et ne sont pas répétés ici (seul le nom de l'e-mail dans le nœud est modifié)

• Les 3 nœuds suivants servent à recevoir l'état du port GPIO 3 et à envoyer un email à
l'adresse spécifiée.

• Cliquez surrpi gpio dansnœud, faites-le glisser et déposez-le dans l’espace de travail. Nommez ce nœud
comme GPIO3et configurez-le pour recevoir l'état du port GPIO 3 comme indiqué sur la figure 5.32,
cliquez surFait. Ce port recevra l'état de la broche du port GPIO 2 qui est connectée au GPIO 3.

●96
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Figure 5.32 Configurer le gpio rpi dans le nœud

• Créer unfonctionnœud, nommez-le commeÉtat du buzzer, saisissez les instructions suivantes,

puis cliquez surFait(Graphique 5.33) :

if(msg.payload == "1")
msg.payload = "Le buzzer est activé"
autre
msg.payload = "Le buzzer est désactivé"

renvoie le message ;

Figure 5.33 Configurer le nœud de fonction

• Cliquer surenvoyer un e-mailnœud, faites-le glisser et déposez-le dans l'espace de travail et nommez-le
commeEnvoyer un mail. Configurez ce nœud comme indiqué dans la figure 5.34. L'état du buzzer est
envoyé à l'adresse email :d.ibrahim@btinternet.com De l'adresse e-mail:dogantest99@gmail.com(vous
devez saisir vos propres adresses e-mail et mots de passe)

●97
Programmation avec Node-RED

Figure 5.34 Configurer le nœud de sortie de courrier électronique

• Joignez les nœuds comme dans la figure 5.31 et cliquez surDéployer. Pour tester le
programme, envoyez la commandeSURà l'adresse e-maildogantest99@gmail.com, et le
buzzer doit être activé. En même temps, le messageLe buzzer est allumésera envoyé à
l'adresse e-maild.ibrahim@btinternet.com (vous devez utiliser vos propres adresses e-mail
et mots de passe).

5 .9 Projet 19 – Contrôler plusieurs ports GPIO à distance par courrier électronique

Description:Dans ce projet, nous contrôlerons à distance 4 ports GPIO du Raspberry Pi en envoyant un email.
Quatre LED sont connectées aux ports GPIO du Raspberry Pi via des résistances de limitation de courant. Les LED
sont allumées/éteintes en envoyant des commandes par courrier électronique sous la forme suivante :

MARCHE=1 allumer la LED1

MARCHE=2 allumer la LED2
MARCHE=3 allumer la LED3
MARCHE=4 allumer la LED4
DE=1 éteindre la LED1
DE=2 éteindre la LED2
DE=3 éteindre la LED3
DE=4 éteindre la LED4

But:Le but de ce projet est de montrer comment plusieurs ports GPIO du Raspberry Pi peuvent être
contrôlés à distance en envoyant des messages électroniques.

Diagramme: La figure 5.35 montre le schéma fonctionnel du projet.

●98
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Figure 5.35 Schéma fonctionnel du projet

Schéma: Le schéma de circuit du projet est présenté à la figure 5.36. Les LED sont connectées aux
broches suivantes du port Raspberry Pi via des résistances de limitation de courant de 470 Ohm :

DIRIGÉ Nom du port Raspberry Pi Numéro de broche du port Raspberry Pi 3

LED1 GPIO2
LED2 GPIO3 5
LED3 GPIO4 7
LED4 GPIO17 11

La broche de port numéro 9 du Raspberry Pi est la broche de masse qui est connectée aux broches cathodiques de
toutes les LED.

Figure 5.36 Schéma de circuit du projet

Programme de flux Node-RED :La figure 5.37 montre le programme de flux. Dans ce programme 6 nœuds
sont utilisés : unemail dansnœud pour vérifier et recevoir l'e-mail à intervalles réguliers, unfonction nœud
avec 4 sorties pour décoder les commandes utilisateur, et 4sortie rpi gpionœuds pour contrôler les 4 LED.

●99
Programmation avec Node-RED

Figure 5.37 Programme de flux du projet

Les étapes sont les suivantes:

• Créere-maildans le nœud comme dans les projets précédents et nommez-le commeRecevoir un e-mail

• Créer unfonctionnœud nomméALLUMÉ ÉTEINTavec les déclarations suivantes (voir Figure

5.38). Variablecmdextrait les 3 premiers caractères de la commande et pour les
commandes valides, il a la valeur deMARCHE=ouDE=. Variableportextrait le numéro de
LED requis et pour les commandes valides, il a les valeurs de1,2,3, ou4. Remarquez
comment plusieurs sorties sont gérées dans la fonction :

var cmd = msg.payload.substr(0,3); var port =

msg.payload.substr(3,1); var On = {charge utile :
"1"} ;
var Off = {charge utile : "0"} ;

si(cmd == "ON=")
{
si(port == "1")
return [On, null, null, null] ; sinon si(port
== "2")
return [null, On, null, null] ; sinon si(port
== "3")
return [null, null, On, null] ; sinon si(port
== "4")
retourner [null, null, null, On]
}

si(cmd == "OF=")
{
si(port == "1")
return [Off, null, null, null] ; sinon si(port
== "2")
return[null, Off, null, null] ; sinon si(port
== "3")
return [null, null, Off, null] ; sinon si(port
== "4")
retourner [null, null, null, Off]
}

●100
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Figure 5.38 Configuration de la fonction (seule une partie du code est affichée)

• Créer 4sortie rpi gpionœuds, un pour chacune des LED, LED1, LED2, LED3 et LED4.
Définissez les noms des broches du port surGPIO2,GPIO3,GPIO4etGPIO17
respectivement et remettre les états initiaux des ports à 0. Un exemple pourGPIO17 est
illustré à la figure 5.39. Cliquez surFaitpour chaque nœud.

Figure 5.39 Configuration du port pour LED4

●101
Programmation avec Node-RED

• Joignez les nœuds comme indiqué dans la figure 5.37 et cliquez surDéployer. Pour tester le programme,
connectez le matériel comme sur la Figure 5.36 et envoyez par exemple un email avec le contenu de
MARCHE=2. La LED2 devrait s'allumer. Envoyez un email avecDE=2et cette fois, la LED2 devrait
s'éteindre

Les LED utilisées dans ce projet peuvent être remplacées par des relais si vous le souhaitez afin que les équipements
électriques puissent facilement être contrôlés à distance par envoi d'e-mails.

La figure 5.40 montre le projet construit sur une maquette où les LED sont connectées au Raspberry
Pi à l'aide de câbles de liaison.

Figure 5.40 Construction du projet sur une maquette

Juste pour rappel, si vous utilisez un compte Gmail, vous devrez l'activeraccès moins sécurisévia les
paramètres de votre compte Google comme décrit dans les projets précédents en utilisant les nœuds de
messagerie.

5 .10 Projet 20 – Simulateur de feux de circulation

Description:Dans ce projet, nous allons simuler un ensemble de feux de circulation. 3 LED sont
connectées aux ports GPIO du Raspberry Pi : une LED Rouge, une LED Orange et une LED Verte. Les
LED sont allumées et éteintes comme dans la séquence PDL suivante :

FAIRE POUR TOUJOURS

Allumez la LED rouge pendant 17 secondes

Allumez les LED rouge et orange pendant 3 secondes

●102
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Allumez la LED verte pendant 15 secondes

Allumez la LED orange pendant 3 secondes
ENDDO

But:Le but de ce projet est de montrer comment un programme simple de simulation de feux de circulation peut
être développé avec Node-RED en utilisant 3 LED connectées à un Raspberry Pi.

Diagramme: La figure 5.41 montre le schéma fonctionnel du projet.

Figure 5.41 Schéma fonctionnel du projet

Schéma: Le schéma de circuit du projet est présenté à la figure 5.42. Les LED sont connectées aux
broches suivantes du port Raspberry Pi via des résistances de limitation de courant de 470 Ohm :

DIRIGÉ Nom du port Raspberry Pi Numéro de broche du port Raspberry Pi 3

Rouge GPIO2
Orange GPIO3 5
Vert GPIO4 7

La broche de port numéro 9 du Raspberry Pi est la broche de masse qui est connectée aux broches cathodiques de
toutes les LED.

Figure 5.42 Schéma de circuit du projet

Programme de flux Node-RED :La figure 5.43 montre le programme de flux. Dans ce programme, 11 nœuds sont
utilisés : uninjecternœud pour démarrer la simulation, 4retardnœuds pour générer les délais de synchronisation
requis, 3déclenchementnœuds, et 3sortie rpi gpionœuds.

●103
Programmation avec Node-RED

Figure 5.43 Programme de flux du projet

Les étapes sont les suivantes:

• Créé uninjecternœud et nommez-le commeCOMMENCER

• Créer 4retardnœuds comme le montre la figure 5.43. Ces nœuds généreront les délais
requis. Par exemple, lorsque la LED rouge reste allumée pendant 20 secondes. Après un
délai de 17 secondes, la LED orange s'allume également, de sorte que le rouge et l'orange
soient allumés pendant 3 secondes. Après ce temps, la LED verte reste allumée pendant
15 secondes, et après ce temps, la LED orange s'allume pendant 3 secondes, puis revient
à la LED rouge. Cette séquence se répète indéfiniment. La figure 5.44 montre un exemple
typiqueretardconfiguration des nœuds.

Figure 5.44 Nœud de retard de 17 secondes

• Créez-en 3déclenchementles nœuds qui envoient 1, attendent le temps spécifié, puis envoient 0.
La figure 5.45 montre à titre d'exemple comment les 20sdéclenchementLe nœud est configuré.

●104
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Figure 5.45 Configuration d'un nœud de déclenchement

• Créez-en 3sortie rpi gpionœuds pour les broches GPIO GPIO 2, GPIO 3 et GPIO 4, et
nommez-les commeROUGE,ORANGE, etVERTrespectivement. A titre d'exemple, la figure
5.46 montre la configuration du nœud GREEN.

Figure 5.46 Configuration du nœud VERT

• Joignez tous les nœuds comme indiqué dans la Figure 5.43, puis cliquez surDéployer. Cliquez sur
le bouton du nœudinjecterpour démarrer la simulation. Vous devriez voir les 3 LED simulant les
feux de circulation avec le timing spécifié au début de ce projet.

●105
Programmation avec Node-RED

Notez que dans ce projet lecommentaireLe nœud est également introduit. Ce nœud nous aide à rédiger
des commentaires sur un projet. Dans cet exemple de projet, le contenu ducommentaireLes nœuds sont
illustrés à la figure 5.47.

Figure 5.47 Contenu du nœud de commentaire

Ce projet a été construit sur une maquette comme dans les projets précédents.

5 .11 Projet 21 – Entrée interrupteur à bouton-poussoir

Description:Il s'agit d'un projet très simple dans lequel un interrupteur à bouton-poussoir (bouton
en abrégé) et une LED sont connectés au Raspberry Pi. Le projet allume la LED lorsque le bouton est
enfoncé.

But:Le but de ce projet est de montrer comment un bouton peut être utilisé dans un projet basé sur Node-
RED.

Informations d'arrière-plan: Les boutons sont couramment utilisés dans les projets basés sur des
microcontrôleurs afin de modifier l'état d'une broche du port d'entrée. Le processeur détecte lorsque le
bouton est enfoncé et exécute ensuite le code requis.

Les boutons peuvent être utilisés dans deux modes : Normalement FAIBLE et normalement ÉLEVÉ. Dans un
mode normalement BAS, l'état de sortie du bouton est à 0 logique par défaut et passe à 1 logique lorsque le
bouton est enfoncé. La sortie reste dans cet état jusqu'à ce que le bouton soit relâché. Le schéma de circuit
de la figure 5.48 montre un bouton normalement BAS.

Figure 5.48 Bouton Normalement BAS

●106
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Dans un bouton normalement ÉLEVÉ, l'état du bouton est à la logique 1 par défaut et passe à la logique 0
lorsque le bouton est enfoncé. La sortie reste dans cet état jusqu'à ce que le bouton soit relâché. Le schéma
de circuit de la figure 5.49 montre un bouton normalement ÉLEVÉ.

Figure 5.49 Bouton Normalement ÉLEVÉ

Le bouton utilisé dans ce projet est un petit composant comportant 4 broches, comme le montre la figure 5.50. En
fait, le bouton est un appareil à 2 broches où les broches sont parallèles pour plus de commodité.

Figure 5.50 Petit bouton et son schéma de connexion

Les interrupteurs mécaniques ont des problèmes de rebond. Cela se produit parce que lorsqu'un interrupteur est
basculé, ses contacts mécaniques rebondissent (passent d'un état à un autre) jusqu'à ce qu'ils se stabilisent. Bien
que ce temps de stabilisation puisse paraître très faible (environ 10 ms), il s'agit en réalité d'un temps très long si
l'on considère le temps de traitement d'un microcontrôleur. Des circuits anti-rebond spéciaux peuvent être utilisés
pour éliminer cet effet de rebond. Heureusement, lerpi gpio dans Le nœud fournit un paramètre pour définir le
temps anti-rebond du commutateur afin que les contacts du commutateur ne soient pas lus avant l'expiration de ce
délai. Cela garantit que l'état correct de la sortie du commutateur est lu par le microcontrôleur.

Diagramme: La figure 5.51 montre le schéma fonctionnel du projet.

Figure 5.51 Schéma fonctionnel du projet

●107
Programmation avec Node-RED

Schéma: Le schéma de circuit du projet est illustré à la figure 5.52 où la LED est connectée à la
broche du port GPIO 2. La broche du port GPIO 3 est connectée à un côté du bouton, tandis que
l'autre côté du bouton est connecté à la broche de terre de Tarte aux framboises.

Figure 5.52 Schéma de circuit du projet

Programme de flux Node-RED :La figure 5.53 montre le programme de flux. Dans ce programme 2 nœuds sont
utilisés :

Figure 5.53 Programme de flux du projet

Les étapes sont les suivantes :

• Créer unrpi gpio dansnœud et maniez-le commeBOUTON, définissez le nom de la broche sur GPIO 3 et
réglez la résistance sur pulldown.

• Créer unsortie rpi gpionœud et nommez-le commeDIRIGÉ, définissez le nom de la broche sur GPIO 3 et
initialisez le niveau de la broche à 0

• Joignez les deux nœuds comme indiqué dans la Figure 5.51, puis cliquez surDéployer.

Vous devriez voir que la LED est allumée et appuyer sur le bouton éteint la LED.
Notez que dans ce programme de flux, nous voulons le contraire. c'est-à-dire que la LED doit être éteinte
normalement et qu'appuyer sur le bouton doit l'allumer. Un programme de flux modifié qui fonctionnera
correctement est illustré à la figure 5.54.

Figure 5.54 Programme de flux modifié

●108
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Cette modification peut être effectuée comme expliqué dans les étapes suivantes :

• Créer unrpi gpio dansnœud comme ci-dessus et nommez-le commeBOUTON, définissez le nom de la broche
sur GPIO 3 et définissez la résistance sur pulldown

• Créer unchangernœud et nommez-le commeSI 1 ou 0. Configurez ce nœud de telle sorte que si

l'entrée est 1, dirigez-le vers la sortie supérieure, sinon dirigez-le vers la deuxième sortie. Pour
diriger vers la deuxième sortie, cliquez sur Ajouter et sélectionnezsinoncomme le montre la
figure 5.54. Cliquez surFait.

Figure 5.55 Configurer le nœud de commutation

• Créer unchangementnœud et nommez-le commeRégler sur 0. Configurez ce nœud pour qu'il renvoie 1 comme
indiqué dans la figure 5.56. Cliquez surFait

Figure 5.56 Configurer le nœud de modification

• Créer un autrechangementnœud et nommez-le commeRégler sur 1et définissez la sortie sur 1. Cliquez
surFait

• Créer unsortie rpi gpionœud et nommez-le commeDIRIGÉ, définissez le nom de la broche sur GPIO 3 et
initialisez le niveau de la broche à 0

• Joignez les 5 nœuds comme indiqué sur la Figure 5.54, puis cliquez surDéployer.

Vous devriez maintenant voir que la LED est éteinte et appuyer sur le bouton allume la LED.

La figure 5.57 montre le circuit construit sur une maquette.

●109
Programmation avec Node-RED

Figure 5.57 Circuit construit sur une maquette

5 .12 Projet 22 – Modification de la luminosité des LED – La sortie PWM

Description:Il s'agit d'un projet très simple dans lequel la luminosité d'une LED est modifiée en
modifiant la tension moyenne et donc le courant moyen traversant la LED.

But:Le but de ce projet est de montrer comment une forme d'onde PWM peut être générée à l'aide de
Node-RED.

Informations d'arrière-plan: PWM (Pulse width Modulation) est une technique couramment utilisée dans
les circuits électroniques afin de modifier la tension moyenne fournie à une charge. Par exemple, la tension
moyenne fournie à un appareil de chauffage peut être modifiée en lui envoyant une forme d'onde de
tension PWM à amplitude fixe, puis en modifiant les caractéristiques de cette forme d'onde.

Une forme d'onde PWM est essentiellement une forme d'onde carrée positive où le temps ON (également appelé
MARK) et le temps OFF (également appelé ESPACE) peuvent être modifiés. La figure 5.58 montre une forme d'onde
PWM typique avec une période de T. Le rapport entre le temps d'activation et la période est connu sous le nom de
cycle de service de la forme d'onde et en modifiant le cycle de service, nous pouvons effectivement modifier la
tension moyenne fournie à la charge.

Figure 5.58 Forme d'onde PWM typique

●110
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Le cycle de service est généralement représenté sous forme de pourcentage. Par exemple, un rapport cyclique de 50 %
correspond à la situation où le temps ON est égal au temps OFF. Dans un rapport cyclique de 100 %, la forme d'onde est
toujours activée (c'est-à-dire qu'il n'y a pas de temps d'arrêt). De même, dans un rapport cyclique de 25 %, la durée du temps
d'activation correspond à un quart de la période de la forme d'onde. La figure 5.59 montre les formes d'onde PWM avec
différents cycles de service.

Figure 5.59 Forme d'onde PWM avec différents cycles de service

Schéma: Le schéma de circuit du projet est comme sur la figure 5.4 où une LED est connectée à la
broche du port GPIO 2 du Raspberry Pi.

Programme de flux Node-RED :La figure 5.60 montre le programme de flux. Dans ce programme, 6 nœuds sont
utilisés : 5injecternœuds avec différents paramètres de cycle de service et unsortie rpi gpionœud.

Figure 5.60 Programme de flux du projet

Les étapes sont les suivantes :

• Créez-en 5injecternœuds, définissez les charges utiles sur des valeurs numériques de 2, 5, 10, 50, 100.
Ce seront les cycles de service de la forme d'onde PWM. Nommez chaque nœud d’injection avec ses
cycles de service correspondants, comme indiqué dans la figure 5.60. Par exemple, la configuration du
nœud avec un rapport cyclique de 50 % est illustrée à la figure 5.61.

●111
Programmation avec Node-RED

Figure 5.61 Configuration pour un cycle de service de 50 %

• Créez un nœud de sortie rpi gpio et nommez-le LED, définissez le nom du port sur GPIO 2 et définissez le type
sur la sortie PWM comme indiqué dans la Figure 5.61. Cliquez sur Terminé

Figure 5.62 Configurer le nœud de sortie rpi gpio

Joignez les nœuds comme dans la figure 5.60. Cliquez sur injecter le nœud 2% et vous devriez voir que la LED est très faible.
Cliquer sur des cycles de service plus élevés devrait rendre la LED plus lumineuse.

5 .13 Résumé
Dans ce chapitre, nous avons appris comment connecter des composants externes aux ports GPIO du
Raspberry Pi puis comment accéder à ces composants depuis les programmes Node-RED.

Dans le prochain chapitre, nous verrons comment connecter un écran LCD à notre Raspberry Pi et nous
développerons également d'autres projets utilisant un écran LCD.

●112
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Chapitre 6 • Utilisation des écrans LCD avec Node-RED

6 .1 Aperçu
Dans les systèmes à microcontrôleur, la sortie d'une variable mesurée est généralement affichée à l'aide de LED,
d'écrans à 7 segments ou d'écrans de type LCD. Les écrans LCD présentent l'avantage de pouvoir être utilisés pour
afficher des données alphanumériques ou graphiques. Certains écrans LCD comportent 40 caractères ou plus et
peuvent afficher plusieurs lignes. Certains autres écrans LCD peuvent être utilisés pour afficher des images
graphiques. Certains modules offrent des écrans couleur tandis que d'autres intègrent un rétroéclairage afin de
pouvoir être visualisés dans des conditions de faible luminosité.

Il existe essentiellement deux types d'écrans LCD en ce qui concerne la technique d'interface : les écrans LCD parallèles et les
écrans LCD série. Les écrans LCD parallèles (par exemple Hitachi HD44780) sont connectés à un microcontrôleur en utilisant
plusieurs lignes de données et les données sont transférées sous forme parallèle. Il est courant d'utiliser 4 ou 8 lignes de
données. L'utilisation d'une connexion à 4 fils permet d'économiser les broches d'E/S mais est plus lente puisque les
données sont transférées en deux étapes. L’une des normes LCD parallèles les plus couramment utilisées est le HD44780.

La programmation d'un écran LCD parallèle est généralement une tâche complexe et nécessite une bonne
compréhension du fonctionnement interne des contrôleurs LCD, y compris les chronogrammes. Heureusement, la
plupart des langages de haut niveau fournissent des commandes de bibliothèque spéciales pour afficher les
données sur des écrans LCD alphanumériques et graphiques. Tout ce que l'utilisateur a à faire est de connecter
l'écran LCD au microcontrôleur, de définir la connexion LCD dans le logiciel, puis d'envoyer des commandes
spéciales pour afficher les données sur l'écran LCD.

Les écrans LCD série sont connectés au microcontrôleur en utilisant seulement quelques lignes de données. Les
écrans LCD série sont beaucoup plus faciles à utiliser mais ils coûtent plus cher que les écrans parallèles. L'un des
écrans LCD série les plus couramment utilisés utilise le I2Protocole de bus C où seuls deux fils sont nécessaires pour
la communication, à savoir SDA (données) et SCL (horloge). Il y a un périphérique maître sur le bus et il peut y avoir
un certain nombre de périphériques esclaves, chaque périphérique ayant une adresse unique afin de pouvoir être
identifié. La figure 6.1 montre un I typique2Bus C avec un maître et deux appareils esclaves. Notez que le bus doit
être terminé par des résistances de rappel vers l'alimentation. Les lecteurs intéressés devraient pouvoir trouver de
nombreux articles, notes d'application et fiches techniques sur Internet sur I2C. Dans ce chapitre, nous utiliserons
un I2Écran LCD basé sur C dans les projets Raspberry Pi basés sur Node-RED.

Figure 6.1 I2Structure de bus C avec un maître et 2 appareils esclaves

●113
Programmation avec Node-RED

6 .2 Framboise Pi I2Ports C
Raspberry Pi fournit deux ports I2C SCL0 et SCL1 aux broches GPIO suivantes :

je2Nom C Broche du port GPIO Signal

SCL0 GPIO0 SDA0

SCL0 GPIO1 SCL0

SCL1 GPIO2 SDA1

SCL1 GPIO3 SDA2

Il est recommandé d'utiliser SCL1 dans I2Applications basées sur C. Les deux lignes I2C sont alimentées en interne
jusqu'à une alimentation de +3,3 V à l'aide de résistances de 1,8 K.

Le je2C sur votre Raspberry Pi 4 doit être activé à l'aide de l'utilitaire raspi-config avant de pouvoir être utilisé. Les
étapes sont les suivantes :

• Démarrez raspi-config sur votre Raspberry Pi 4 en entrant la commande suivante

pi@raspberrypi :~ $sudo raspi-config

• Descendre à l'élément5 options d'interface

• Descendez jusqu'àP5I2C(voir Figure 6.2) et appuyez sur Entrée

• SélectionnerOuipour permettre au je2Interface C, puis cliquez surD'ACCORDet quittez l'utilitaire raspi-

config

Figure 6.2 Déplacer vers P5 I2C

Certains des je2Les appareils C fonctionnent avec du +5V. Il est important d'être prudent lors de la
connexion de tels appareils à votre Raspberry Pi car la tension aux broches E/S du Raspberry Pi ne doit pas
dépasser +3,3 V, sinon le Raspberry Pi pourrait être endommagé. Il est sécuritaire de connecter un I2
Appareil C qui fonctionne avec +5V sur votre Raspberry Pi si l'appareil n'a pas de résistances de rappel
internes sur son I2Lignes C. Si le je2Les lignes C de l'appareil sont connectées en interne à
+ 5V, alors vous ne devez pas connecter un tel appareil à votre Raspberry Pi sans utiliser des circuits
convertisseurs de niveau de tension pour abaisser la tension de +5V à +3,3V.

●114
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

6 .3 Je2CLCD
Le communément disponible I2L'écran LCD C se compose d'un écran 16 x 2 caractères compatible
HD44780 qui fonctionne en mode 4 bits. Une petite carte est branchée à l'arrière de la carte LCD.
Cette carte possède une puce PCF8574 qui convertit I2Données série C sous forme parallèle pour
l'écran LCD. Bien que l'adresse esclave de l'écran LCD puisse être modifiée de 0x20 à 0x27, sa valeur
par défaut est 0x27. Le module LCD fonctionne avec +5V et il n'a pas de résistances de rappel
internes sur son I2Lignes C. Le module peut donc être directement connecté au Raspberry Pi I2Lignes
C.

Pour tester le module LCD et trouver son adresse esclave, suivez les étapes ci-dessous :

• Connectez les broches SDA et SCL des modules LCD respectivement aux broches des ports
GPIO 2 et GPIO 3 du Raspberry Pi.

• Connectez respectivement les broches Vcc et GND du module LCD aux broches +5V et GND
du Raspberry Pi.

• Entrez la commande suivante sur votre Raspberry Pi :

pi@raspberrypi :~ $sudo i2cdetect –y 1

• Vous devriez obtenir un affichage similaire à celui présenté dans la figure 6.3. Notez sur cette
figure que l'adresse esclave de votre module LCD est 0x27

Figure 6.3 L'adresse du module LCD est 0x27

• Si l'adresse du module LCD ne s'affiche pas, cela signifie qu'il y a des erreurs. Vous devriez
vérifier vos connexions et réessayer. Vous devrez peut-être également installer le I2Outils
C en entrant les commandes suivantes :

pi@raspberrypi :~ $sudo apt-get install python-smbus

pi@raspberrypi :~ $sudo apt-get installer i2c-tools

6 .4 Installation du I2Logiciel LCD C sur Node-RED

Il y en a plusieurs2C Appareils LCD. Celui que nous utiliserons dans ce projet est un écran 16
caractères sur 2 lignes compatible HD44780, doté d'une petite carte à l'arrière avec une puce
PCF8574 (voir Figure 6.4).

●115
Programmation avec Node-RED

Figure 6.4 I2C LCD utilisé dans le projet

Un nœud LCD I2C compatible doit être installé pour qu'il soit disponible dans la palette Node-RED. Les
étapes pour l'installer sont les suivantes :

• Démarrez Node-RED et cliquez surMenu -> Gérer la palettepuis cliquez surInstaller

• Entrernœud-rouge-contrib-lcd20x4-i2cdans le chemin de recherche et cliquez surinstaller

• Vous devriez maintenant voir un nouveau nœud appeléLCD20x4 I2C

Le nœud LCD peut être utilisé pour les écrans LCD comportant jusqu'à 4 lignes et il accepte un objetmsg.
charge utile .msgs. Si l'objet transmis ne contient pas 4 lignes, la différence est remplie de lignes vides. Les
points suivants sont importants lors de l'utilisation de ce nœud LCD :

• messagedoit être une chaîne ne dépassant pas 20 caractères. Le défilement sera effectué si plus
de 20 caractères sont envoyés à l'écran LCD.

• UNpositionl'objet peut être spécifié entre 1 et 20 (la valeur par défaut est 1 s'il n'est pas spécifié)
qui est utilisé pour décaler le texte (des espaces peuvent être insérés au lieu d'utiliser cet objet)

• UNcentreL'objet est facultatif et doit être spécifié sous forme de valeur booléenne, transmise sous forme de
chaîne.

S'il y a une erreur dans les données envoyées à l'écran LCD, un message d'erreur s'affichera sur
l'écran LCD.

Un exemple est donné ci-dessous pour montrer comment le nœud LCD peut être utilisé.

Exemple
Développer un programme de flux pour afficher le texteBonjour dedans la rangée supérieure etMon écran LCDdans la
deuxième rangée.

Solution
Le programme de flux requis est illustré à la figure 6.5.

Figure 6.5 Programme de flux de l'exemple

●116
 Chapitre 5 • Projets Raspberry Pi basés sur Node-RED utilisant Gpio

Les étapes sont les suivantes:

• Créé uninjecternœud et nommez-le commeCliquez sur

• Créer unfonctionnœud et nommez-le commeAfficher. Entrez les instructions suivantes à

l'intérieur de ce nœud (voir Figure 6.6).

msg.payload={msgs :[
{msg : "Bonjour de"},
{msg:"Mon écran LCD"}

]} ;
renvoyer un message ;

Le message dans la première partie de l'instruction entouré de {} est envoyé à la rangée supérieure et le
deuxième message entouré de {} est envoyé à la rangée inférieure de l'écran LCD.

Figure 6.6 Contenu du nœud de fonction

• Cliquez, faites glisser et déposez leLCD20x4 I2Cnœud à l'espace de travail et changez son nom
enÉcran LCD.Définissez l'adresse I2C sur 0x27 et cliquez surFait

• Joignez les nœuds comme indiqué dans la figure 6.5, puis cliquez surDéployer. Vous devriez voir le texte affiché
comme indiqué dans la figure 6.7

Figure 6.7 Texte affiché sur l'écran LCD

Le format de l'objet LCD pour un écran LCD à deux rangées (16 x 2) est le suivant (voir lien :https://
flux. nodered.org/node/node-red-contrib-lcd20x4-i2c) :

msg.payload = {
msg : [
{
msg : "chaîne",

●117
Programmation avec Node-RED

pos : numéro,
centre : "booléen"
},
{
msg : "chaîne",
pos : numéro,
centre : "booléen"
},
]
};

Les données à afficher sont saisies après le mot-clémessage. Le premier message concerne la rangée supérieure et
le deuxième message concerne la rangée inférieure de l’écran LCD.

6 .5 Projet 23 – Affichage de l'heure actuelle sur l'écran LCD

Description:Dans ce projet, l'heure actuelle est affichée sur l'écran LCD toutes les secondes dans le
format suivant :

Heure actuelle
Heure=hh:mm:ss

But: Le but de ce projet est de montrer comment l'heure actuelle peut être extraite puis affichée sur
l'écran LCD toutes les secondes.

Schéma: La figure 6.8 montre le schéma de circuit du projet. L'écran LCD est directement connecté
au I2Broches C du Raspberry Pi.

Figure 6.8 Schéma de circuit du projet

Programme de flux Node-RED: La figure 6.9 montre le programme de flux qui se compose de 3
nœuds : uninjecternœud, unfonctionnœud, et unLCD20x4 I2Cnœud.

●118