Raspberry Pi: externe Status-LEDs über GPIO (pwr_led & act_led)

Aktuelle Raspberry Pi-Modelle besitzen 2 Status-LEDs auf dem Board, anhand derer man erkennt, ob der RPi läuft (pwr_led) und ob sich gerade etwas tut (act_led). Baut man den RPi jedoch in ein Gehäuse ein, sind diese LEDs oft verdeckt. In diesem Beitrag wollen wir ein paar LEDs über die GPIO-Anschlüsse ansteuern und damit die Staus-LEDs außerhalb geschlossener Gehäuse sichtbar machen.

Grundlagen und Material

Ich setze mal voraus, dass Ihr einen betriebsbereiten Raspberry Pi mit installiertem Image und SSH-Zugang zur Hand habt. Falls nicht, könnt Ihr hier nochmal nachlesen, wie ich ein neues System aufsetze.

Also, was brauchen wir? Ein paar LEDs mit niedrigem Stromverbrauch und die passenden Widerstände dazu. Bei der Auswahl der LEDs sollte man folgendes beachten: Angeschlossen werden sie am GPIO-Header des Raspberry Pi’s. Aus den GPIO-Ausgängen kommt +3,3V heraus und an einem beliebigen GPIO wird der +-Pol der LEDs (das längere Bein) angeschlossen. Das kürzere Bein, der --Pol, wird über einen Widerstand an GND angeschlossen. Der Widerstand dient dazu, die überschüssige Spannung zu verbraten und den Strom durch die LED zu begrenzen.

Spannungsfall LED/Widerstand

Weiterhin müssen bei der Auswahl der LEDs deren technische Daten berücksichtigt werden. Die Versorgungsspannung sollte ≤3,3V und die Stromaufnahme ≤16mA sein, denn das ist der Strom, den die GPIO auf Dauer liefern können. Eine LED mit höherer Stromaufnahme wird zwar auch funktionieren, nur kann man sich nicht sicher sein, wie lange das funktioniert und ob der Raspberry Pi auf Dauer nicht doch Schaden nimmt.

Ich habe mich für Low-Current-LEDs entschieden, die eine Durchlassspannung von 2,1V und eine Stromaufnahme von 2mA haben. Das bedeutet, dass von den 3,3V, die der Ausgang ausgibt, 2,1V für die LED verwendet werden und die restlichen 1,2V über den Widerstand abfallen müssen. Weiterhin möchten die LEDs 2mA an Strom haben, sodass diese 2mA auch durch den Widerstand fließen müssen. die Größe des Widerstandes errechnet sich jetzt wie folgt:

Rein rechnerisch bräuchten wir einen 600Ω-Widerstand. Da es diesen jedoch nicht gibt, nehmen wir den nächst größeren mit 680Ω.

LEDs anschließen

LEDs am Raspberry Pi anschließen

Wer möchte, kann sich LEDs, Widerstände und Raspberry Pi ja erstmal auf einer Steckplatine zusammenstecken und ein wenig herumprobieren. Letztlich muss das Ganze jedoch zusammengelötet werden, um nicht zu viel Platz im Gehäuse zu verschenken. Die GPIO-Belegung könnt Ihr hier nochmal nachschauen. Ich habe die LEDs wie folgt angeschlossen:

• ROT: an GPIO26 (Pin 37)
• GRÜN: an GPIO20 (Pin 38)
• GELB: an GPIO21 (Pin 40)
• Masse: an GND (Pin 39)

Zuerst schneiden wir das jeweils kürzere Bein an den LEDs noch kürzer und löten daran den Widerstand an. Dann befestigen wir die LEDs im Gehäuse und biegen die langen Beine (die ohne den Widerstand) der LEDs so zusammen, dass wir an alle 3 einen Draht anlöten können. Als nächstes nehmen wir uns ein paar Steckbrücken, schneiden auf der einen Seite den Stecker ab und verzinnen die Adern. Zuletzt müssen die Drähte dann nur noch angelötet und die andere Seite auf den Raspberry Pi gesteckt werden.

Steuerung der LEDs

…über die Shell

Die Status-LEDs sind jetzt soweit vorbereitet, dass man sie beliebig in einem Script ansteuern kann. Entweder verwendet man dafür ein Python-Script, wie ich hier schonmal beschrieben habe, oder macht das direkt über die Shell. Letzteres will ich hier mal kurz anhand des GPIO26 erläutern.

Zuerst muss der gewünschte GPIO verfügbar gemacht werden. Das geschieht, indem man auf der Kommandozeile die GPIO-Nummer exportiert:

$ echo 26 > /sys/class/gpio/export

Damit ist der GPIO erstmal grundsätzlich einsatzbereit. Als nächstes wird der GPIO als Ausgang festgelegt:

$ echo "out" > /sys/class/gpio/gpio26/direction

Anschließend kann er dann eingeschaltet werden, indem 1 auf den Ausgang geschrieben wird:

$ echo 1 > /sys/class/gpio/gpio26/value

Zum Ausschalten schreiben wir 0:

$ echo 0 > /sys/class/gpio/gpio26/value

Mit diesem Wissen können wir nun in beliebige Shell-Scripte die Steuerung von Statusanzeigen einbauen. Wir könnten auch Cron dazu verwenden, LEDs zu schalten.

…über /boot/config.txt

Um über die LEDs den echten Betriebsstatus des Raspberry Pi erkennen zu können, müssen wir etwas tiefer ins System eintauchen. In der Datei /boot/config.txt kann man verschiedene Einstellungen vornehmen. Darunter auch das Weiterleiten der Status-Informationen. Außerdem kann man hier angeben, wie die Onboard-, aber auch die GPIO-LEDs getriggert werden sollen. Dafür stehen verschiedene Trigger zu Auswahl:

Es gibt noch ein paar weitere Trigger, die man sich mit folgendem Befehl ausgeben lassen kann:

$ cat /sys/class/leds/led0/trigger

Verwendet werden können die Trigger mit folgenden Parametern:

• act_led_trigger=<Trigger>
• pwr_led_trigger=<Trigger>

Für act_led_trigger ist mmc0 der Standard. Möchte man diese Funktion beibehalten, kann man sich die Angabe des Triggers sparen.

Die externen LEDs lassen sich mit diesen Parametern ansteuern:

• act_led_gpio=<GPIO-Nummer>
• pwr_led_gpio=<GPIO-Nummer>

In diesem Beispiel nutzen wir die rote LED als Heartbeat. Die grüne soll Schreib- und Lesezugriffe auf der SD-Karte anzeigen. Also öffnen wir die config-Datei mit folgendem Befehl…

$ sudo nano /boot/config.txt

…und fügen für einen Raspberry Pi bis Version 2 am Ende folgende Zeilen an:

# Status-LEDs an GPIO weiterleiten
dtparam=act_led_gpio=20
dtparam=pwr_led_gpio=26,pwr_led_trigger=heartbeat

Beim Raspberry Pi 3 wurden diese Funktionen geändert. So kann man dort nicht mehr auf pwr_led zugreifen. Auch die act_led funktioniert nun anders:

# Status-LEDs an GPIO weiterleiten
dtoverlay=pi3-act-led,gpio=20

Nach einem Reboot werden die Einstellungen übernommen. Fortan blinken die GPIO-LEDs ohne Ansteuerung durch ein separates Script.

Nutzt man übrigens timer als Trigger, so kann man die Blink-Frequenz mit folgenden Befehlen beeinflussen:

$ echo [Zeit in ms] > /sys/class/leds/led0/delay_on
$ echo [Zeit in ms] > /sys/class/leds/led0/delay_off

Auch für none gibt es noch Einstellungen. Mit brightness kann man bestimmen, ob die LED ein- oder ausgeschaltet sein soll:

$ echo 1 > /sys/class/leds/led0/brightness
$ echo 0 > /sys/class/leds/led0/brightness

Und die gelbe LED?

Was man am besten mit der gelben LED macht, hängt natürlich von der konkreten Anwendung ab. Die Pi’s in meinem Netzwerkschrank haben natürlich eine konkrete Funktion. Auf dem einen läuft RaspberryMatic, auf dem anderen FHEM. Hier ist es natürlich eine relevante Information, ob beides korrekt arbeitet. Dafür habe ich in beiden Systemen einen Heartbeat programmiert, der jeweils die gelbe LED blinken lässt.

Unter RaspberryMatic, das seit einigen Versionen mit WiringPi ausgeliefert wird, sieht das so aus und wird aller 2 Sekunden ausgeführt:

FHEM bringt die Unterstützung von GPIOs ebenfalls direkt mit (allerdings ohne WiringPi), sodass wir uns hier auf deine reine FHEM-Config beschränken können:

define RPi.GPIO21_htb_led RPI_GPIO 21
attr RPi.GPIO21_htb_led direction output
attr RPi.GPIO21_htb_led room RPi

define RPi.GPIO26_htb_led.blink at +*00:00:02 set RPi.GPIO21_htb_led on-for-timer 1
attr RPi.GPIO26_htb_led.blink room RPi

Weiterführende Informationen und Links

• Overlays: https://github.com/raspberrypi/firmware/blob/master/boot/overlays/README

• Über
• Letzte Artikel

Sebastian

...ist staatlich geprüfter Techniker für Elektrotechnik, Schwerpunkt Prozessautomatisierung und Energietechnik. Die Themen Automatisierung und Programmierung haben es ihm besonders angetan.
Außerdem ist er für jede technische Spielerei zu haben 😉

Letzte Artikel von Sebastian (Alle anzeigen)

• Proxmox: „Failed to connect to Server“ mit Safari auf MacOS - 28. Januar 2023
• Loxone: Benachrichtigung per Telegram - 15. Januar 2022
• Telegram: Nachrichten per Bot von der Heimautomation aufs Handy - 2. Januar 2022