Un des éléments permettant d’afficher des informations les plus utilisés sur Arduino est l’écran à cristaux liquide LCD 16×2.
Les cristaux liquides permettent la création d’écran plat à faible consommation électrique. Ils utilisent la polarisation de la lumière par des filtres polarisants. Les cristaux n’émettent donc pas de lumière, seul leurs transparences varie ils doit donc disposer d’un éclairage.
L’afficheur dispose d’un rétro-éclairage LED et peut afficher deux lignes de 16 caractères. Chaque caractère est un rectangle de pixel. Il est possible de contrôler chaque pixel de chaque rectangle pour créer des caractères spécifiques.
L’écran s’appelle 16×2 parce qu’il possède 16 colonnes et 2 lignes. Il y a beaucoup d’autres combinaisons d’écran possible comme 8×1,10×2, 16×1, mais le 16×2 est le plus connus.
Avec un écran 16×2, on va donc avoir 32 caractères. Un caractère est composé de 5×8 =40 pixels. Ce nombre de pixels est nécessaire pour distinguer les différents caractères les uns des autres.
D’abord disponible en noir et blanc et de petite taille, il est utilisé dans les calculatrices, les multimètres, les montres du fait de sa faible consommation électrique.
Il permet actuellement d’afficher en couleurs et est utilisé dans plein d’application électronique.
Vous pouvez l’utiliser dans plein de projet, notamment pour afficher la valeur d’un capteur de température, l’heure, ou petit écran pour une imprimante 3d.
On va voir les différentes broches de l’écran LCD :
Beaucoup de projet en extérieur nécessite un affichage, comme une mini station météo ou relever des informations de capteur. L’écran LCD est donc utilisable s’il est protéger de la pluie. On vous conseille donc de le mettre en hauteur avec une protection, comme une vitre par exemple ou dans une boite fermée.
En ce qui concerne la température que l’écran support, voici un tableau des températures que supporte l’écran en fonctionnement :
Température Haute | 70°C |
---|---|
Température Basse | -20°C |
Humidité | 90 % à 40°C |
Dans nos circuits Fritzing, on utilise le composant écran LCD 16×2 qui n’est pas disponible directement. Voici le composant si vous voulez l’ajouter : écran LCD.
Si vous ne savez pas comment ajouter le composant, on vous conseille notre cours dessus.
Pour utiliser l’écran LCD, vous avez besoin d’une librairie : LiquidCrystal.zip. Il y a un ensemble de fonction dedans qui vont simplifier votre code et l’utilisation de l’écran 16×2.
Pour pouvoir l’installer, il vous faut ouvrir Arduino IDE et cliquer sur sketch puis include librairie et add .ZIP Library comme ci-dessous :
Vous pouvez aussi l’installer depuis le manageur de librairie en cliquant sur Manage Librairies plutôt que Add .ZIP Library puis en tapant Liquid Crystal.
Si vous avez du mal à l’installer, vous pouvez regarder notre cours sur les librairies.
La librairie Liquid Crystal est composée de plusieurs fonctions pour vous faciliter l’utilisation de celle-ci.
On va maintenant voir comment afficher du texte sur l’écran 16×2. Cela peut vous être super utile pour afficher des informations comme l’heure, la réponse d’un capteur. Le circuit est un peu complexe à réaliser… Néanmoins pour compenser le code est très simple et compréhensible grâce à la librairie.
Pour simplifier le circuit si vous le souhaiter, vous pouvez enlever le potentiomètre du circuit et remplacer le fils jaune sur le schéma par un fils allant vers le 5V. Vous ne pourrez alors plus régler la luminosité de l’écran, elle sera à son maximum, mais vous aurez moins de composant et de fils.
Voici le programme associé au projet :
#include <LiquidCrystal.h> // La librairie pour l'écran
// On initialise avec l'écran avec les pins pour lequel on l'a branché
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
void setup() {
// On définit le nombre de ligne et colonne de l'écran.
lcd.begin(16, 2);
// On affiche le message
lcd.print("Arduino Factory");
}
void loop() {
// On met le curseur à la colonne 0 ligne 1
lcd.setCursor(0, 1);
}
Voici le résultat que l’on obtient :
On va maintenant voir comment faire une mini station solaire. Concrètement, on va indiqué la luminosité enregistrée par la photorésistance et écrire cette valeur sur l’écran LCD.
Voici le programme à téléverser :
#include <LiquidCrystal.h> // La librairie pour l'écran
int valeur_photoresistance;
// On initialise avec l'écran avec les pins pour lequel on l'a branché
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
void setup() {
// On définit le nombre de ligne et colonne de l'écran.
lcd.begin(16, 2);
// On affiche le message
}
void loop() {
// On met le curseur à la colonne 0 ligne 1
lcd.setCursor(0, 0);
lcd.print("Voici la valeur:");
valeur_photoresistance = analogRead(A0);
lcd.setCursor(0, 1);
lcd.print(valeur_photoresistance);
}
Voici le résultat :
Il se peut que vous vouliez afficher des caractères sur l’écran qui ne sont pas disponible avec les caractères ASCII standard. Il va donc falloir les reproduire vous même en hexadécimal. Pour cela il y a une fonction dans la librairie appelée creatChar(). Comme on l’a dit toute à l’heure, les écrans 16X2 peuvent écrire des caractères sur des carrés de 5×8 =40 pixels.
On va donc devoir placer notre nombre hexadécimal sous forme de 1 et de 0, avec 1 correspondant à un pixel noircie et 0 un blanc. On va donc avoir une liste de 8 nombres hexadécimaux de 5 chiffres correspondant aux 8 lignes et 5 colonnes d’un caractère.
On va maintenant prendre l’exemple du logo diviser pour mieux comprendre comment faire notre liste en hexadécimal. Comme on voit ici la deux colonne ne contiennent pas de point noirci, on aura donc :
Code en Héxadécimal | Schéma |
---|---|
byte Coeur [] = { B00000, B01010, B11111, B11111, B01110, B00100, B00000, B00000 }; | |
byte Cloche [] = { B00100, B01110, B01110, B01110, B11111, B00000, B00100, B00000 }; | |
byte Check [] = { B00000, B00001, B00011, B10110, B11100, B01000, B00000, B00000 }; | |
byte Haut-parleur [] = { B00001, B00011, B01111, B01111, B01111, B00011, B00001, B00000 }; | |
byte locket [] = { B01110, B10001, B10001, B11111, B11011, B11011, B11111, B00000 }; |
On va maintenant voir le programme pour implémenter vos créations. Le circuit est le même que le premier de la page, celui pour afficher du texte à l’écran. Seul le programme change :
#include <LiquidCrystal.h> // La librairie pour l'écran
// On initialise avec l'écran avec les pins pour lequel on l'a branché
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
// Créez des caractères personnalisés:
byte Coeur [] = {B00000,B01010,B11111,B11111,B01110,B00100,B00000,B00000};
byte Cloche [] = {B00100,B01110,B01110,B01110,B11111,B00000,B00100,B00000};
byte Check [] = {B00000,B00001,B00011,B10110,B11100,B01000,B00000,B00000};
byte Haut_parleur [] = {B00001,B00011,B01111,B01111,B01111,B00011,B00001,B00000};
byte locket [] = {B01110,B10001,B10001,B11111,B11011,B11011,B11111,B00000};
void setup() {
// On définit le nombre de ligne et colonne de l'écran.
lcd.begin(16, 2);
// On affiche le message
// Créer un nouveau caractère:
lcd. createChar ( 0, Coeur ) ; // On copie le caractère dans la mémoire de l'écran
lcd. createChar ( 1, Cloche ) ;
lcd. createChar ( 2, Check ) ;
lcd. createChar ( 3, Haut_parleur ) ;
lcd. createChar ( 4, locket ) ;
}
void loop() {
// On met le curseur à la colonne 0 ligne 1
// Imprimer tous les caractères personnalisés:
lcd. setCursor ( 0, 0 ) ; // On place le curseur ou veut le caractère
lcd.write(byte(0)); // On affiche le caractère.
lcd. setCursor ( 2, 0 ) ;
lcd.write(byte(1));
lcd. setCursor ( 4, 0 ) ;
lcd.write(byte(2));
lcd. setCursor ( 6, 0 ) ;
lcd.write(byte(3));
lcd. setCursor ( 8, 0 ) ;
lcd.write(byte(4));
}
Voici le résultat sur l’écran :