Afficher du texte sur un écran LCD

Article
06/08/2023

Les écrans caractères LCD sont utiles pour afficher des informations sans avoir besoin d’un moniteur externe. Les écrans caractères LCD courants peuvent être connectés directement aux broches GPIO, mais une telle approche nécessite l’utilisation de jusqu’à 10 broches GPIO. Pour les scénarios qui nécessitent la connexion à une combinaison d’appareils, consacrer une telle quantité du brochage GPIO à un affichage de caractères est souvent impraticable.

De nombreux fabricants vendent des écrans caractères LCD 20x4 avec une extension GPIO intégrée. L’écran caractères se connecte directement à l’extension GPIO, qui se connecte ensuite au Raspberry Pi via le protocole série Inter-Integrated Circuit (I²C).

Dans cette rubrique, vous allez utiliser .NET pour afficher du texte sur un écran caractères LCD en utilisant une extension GPIO I²C.

Prérequis

Ordinateur à carte unique (SBC) ARM (ARM v7 ou version ultérieure)
Écran caractères LCD 20x4 avec interface I²C
Câbles de liaison
Plaque d’essai (facultative/recommandée)
Carte d’évaluation GPIO Raspberry Pi (facultative/recommandée)
Kit de développement logiciel (SDK) .NET version 7 ou ultérieure

Notes

Ce tutoriel est écrit pour un appareil cible Raspberry Pi. Il peut toutefois être utilisé pour n’importe quel ordinateur SBC Linux qui prend en charge .NET, comme Orange Pi ou ODROID.

Notes

Il existe de nombreux fabricants d’écrans caractères LCD. La plupart des conceptions sont identiques, et les fonctionnalités ne doivent normalement pas différer selon le fabricant. Pour référence, ce tutoriel a été développé avec le SunFounder LCD2004.

Préparation de l’ordinateur SBC

Vérifiez que votre ordinateur SBC est configuré pour prendre en charge les services suivants :

Pour de nombreux appareils, aucune configuration supplémentaire n’est requise. Dans le cas de Raspberry Pi, utilisez la commande raspi-config. Pour plus d’informations sur raspi-config, reportez-vous à la documentation sur Raspberry Pi.

Préparer le matériel

Utilisez des câbles de jumper pour connecter les quatre broches de l’extension GPIO I²C au Raspberry Pi comme suit :

GND à la terre
VCC à 5V
SDA à SDA (GPIO 2)
SCL à SCL (GPIO 3)

Si nécessaire, reportez-vous aux figures suivantes :

Interface I²C (arrière de l’écran)	Raspberry Pi GPIO
	Image avec la permission de Raspberry Pi Foundation.

Conseil

Un circuit imprimé GPIO conjointement avec un tableau de navigation est recommandé pour simplifier les connexions à la tête du GPIO.

Créer l’application

Effectuez les étapes suivantes dans votre environnement de développement préféré :

Créez une application console .NET à l’aide de l’interface CLI .NET ou de Visual Studio. Nommez-le LcdTutorial.
```
dotnet new console -o LcdTutorial
cd LcdTutorial
```
Ajoutez le package Iot.Device.Bindings au projet. Utilisez l’interface CLI .NET du répertoire du projet ou Visual Studio.
```
dotnet add package Iot.Device.Bindings --version 2.2.0-*
```
Remplacez le contenu du fichier Program.cs par le code suivant :
```
using System;
using System.Device.Gpio;
using System.Device.I2c;
using System.Threading;
using Iot.Device.CharacterLcd;
using Iot.Device.Pcx857x;

Console.WriteLine("Displaying current time. Press Ctrl+C to end.");

using I2cDevice i2c = I2cDevice.Create(new I2cConnectionSettings(1, 0x27));
using var driver = new Pcf8574(i2c);
using var lcd = new Lcd2004(registerSelectPin: 0, 
                        enablePin: 2, 
                        dataPins: new int[] { 4, 5, 6, 7 }, 
                        backlightPin: 3, 
                        backlightBrightness: 0.1f, 
                        readWritePin: 1, 
                        controller: new GpioController(PinNumberingScheme.Logical, driver));
int currentLine = 0;

while (true)
{
    lcd.Clear();
    lcd.SetCursorPosition(0,currentLine);
    lcd.Write(DateTime.Now.ToShortTimeString());
    currentLine = (currentLine == 3) ? 0 : currentLine + 1; 
    Thread.Sleep(1000);
}
```
Dans le code précédent :
- Une déclaration using crée une instance de I2cDevice en appelant I2cDevice.Create et en passant en entrée un nouveau I2cConnectionSettings avec les paramètres busId et deviceAddress. Ce I2cDevice représente le bus I²C. La déclaration using garantit que l’objet est supprimé et que les ressources matérielles sont correctement libérées.
  
  Avertissement
  
  L’adresse de l’appareil pour l’extension GPIO dépend de la puce utilisée par le fabricant. Les extensions GPIO équipées d’un PCF8574 utilisent l’adresse 0x27, tandis que celles qui sont équipées de puces PCF8574A utilisent 0x3F. Consultez la documentation de votre LCD.
- Une autre déclaration using crée une instance de Pcf8574 et passe le I2cDevice dans le constructeur. Cette instance représente l’extension GPIO.
- Une autre déclaration using crée une instance de Lcd2004 pour représenter l’écran. Plusieurs paramètres sont passés au constructeur décrivant les paramètres à utiliser pour communiquer avec l’extension GPIO. L’extension GPIO est passée en tant que paramètre controller.
- Une boucle while s’exécute indéfiniment. Chaque itération :
  1. Efface l’écran.
  2. Définit la position du curseur sur la première position sur la ligne active.
  3. Écrit l’heure actuelle sur l’écran à la position actuelle du curseur.
  4. Itère le compteur de ligne actif.
  5. Mise en veille pendant 1 000 ms.
Générez l'application. Si vous utilisez l’interface CLI .NET, exécutez dotnet build. Pour générer dans Visual Studio, appuyez sur Ctrl+Maj+B.
Déployez l’application en tant qu’application autonome sur l’ordinateur SBC. Pour obtenir des instructions, consultez Déployer des applications .NET sur Raspberry Pi. Veillez à accorder à l’exécutable l’autorisation exécuter à l’aide de chmod +x.
Exécutez l’application sur le Raspberry Pi en basculant vers le répertoire de déploiement et en exécutant l’exécutable.
```
./LcdTutorial
```
Observez l’écran caractères LCD à mesure que l’heure actuelle s’affiche sur chaque ligne.

Conseil

Si l’écran est allumé mais que vous ne voyez aucun texte, essayez en ajustant le bouton de contraste à l’arrière de l’écran.
Terminez le programme en appuyant sur Ctrl+C.

Félicitations ! Vous avez affiché du texte sur un écran LCD en utilisant un I²C et une extension GPIO !

Obtenir le code source

La source de ce tutoriel est disponible sur GitHub.

Étapes suivantes

Découvrir comment utiliser un GPIO (General Purpose Input/Output) pour faire clignoter une LED