Faire clignoter une LED

Article
06/01/2023

Les broches d’E/S à usage général (GPIO) peuvent être contrôlées individuellement. Cette approche est utile pour contrôler les LED, les relais et d’autres appareils avec état. Dans cette rubrique, vous allez utiliser .NET et vos broches GPIO Raspberry Pi pour alimenter une LED et la faire clignoter de façon répétée.

Prérequis

Ordinateur à carte unique (SBC) basé sur ARM (ARMv7 ou version ultérieure)
LED 5 mm
Résistance 330 Ω
Platine d’expérimentation
Câbles de liaison
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 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.

Vérifiez que SSH est activé sur votre appareil. Pour Raspberry Pi, consultez Configuration d’un serveur SSH dans la documentation Raspberry Pi.

Préparer le matériel

Utilisez les composants matériels pour générer le circuit, comme illustré dans le diagramme suivant :

L’image ci-dessus décrit les connexions suivantes :

Broche GPIO 18 vers anode LED (fil positif plus long)
Cathode LED (file négatif plus court) à résistance de 330 Ω (à l’une ou l’autre extrémité)
Résistance de 330 Ω (autre extrémité) à la terre

Si nécessaire, reportez-vous au schéma de raccordement suivant :

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. Choisissez le nom BlinkTutorial.
```
dotnet new console -o BlinkTutorial
cd BlinkTutorial
```
Ajoutez le package System.Device.Gpio au projet. Utilisez l’interface CLI .NET du répertoire du projet ou Visual Studio.
```
dotnet add package System.Device.Gpio --version 2.2.0-*
```
Remplacez le contenu du fichier Program.cs par le code suivant :
```
using System;
using System.Device.Gpio;
using System.Threading;

Console.WriteLine("Blinking LED. Press Ctrl+C to end.");
int pin = 18;
using var controller = new GpioController();
controller.OpenPin(pin, PinMode.Output);
bool ledOn = true;
while (true)
{
    controller.Write(pin, ((ledOn) ? PinValue.High : PinValue.Low));
    Thread.Sleep(1000);
    ledOn = !ledOn;
}
```
Dans le code précédent :
- Une déclaration using crée une instance de GpioController. La déclaration using garantit que l’objet est supprimé et que les ressources matérielles sont correctement libérées.
- La broche GPIO 18 est ouverte pour la sortie
- Une boucle while s’exécute indéfiniment. Chaque itération :
  1. Envoie une valeur à la broche GPIO 18. Si ledOn est vrai, écrit PinValue.High (activé). Sinon, écrit PinValue.Low.
  2. Mise en veille pendant 1 000 ms.
  3. Bascule la valeur de ledOn.
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 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.
```
./BlinkTutorial
```
La LED clignote chaque seconde.
Terminez le programme en appuyant sur Ctrl+C.

Félicitations ! Vous avez utilisé GPIO pour faire clignoter une LED.

Obtenir le code source

La source de ce tutoriel est disponible sur GitHub.

Étapes suivantes

Découvrez comment lire une entrée binaire à l’aide de GPIO