L’afficheur LCD alpha-numérique est un outil très pratique pour afficher des informations sur un écran. Il peut être utilisé pour afficher des messages, des données, des informations et bien plus encore. Il est possible de contrôler un afficheur LCD alpha-numérique à partir du Terminal Série, ce qui permet de le configurer et de le contrôler à distance. Dans cet article, nous allons vous expliquer comment contrôler un afficheur LCD alpha-numérique à partir du Terminal Série et quels sont les avantages de ce type de contrôle.
Contrôler un afficheur LCD alpha-numérique à partir du Terminal Série
1. Présentation
Ce programme permet de contrôler un afficheur LCD alpha-numérique depuis le Terminal série du logiciel Arduino à l’aide d’instructions simple (blink, noblink, clear, etc..).
Ce programme exploite les possibilités très intéressantes de l’objet String qui permet de manipuler facilement les chaînes de caractères.
Ce programme est particulièrement pratique pour ceux qui débute avec l’utilisation d’un afficheur LCD : ils pourront utiliser le programme directement dans Arduino pour se familiariser avec les instructions de la librairie LCD.
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
- Utilise un afficheur LCD alphanumérique en mode 4 bits
Ressources utiles associées à ce programme :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
- La librairie LiquidCrystal pour afficheur LCD alphanumérique
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.

2.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,

- des straps,

- un afficheur LCD alpha-numérique (préparé pour une utilisation simplifiée en mode 4 bits avec la carte Arduino)

3. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
- Connexion du LCD sur les broches de la carte Arduino :
- Connecter broche RS du LCD sur la broche 2
- Connecter broche E du LCD sur la broche 3
- Connecter broche D4 du LCD sur la broche 4
- Connecter broche D5 du LCD sur la broche 5
- Connecter broche D6 du LCD sur la broche 6
- Connecter broche D7 du LCD sur la broche 7
4. Le schéma théorique du montage
Le schéma théorique du montage (cliquer pour agrandir)
5. Le circuit du montage
Le schéma du montage à réaliser (cliquer pour agrandir)
6. Fonctionnement du programme
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme
7. Explication du programme
7.1 Au niveau de la partie déclarative :
7.2 Au niveau de la fonction d’initialisation setup( ) :
7.3 Au niveau de la boucle principale, la fonction loop ( ) :
8. Mise en oeuvre du programme
8.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
8.2 Préparation du Terminal côté PC dans le logiciel Arduino
- Côté PC, il faut ouvrir la fenêtre terminal de l’IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».

- La fenêtre « Terminal » s’ouvre alors :

- Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :

Point important, il faut également activer l’option « newline » qui active l’envoi du caractère ‘\n’ (ascii 10) lorsque l’on saisi quelque chose dans le champ du Terminal suivi d’un <send>

8.3 Fonctionnement
9. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur Arduino
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr
// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 8/2/2011.
// ——- Licence du code de ce programme —–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// //////////////////// PRESENTATION DU PROGRAMME ////////////////////
// ——– Que fait ce programme ? ———
/* Ce programme permet de contrôler un afficheur LCD alpha-numérique
depuis le Terminal série du logiciel Arduino
à l’aide d’instructions simple (blink, noblink, clear, etc..).
Utilise l’objet String pour analyser la chaine recue via le port Série
*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise un afficheur LCD alphanumérique en mode 4 bits
// ——– Circuit à réaliser ———
// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
// Connexion du LCD sur les broches de la carte Arduino :
// Connecter broche RS du LCD sur la broche 2
// Connecter broche E du LCD sur la broche 3
// Connecter broche D4 du LCD sur la broche 4
// Connecter broche D5 du LCD sur la broche 5
// Connecter broche D6 du LCD sur la broche 6
// Connecter broche D7 du LCD sur la broche 7
// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…
// — Déclaration des constantes —
// — Inclusion des librairies —
#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD
// — Déclaration des constantes utiles —
// — Déclaration des constantes des broches E/S numériques —
const int RS=2; // Constante pour la broche 2
const int E=3; // Constante pour la broche 3
const int D4=4; // Constante pour la broche 4
const int D5=5; // Constante pour la broche 5
const int D6=6; // Constante pour la broche 6
const int D7=7; // Constante pour la broche 7
// — Déclaration des constantes des broches analogiques —
// — Déclaration des variables globales —
int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre reçu sur le port Série
String chaineReception=« »; // déclare un objet String vide pour reception chaine
String chaineTest=« »; // déclare un objet String pour analyse chaine réception
int valeur1=0, valeur2=0; // variables int pour analyse chaine réception
int ligne, colonne; // variables de positionnement sur le LCD avec 1er caractère à ligne=0 et colonne=0
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//———— Création d’un objet afficheur LCD alphanumérique —-
LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en mode 4 bits
// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter 1 seule fois au démarrage du programme —
// ——- Initialisation fonctionnalités utilisées ——-
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// Initialisation de l’afficheur LCD
lcd.begin(20,4); // Initialise le LCD avec 20 colonnes x 4 lignes
delay(10); // pause rapide pour laisser temps initialisation
// Test de l’afficheur LCD
lcd.clear(); // efface LCD
lcd.print(« LCD OK »); // affiche texte
delay (1000); //pause
lcd.clear(); // efface LCD
// ——- Broches en sorties numériques ——-
// ——- Broches en entrées numériques ——-
// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-
// ——- Initialisation des variables utilisées ——-
//———– Affichage des instructions dispo dans le Terminal Série ———–
Serial.println(« *** Instructions disponibles pour controle du LCD *** »);
Serial.println(« blink() : active curseur clignotant »);
Serial.println(« noBlink() : inactive curseur clignotant »);
Serial.println(« cursor() : active trait sous curseur »);
Serial.println(« noCursor() : inactive trait sous curseur »);
Serial.println(« clear() : efface ecran et revient en 0,0 »);
Serial.println(« home() : revient en 0,0 sans effacer ecran »);
Serial.println(« display() : active ecran »);
Serial.println(« noDisplay() : inactive ecran »);
Serial.println(« scrollDisplayLeft() : decale ecran et curseur vers gauche »);
Serial.println(« scrollDisplayRight() : decale ecran et curseur vers droite »);
Serial.println(« setCursor (colonne,ligne) : positionne curseur en colonne,ligne »);
Serial.println(« print(\ »chaine\ ») : affiche chaine a la position actuelle »);
} // fin de la fonction setup()
// ********************************************************************************
////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
// — ici instructions à exécuter par le programme principal —
//—- Réception chaine sur le port série —
while (Serial.available()>0) { // tant qu’un octet en réception
octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable
if (octetReception==10) { // si Octet reçu est le saut de ligne – activer Newline dans le Terminal
Serial.println (« Chaine recue= »+chaineReception); // affiche la chaine recue
//chaineReception= » »; //RAZ le String de réception
break; // sort de la boucle while
}
else { // si le caractère reçu n’est pas un saut de ligne
chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
}
} // fin tant que octet réception
//—– une fois que le saut de ligne est reçu, on sort du While et on se positionne ici
// —- analyse de la chaine recue sur le port Série —-
chaineReception=chaineReception.trim(); // enlève les espaces
if (chaineReception==« blink() ») lcd.blink(); // blink
if (chaineReception==« noBlink() ») lcd.noBlink(); // noblink
if (chaineReception==« cursor() ») lcd.cursor(); // cursor
if (chaineReception==« noCursor() ») lcd.noCursor(); // noCursor
if (chaineReception==« clear() ») lcd.clear(); // clear
if (chaineReception==« home() ») lcd.home(); // home
if (chaineReception==« display() ») lcd.display(); // display
if (chaineReception==« noDisplay() ») lcd.noDisplay(); // noDisplay
if (chaineReception==« scrollDisplayLeft() ») lcd.scrollDisplayLeft(); // scrollDisplayLeft()
if (chaineReception==« scrollDisplayRight() ») lcd.scrollDisplayRight(); // scrollDisplayRight()
if (chaineReception.substring(0,10)==« setCursor(« ) { // si reçoit l’instruction setCursor
// nb substring : dernier caractere exclu
Serial.print(« setCursor(« ); // affiche sur LCD
//————- extraction colonne – ligne —— 2 chiffres
if (chaineReception.substring(11,12)==« , ») { // si la virgule en position 11 – càd 1 chiffre
//—- extraction nombre colonnes – cas 1 seul chiffre
valeur1=chaineReception.charAt(10); // extrait valeur ASCII du caractere
valeur1=valeur1–48; // extrait valeur numérique du caractere
colonne=constrain(valeur1,0,19);//oblige valeur colonne
Serial.print(colonne); // affiche sur LCD
Serial.print(« , »); // affiche sur LCD
//—- extraction nombre lignes — 1 seul chiffre
valeur1=chaineReception.charAt(12); // extrait valeur ASCII du caractere
valeur1=valeur1–48; // extrait valeur numérique du caractere
ligne=constrain(valeur1,0,3);// oblige valeur ligne
Serial.print(ligne); // affiche sur LCD
Serial.print(« ) »); // affiche sur LCD
//———- si dernier caractere est bien une ) on positionne curseur
if (chaineReception.substring(13,14)==« ) ») lcd.setCursor(colonne,ligne);
} // fin si 1 chiffre colonne
//————- extraction colonne – ligne —— 2 chiffres
if (chaineReception.substring(12,13)==« , ») { // si la virgule en position 12 – càd 2 chiffres
valeur1=chaineReception.charAt(10); // extrait valeur ASCII du caractere
valeur1=valeur1–48; // extrait valeur numérique du caractere
valeur2=chaineReception.charAt(11); // extrait valeur ASCII du caractere
valeur2=valeur2–48; // extrait valeur numérique du caractere
colonne=(valeur1*10)+valeur2;
Serial.print(colonne); // affiche sur LCD
Serial.print(« , »); // affiche sur LCD
//—- extraction nombre lignes — 1 seul chiffre
valeur1=chaineReception.charAt(13); // extrait valeur ASCII du caractere
valeur1=valeur1–48; // extrait valeur numérique du caractere
ligne=valeur1;
Serial.print(ligne); // affiche sur LCD
Serial.print(« ) »); // affiche sur LCD
//———- si dernier caractere est bien une ) on positionne curseur
if (chaineReception.substring(14,15)==« ) ») lcd.setCursor(colonne,ligne);
} // fin si 2 chiffres colonne
} // fin si setCursor
if (chaineReception.substring(0,7)==« print(\ »« ) { // si reçoit l’instruction print(« chaine »)
// nb substring : dernier caractere exclu
valeur1=chaineReception.length(); // mémorise longueur de la chaine
valeur1=valeur1–7–2; // longueur de la chaine texte entre « »
chaineTest=chaineReception.substring(7,7+valeur1); // extrait la chaine texte
Serial.println(chaineTest);
//—- si la chaine est bien suivie du « )
if (chaineReception.substring(7+valeur1,7+valeur1+2)==« \ ») ») lcd.print(chaineTest);
} // fin si reçoit l’instruction print(« chaine »)
chaineReception=« »; // RAZ String de reception
delay(100); // pause
//while(1); // stop loop
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////
// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////
// ////////////////////////// Fin du programme ////////////////////
Articles Liés
- Saisir une valeur entière au clavier matriciel et l'afficher sur l'afficheur LCD 4x20
L'utilisation d'un clavier matriciel et d'un afficheur LCD 4x20 est une méthode pratique pour saisir…
- EXPERT : ARDUINO : LCD Graphique
Arduino est une plateforme de prototypage électronique open source qui permet aux utilisateurs de créer…
- ARDUINO : EXPERT : LCD
Arduino est une plateforme de prototypage électronique open source qui permet aux utilisateurs de créer…