Afficher du texte sur un écran LCD

2025-04-16

Les écrans de caractères LCD sont utiles pour afficher des informations sans avoir besoin d’un moniteur externe. Les écrans de 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 nécessitant la connexion à une combinaison d'appareils, consacrer une grande partie de l'en-tête GPIO à un affichage de caractères est souvent peu pratique.

De nombreux fabricants vendent des écrans à caractère LCD 20x4 avec un expandeur GPIO intégré. L’affichage des caractères se connecte directement au expandeur 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 affichage de caractères LCD à l’aide d’un expandeur GPIO I²C.

Conditions préalables

Ordinateur monocarte (SBC) basé sur ARM (ARMv7 ou supérieur)
É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)
SDK .NET 8 ou version ultérieure

Remarque

Ce tutoriel est écrit en supposant que l’appareil cible est Raspberry Pi. Toutefois, ce tutoriel peut être utilisé pour n’importe quel SBC linux qui prend en charge .NET, comme Orange Pi, ODROID, etc.

Remarque

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

Préparer le fichier SBC

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

Pour de nombreux appareils, aucune configuration supplémentaire n’est requise. Pour Raspberry Pi, utilisez la raspi-config commande. Pour plus d’informations sur raspi-config, reportez-vous à la documentation 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)

Reportez-vous aux illustrations suivantes en fonction des besoins :

Interface I²C (arrière-écran)	Raspberry Pi GPIO
	Image courtesy Raspberry Pi Foundation.

Conseil / Astuce

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 à partir du répertoire du projet ou de Visual Studio.
```
dotnet add package Iot.Device.Bindings --version 3.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. Cela I2cDevice représente le bus I²C. La using déclaration garantit que l’objet est supprimé et que les ressources matérielles sont correctement libérées.
  
  Avertissement
  
  L’adresse de l’appareil pour le expandeur GPIO dépend de la puce utilisée par le fabricant. Les expandeurs GPIO équipés d’un PCF8574 utilisent l’adresse 0x27, tandis que ceux qui utilisent des 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 le expandeur GPIO.
- Une autre using déclaration crée une instance de Lcd2004 pour représenter l'affichage. Plusieurs paramètres sont passés au constructeur décrivant les paramètres à utiliser pour communiquer avec le expandeur GPIO. L’extension GPIO est passée en tant que paramètre controller.
- Une while boucle s’exécute indéfiniment. Chaque itération :
  1. Efface l’affichage.
  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 sur le SBC en tant qu’application autonome. Pour obtenir des instructions, consultez Déployer des applications .NET sur Raspberry Pi. Veillez à accorder à l’exécutable l’autorisation d’exécution en utilisant chmod +x.
Exécutez l’application sur Raspberry Pi en basculant vers le répertoire de déploiement et en exécutant l’exécutable.
```
./LcdTutorial
```
Observez l’affichage des caractères LCD à mesure que l’heure actuelle s’affiche sur chaque ligne.

Conseil / Astuce

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

Félicitations! Vous avez affiché du texte sur un écran LCD à l’aide d’un I²C et d’un expandeur GPIO !

Obtenir le code source

La source de ce didacticiel est disponible sur GitHub.

Étapes suivantes

Apprenez à utiliser l’entrée/sortie à usage général pour clignoter une LED

Partager via