Comment utiliser Afficheur LCD avec Arduino

Description générale des Afficheur LCD

Un afficheur LCD (Liquid Crystal Display) est un type d’écran utilisé pour afficher des informations en utilisant des cristaux liquides pour contrôler la transparence des pixels. Les cristaux liquides sont des molécules organiques qui peuvent être alignées pour bloquer ou laisser passer la lumière. Les afficheurs LCD utilisent cette propriété pour afficher des images et des textes.

Principe du fonctionnement :

Un écran LCD utilise des cristaux liquides pour fonctionner. Ces cristaux sont disposés en une grille de pixels, chaque pixel étant formé par un groupe de cristaux liquides. Lorsqu’aucun courant électrique n’est appliqué, les molécules des cristaux liquides sont orientées dans une direction particulière, mais lorsqu’un courant électrique est appliqué, les molécules se tournent dans une autre direction, permettant ainsi de bloquer ou de laisser passer la lumière pour afficher des informations

Les types des afficheurs LCD :

Il existe plusieurs types d’afficheurs LCD compatibles avec Arduino, par exemple

• Afficheur LCD alphanumérique
• Afficheur LCD graphique

Liste des broches du LCD et leur rôle :

Il faut noter que les écrans LCD graphiques, d’autre part, utilisent généralement des broches supplémentaires pour transmettre des données graphiques, comme des informations de coordonnées pour dessiner des images et des graphiques sur l’écran. Ces écrans peuvent généralement afficher des images et des graphiques en plus des caractères et des symboles prédéfinis.

Les broches supplémentaires pour les écrans LCD graphiques peuvent inclure:

• CS: Chip Select, qui permet de sélectionner le composant à utiliser
• RST : reset, sert à réinitialiser l’écran
• D/C : Data/Command select, pour sélectionner si les données envoyées sont des commandes ou des informations à afficher
• SDA : Serial Data, il transmettre les données en série
• SCL : Serial Clock, il synchronise la transmission de données en série

Afficheur LCD alphanumérique :

Les afficheurs LCD alphanumériques sont des afficheurs LCD qui sont capables d’afficher des caractères et des chiffres. Ils sont souvent utilisés pour afficher des messages de texte ou des valeurs numériques. Les afficheurs alphanumériques peuvent avoir un ou plusieurs lignes et peuvent être utilisés pour créer des projets tels que des horloges, des compteurs et des indicateurs de température.

Ils sont généralement construits avec un certain nombre de colonnes et de lignes de caractères. Les colonnes sont généralement utilisées pour afficher les caractères alphanumériques, tandis que les lignes sont utilisées pour afficher des lignes de texte. Les afficheurs alphanumériques peuvent avoir un seul caractère par colonne, ou plusieurs caractères par colonne, en fonction de la taille de l’afficheur.

Les types des afficheurs LCD alphanumériques

Il y a différentes sortes d’afficheurs LCD alphanumériques, tels que les afficheurs LCD 16×2 et 20×4. Ces derniers peuvent être de couleur bleue ou verte et peuvent être dotés d’un module I2C ou présentés sous forme de Shield.

Afficheur LCD 16×2

Un afficheur LCD 16×2 est un type d’afficheur LCD alphanumérique qui possède 16 colonnes et 2 lignes de caractères. Il est capable d’afficher 32 caractères au total, ce qui en fait un choix populaire pour les projets qui nécessitent un affichage de données de base mais pas trop complexe.

Ils ont généralement des dimensions standard, ils peuvent être connectés à une carte de développement comme l’Arduino à l’aide de pin de commande et de données. Il existe des bibliothèques de logiciels pour Arduino qui prennent en charge les afficheurs LCD 16×2, permettant de faciliter l’affichage de caractères et de chaînes de caractères sur l’afficheur.

Afficheur LCD 20×4

Un afficheur LCD 20×4 est un écran à cristaux liquides (LCD) qui peut afficher des caractères sur 20 colonnes et 4 lignes. Il est souvent utilisé pour afficher des informations comme des messages, des menus, des données de capteurs et des paramètres de réglage dans des applications électroniques

Utilisation des afficheur LCD I2C avec Arduino

L’utilisation d’un afficheur LCD I2C est un moyen simple et efficace à vos projets. Les afficheurs LCD I2C utilisent une interface I2C pour communiquer avec le microcontrôleur avec Arduino, ce qui permet de réduire le nombre de broches nécessaires pour la communication.

Matériel

• Un afficheur LCD I2C
• Arduino
• Des fils
• Cable USB

Branchement

Code

Pour l’afficheur LCD 16×2 I2C

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Initialise l'afficheur LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.begin(); // Démarre l'afficheur
  lcd.backlight(); // Allume le rétro-éclairage
  lcd.print("Hello, World!"); // Affiche "Hello, World!" sur le premier ligne
}

void loop() {
  // Rien à faire ici
}

Il est important de noter que vous devrez peut-être installer la bibliothèque LiquidCrystal_I2C via l’IDE Arduino avant de pouvoir utiliser ce code.

Explication du code

Ce code utilise l’Arduino pour contrôler un afficheur LCD 16×2 I2C. Il comprend les étapes suivantes:

1. Les lignes #include <Wire.h> et #include <LiquidCrystal_I2C.h> incluent les bibliothèques nécessaires pour utiliser l’afficheur LCD I2C avec Arduino. La bibliothèque Wire.h est utilisée pour la communication I2C, et la bibliothèque LiquidCrystal_I2C.h fournit des fonctions pour contrôler l’afficheur LCD.
2. La ligne “LiquidCrystal_I2C lcd(0x27, 16, 2);” crée un objet pour l’afficheur LCD. L’adresse I2C par défaut de l’afficheur est 0x27, mais cela peut varier selon le modèle. Les arguments 16 et 2 indiquent respectivement le nombre de colonnes et de lignes de l’afficheur.
3. La fonction setup() est exécutée une seule fois au démarrage de l’Arduino. Elle contient les commandes pour initialiser l’afficheur LCD. La fonction lcd.begin() démarre l’afficheur, tandis que lcd.backlight() allume le rétro-éclairage. La fonction lcd.print(“Hello, World!”) affiche le texte “Hello, World!” sur la première ligne de l’afficheur.
4. La fonction loop() est exécutée en boucle après l’initialisation. Dans ce cas, elle ne contient aucune commande, donc il n’y a rien à faire ici.

Pour l’afficheur LCD 20×4 I2C

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Initialise l'afficheur LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup() {
  lcd.begin(); // Démarre l'afficheur
  lcd.backlight(); // Allume le rétro-éclairage
  lcd.print("Hello, World!"); // Affiche "Hello, World!" sur le premier ligne
  lcd.setCursor(0, 1); // définit le curseur sur la deuxième ligne
  lcd.print("I am an Arduino"); // Affiche "I am an Arduino" sur la deuxième ligne
}

void loop() {
  // Rien à faire ici
}

le code initialise l’afficheur LCD 24×4 I2C en utilisant les bibliothèques nécessaires, allume le rétro-éclairage, affiche “Hello, World!” sur la première ligne, puis déplace le curseur sur la deuxième ligne pour afficher “I am an Arduino” .

Liens outilles

Si vous souhaitez de télécharger la bibliothèque : https://github.com/johnrickman/LiquidCrystal_I2C

Pour l’achat du matériels nécessaire :

Arduino Uno :

https://www.moussasoft.com/produit/arduino-uno-r3-usb-cable

Afficheur LCD 16×2 I2C :

https://www.moussasoft.com/produit/afficheur-lcd-1602-avec-i2c

Afficheur LCD 20×4 I2C :

https://www.moussasoft.com/produit/afficheur-lcd-20×4-ecran-vert-avec-i2c

https://www.moussasoft.com/produit/afficheur-lcd-20×4-ecran-bleu-avec-i2c