Clignoter une LED

2025-04-17

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 les broches GPIO de Raspberry Pi pour alimenter une LED et clignoter à plusieurs reprises.

Conditions préalables

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

Vérifiez que SSH est activé sur votre appareil. Pour Raspberry Pi, reportez-vous à la 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 illustre 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 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 BlinkTutorial.
```
dotnet new console -o BlinkTutorial
cd BlinkTutorial
```
Ajoutez le package System.Device.Gpio au projet. Utilisez l’interface CLI .NET à partir du répertoire du projet ou de Visual Studio.
```
dotnet add package System.Device.Gpio --version 3.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 using déclaration 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 while boucle s’exécute indéfiniment. Chaque itération :
  1. Écrit une valeur sur le pin GPIO 18. Si ledOn c’est vrai, il écrit PinValue.High (activé). Sinon, il é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 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.
```
./BlinkTutorial
```
La LED clignote et se déclenche toutes les secondes.
Terminez le programme en appuyant sur Ctrl+C.

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

Obtenir le code source

La source de ce didacticiel est disponible sur GitHub.

Étapes suivantes

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

Partager via