Ecran LCD - Arduino

Introduction

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.

Sommaire masquer

1 Introduction

1.1 Peut-on utiliser l'écran LCD pour des projets en extérieur ?

1.2 Comment reproduire nos circuits sur Fritzing ?

2 La librairie Liquid Crystal

2.1 a) Installation

2.2 b) Les fonctions de la Librairie

3 Afficher du texte à l'écran

4 Mini station solaire

5 Faire des caractères personnalisés

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 :

Vss : Connecter à la masse
Vdd : Connecter au +5V
VEE ou VO : Connecter à un potentiomètre pour ajuster le contraste
Rs : Contrôler le registre de mémoire
R/W : Sélectionner écriture ou lecture
E : Lorsqu’elle est à l’état bas, provoque l’exécution des instructions par le module LCD.
D0-D7：Lire et Ecrire des données
A and K: Contrôler le rétro-éclairage

Peut-on utiliser l'écran LCD pour des projets en extérieur ?

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

Comment reproduire nos circuits sur Fritzing ?

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.

La librairie Liquid Crystal

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.

a) Installation

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.

b) Les fonctions de la Librairie

La librairie Liquid Crystal est composée de plusieurs fonctions pour vous faciliter l’utilisation de celle-ci.

LiquidCrystal () : Permet d’initialiser les broches associé à l’écran LCD.
begin(colonne,ligne) : Initialise l’écran LCD avec les dimension de l’écran
clear() : Efface l’écran et fait revenir le curseur en haut à gauche.
home() : Fait revenir le curseur en haut à gauche sans effacer l’écran
setCursor(colonne, ligne) : Positionne le curseur sur l’écran.
write() : Ecrit un caractère sur l’écran.
Print() : Ecrit une chaîne de caractère sur l’écran
createChar() : Permet de créer son propre caractère. On verra un exemple à la fin de ce cours.

Afficher du texte à l'écran

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 :

Mini station solaire

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 :

Faire des caractères personnalisés

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 :

byte Division [] = { B00000, B00000…}.

La troisième ligne possède un pixel noirci : B00100.

Une fois que l’on a compris comment cela fonctionne on peut faire le logo en entier :

byte Division [] = { B00000, B00000,B00100,B00000,B11111,B00000,B00100;B00000,B00000,B00000,B00000}.

Voici une liste de différente caractère que vous ne trouverez pas dans les caractères ASCII :

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 :