Comment connecter un écran LCD 16 × 2 I2C avec Arduino

L’un des défis de l’utilisation des écrans LCD est qu’ils nécessitent de nombreuses broches d’E/S du microcontrôleur, ce qui limite sa fonctionnalité. Normalement, l’écran LCD utilise 6 des 13 broches d’E/S numériques disponibles, il ne reste alors que 7 broches pour interfacer d’autres composants.

Ce problème est résolu en utilisant le module I2C qui nous empêchera d’utiliser les broches d’E/S numériques de l’Arduino.

Un module basé sur le circuit intégré PCF8574.

Le module basé sur le circuit intégré PCF8574 nous permet d’étendre les broches d’E/S de l’Arduino via l’interface I2C.

.

.

Vous pouvez configurer 8 broches d’E/S bidirectionnelles en utilisant seulement deux lignes de l’interface I2C, à savoir la ligne de données série (SDA) et la ligne d’horloge série (SCL).

Le moule basé sur le circuit intégré PCF8574 est fixé à l’arrière de l’écran LCD comme indiqué ci-dessous.

Ecran LCD avec un module i2c

Connexion de l’écran LCD I2C à Arduino

Nous connectons les broches i2c du module comme indiqué dans le schéma ci-dessous. VCC du module i2c à la broche 5V et connecter le GND aussi. La broche SDA du module i2c est connectée à Arduino A4 et la broche SCL à A5.

Avant d’écrire le code pour afficher le contenu sur le LCD, nous devons connaître l’adresse du périphérique I2C relié au LCD. Ceci est fait en utilisant le code I2C Scanner montré ci-dessous. Ce code nécessite la bibliothèque Wire.h. Les puces PCF8574 sont réglées sur des adresses hexadécimales de 0x20 à 0x27.

Code du scanner I2C

// i2c_scanner
#include <Wire.h>
void setup()
{
  Wire.begin();
  Serial.begin(9600);
  while (!Serial);             
  Serial.println("nI2C Scanner");
}
void loop()
{
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for(address = 1; address < 127; address++ ) 
  {
    // Le scanner i2c_scanner utilise la valeur de retour de
    // de Write.endTransmisstion pour voir si
    // un périphérique a accusé réception à l'adresse.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0)
    {
      Serial.print("Dispositif I2C trouvé à l'adresse 0x");
      if (address<16) 
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
      nDevices++;
    }
    else if (error==4) 
    {
      Serial.print("Erreur inconnue à l'adresse 0x");
      if (address<16) 
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("Aucun dispositif I2C trouvé");
  else
    Serial.println("donen");
  delay(5000);           // attendre 5 secondes pour le prochain scan
}

Lorsque le code ci-dessus est téléchargé sur la carte Arduino, nous sommes en mesure de lire l’adresse de notre dispositif i2c à partir du moniteur série. Cette adresse est celle qui sera utilisée dans le code pour l’affichage LCD. Dans ce cas, l’adresse est 0x27.

i2c scanner display

Le code pour l’affichage des messages sur le LCD peut alors être écrit en utilisant l’adresse obtenue ci-dessus.

La bibliothèque LiquidCrystal_I2C.h est une bibliothèque importante qui doit être incluse dans l’IDE Arduino pour que le module i2c fonctionne correctement. Cette bibliothèque peut être téléchargée ici sous forme de dossier zip liquidCrystal_I2C.

Code pour afficher le message sur le LCD

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

// Déclaration des broches I2C
LiquidCrystal_I2C lcd(0x27,16,4); 

void setup() 
{
  lcd.init();       // initialiser le lcd
  lcd.backlight();  // Pour allumer le rétro-éclairage
}

void loop() 
{
  lcd.setCursor(0,0);   // Définir la position d'écriture à partir de la première ligne, première colonne.
  lcd.print("I2C LCD DISPLAY"); // Vous pouvez écrire 16 caractères par ligne.
  delay(1000);  //  Retard utilisé pour donner un effet dynamique.
  lcd.setCursor(2,1);  // Définir la position d'écriture à partir de la deuxième ligne, première colonne.
  lcd.print("AVEC ARDUINO");
  delay(5000); 
  lcd.clear();  // Effacer l'écran
  lcd.setCursor(0,0); 
  lcd.print("COURS ROBOTIQUE");
  delay(1000);
  lcd.setCursor(0,1);
  lcd.print("MJC DES VOIRONS");
  delay(5000);
  lcd.clear();  // Effacer l'écran
}

Après avoir compris comment interfacer le LCD i2c avec Arduino, vous pouvez utiliser ce LCD dans un certain nombre d’applications, en particulier lorsque vous devez utiliser un certain nombre d’autres composants qui peuvent limiter les broches d’E/S disponibles.

Personnellement, je préfère utiliser ce type de LCD dans la plupart de mes projets, comme vous pourrez le constater en consultant certains de ces articles :

  • 4×4 Keypad avec Arduino Système de sécurité basé sur des mots de passe.
  • Interfaçage de DS3231 RTC avec Arduino.
  • Système de contrôle d’accès par serrure de porte RFID avec Arduino.

Affichage de caractères personnalisés sur l’écran LCD

Cet écran LCD est basé sur le contrôleur Hitachi HD44780 qui contient deux types de mémoire :
CGROM : Il s’agit de la ROM du générateur de caractères qui est le type de mémoire utilisé pour stocker les polices de code ASCII permanentes. Ces polices sont celles que nous utilisons normalement pour afficher des messages sur le LCD.

CGRAM : C’est l’endroit où sont stockés les caractères définis par l’utilisateur. Cet espace mémoire peut être modifié et est limité à 64 octets. Cela signifie que pour un LCD basé sur 5×8, un maximum de huit caractères personnalisés peuvent être stockés dans le CGRAM.

Si vous regardez attentivement l’écran LCD, vous pouvez voir les petits rectangles qui forment les différents caractères de l’écran. Chaque rectangle est constitué d’une grille de 5×8 pixels Les caractères sont stockés sous forme de tableaux composés de 8 octets, 1 octet pour chaque ligne de la matrice de 5 x 8 leds.

Pour créer des caractères personnalisés, vous devez créer un tableau de 8 octets définissant le caractère que vous souhaitez. Ce tableau est composé de zéros et de uns où les zéros représentent un pixel éteint et les uns sont pour les pixels allumés. Un exemple est montré ci-dessous ;

La formation de tableaux de caractères personnalisés peut être assez difficile et je vous encourage donc à utiliser l’outil Générateur de caractères personnalisés LCD. Il vous aidera à créer les caractères rapidement et vous donnera même une esquisse du code que vous pourrez utiliser.

Fonctions de la bibliothèque LiquidCrystal.

Les principales fonctions à connaître lors de l’utilisation de caractères personnalisés sont :

createChar() : utilisée pour définir un caractère personnalisé
write() : pour afficher un caractère donné.
Le code ci-dessous est un exemple montrant la création d’un certain nombre de caractères personnalisés et comment les afficher sur un LCD i2c 16×2.

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

// Déclaration des broches I2C
LiquidCrystal_I2C lcd(0x27,16,4);

// Créez des personnages personnalisés
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};
byte Bell[] = {
  B00100,
  B01110,
  B01110,
  B01110,
  B11111,
  B00000,
  B00100,
  B00000
};
byte Alien[] = {
  B11111,
  B10101,
  B11111,
  B11111,
  B01110,
  B01010,
  B11011,
  B00000
};
byte Check[] = {
  B00000,
  B00001,
  B00011,
  B10110,
  B11100,
  B01000,
  B00000,
  B00000
};
byte Speaker[] = {
  B00001,
  B00011,
  B01111,
  B01111,
  B01111,
  B00011,
  B00001,
  B00000
};
byte Sound[] = {
  B00001,
  B00011,
  B00101,
  B01001,
  B01001,
  B01011,
  B11011,
  B11000
};
byte Skull[] = {
  B00000,
  B01110,
  B10101,
  B11011,
  B01110,
  B01110,
  B00000,
  B00000
};
byte Lock[] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};
void setup() {
  lcd.init();       // initialiser le lcd
  lcd.backlight();
  //Créez des nouveaux caractéres
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);
  // Clear the LCD screen:
  lcd.clear();
  

}
void loop() { 
  // Imprime un message sur l'écran LCD :
  lcd.setCursor(0, 0);
  lcd.print("CARACTERES PERSO");
  delay(1000);
  lcd.noAutoscroll();
  // Print all the custom characters:
  lcd.setCursor(0, 1);
  lcd.write((byte)0);
  lcd.setCursor(2, 1);
  lcd.write((byte)1);
  lcd.setCursor(4, 1);
  lcd.write((byte)2);
  lcd.setCursor(6, 1);
  lcd.write((byte)3);
  lcd.setCursor(8, 1);
  lcd.write((byte)4);
  lcd.setCursor(10, 1);
  lcd.write((byte)5);
  lcd.setCursor(12, 1);
  lcd.write((byte)6);
  lcd.setCursor(14, 1);
  lcd.write((byte)7);
}

Lorsque ce code est téléchargé sur la carte Arduino, vous verrez les différents caractères sur l’écran LCD.

0 commentaires

Soumettre un commentaire