Blinken einer LED

Artikel
06/01/2023

Allgemeine E/A-Pins (GPIO) können einzeln gesteuert werden. Diese Funktion ist für die Steuerung von LEDs, Relais und anderen zustandsbehafteten Geräten nützlich. In diesem Abschnitt werden Sie .NET und die GPIO-Pins Ihres Raspberry Pi verwenden, um eine LED einzuschalten und sie wiederholt blinken zu lassen.

Voraussetzungen

ARM-basierter (ARMv7 oder höher) Single-Board-Computer (SBC)
5-Millimeter-LED
330-Ω-Widerstand
Breadboard
Jumperdrähte
Raspberry Pi GPIO Breakout Board (optional/empfohlen)
.NET SDK 7 oder höher

Hinweis

Dieses Tutorial wurde unter der Annahme geschrieben, dass das Zielgerät Raspberry Pi ist. Dieses Tutorial kann jedoch für jeden Linux-basierten SBC verwendet werden, der .NET unterstützt, z. B. Orange Pi, ODROID und mehr.

Stellen Sie sicher, dass SSH auf Ihrem Gerät aktiviert ist. Für Raspberry Pi: Lesen Sie Einrichten eines SSH-Servers in der Dokumentation zu Raspberry Pi.

Vorbereiten der Hardware

Verwenden Sie die Hardwarekomponenten, um eine Schaltung wie im folgenden Diagramm zu erstellen:

Die obige Abbildung zeigt die folgenden Anschlüsse:

GPIO 18 an LED-Anoden (längere, positive Leitung)
LED-Kathode (kürzere, negative Leitung) an 330-Ω-Widerstand (beide Enden)
330-Ω-Widerstand (anderes Ende) an Masse

Beachten Sie falls nötig das folgende Anschlussdiagramm:

Bild mit freundlicher Genehmigung der Raspberry Pi Foundation.

Tipp

Ein GPIO-Breakout-Board in Verbindung mit einer Steckplatine wird empfohlen, um die Verbindungen zum GPIO-Header zu optimieren.

Erstellen der App

Führen Sie in Ihrer bevorzugten Entwicklungsumgebung die folgenden Schritte aus:

Erstellen Sie eine neue .NET-Konsolen-App, indem Sie entweder die .NET-CLI oder Visual Studio verwenden. Nennen Sie BlinkTutorial.
```
dotnet new console -o BlinkTutorial
cd BlinkTutorial
```
Fügen Sie dem Projekt das Paket System.Device.Gpio hinzu. Verwenden Sie entweder .NET CLI aus dem Projektverzeichnis oder Visual Studio.
```
dotnet add package System.Device.Gpio --version 2.2.0-*
```
Ersetzen Sie den Inhalt von Program.cs durch den folgenden Code:
```
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;
}
```
Für den Code oben gilt:
- Eine Using-Deklaration erzeugt eine Instanz von GpioController. Mit der using-Deklaration wird sichergestellt, dass das Objekt verworfen wird und die Hardwareressourcen richtig freigegeben werden.
- GPIO-Pin 18 wird für die Ausgabe geöffnet
- Eine while-Schleife wird ohne zeitliche Begrenzung ausgeführt. Bei jeder Iteration passiert Folgendes:
  1. Ein Wert wird in GPIO-Pin 18 geschrieben. Wenn ledOn den Wert „true“ hat, wird PinValue.High geschrieben (ein). Andernfalls wird PinValue.Low geschrieben.
  2. 1000 ms langes Warteintervall.
  3. Umschalten des Werts von ledOn.
Erstellen Sie die App. Führen Sie dotnet build aus, wenn Sie die .NET-CLI verwenden. Drücken Sie STRG+UMSCHALT+B, um die App in Visual Studio zu kompilieren.
Stellen Sie die App auf dem SBC als eigenständige App bereit. Anweisungen hierzu finden Sie unter Bereitstellen von .NET-Apps auf einem Raspberry Pi-Gerät. Erteilen Sie dabei mithilfe von chmod +x die execute-Berechtigung für ausführbare Dateien.
Führen Sie die App auf dem Raspberry Pi aus, indem Sie zum Bereitstellungsverzeichnis wechseln und die ausführbare Datei ausführen.
```
./BlinkTutorial
```
Die LED blinkt im Sekundentakt aus und ein.
Beenden Sie das Programm, indem Sie STRG+C drücken.

Glückwunsch! Sie haben GPIO verwendet, um eine LED blinken zu lassen.

Herunterladen des Quellcodes

Der Quellcode für dieses Tutorial ist auf GitHub verfügbar.

Nächste Schritte

Erfahren Sie, wie Sie binäre Eingaben mit GPIO lesen

Teilen über