Bastel-Rechner: Mit dem Raspberry Pi auf einem Bildschirm zeichnen
Der Bastelcomputer Raspberry Pi muss nicht still und von der Außenwelt unbeachtet im Netzwerk vor sich hinwerkeln. Es gibt zahlreiche Projekte, in denen er mit Peripherie-Geräten versehen wird, über die er mit uns kommuniziert oder wir mit ihm.
In diesem Projekt zeigen wir, wie ein 64-x-64-Pixel-Bildschirm angeschlossen wird und welche Möglichkeiten diese Konfiguration bietet. Für die Programmierung der grafischen Ausgaben von Linien und Text verwenden wir die Sprache C# unter dem Framework Mono.
Die Minicomputer aus der Raspberry-Pi-Reihe sind mit einer General Purpose Input/Output-Leiste (GPIO) ausgestattet. Hierbei handelt es sich um eine Aneinanderreihung von Pins, die einzeln oder in Gruppen durch Softwarebefehle so geschaltet werden, dass sie entweder Signale entgegennehmen oder abschicken. An diese Pins können LEDs, Motoren, Displays, Sensoren oder ähnliche Hardwarekomponenten angeschlossen werden, um sie fernzusteuern oder auszulesen.
Die Raspberry-Computer sind üblicherweise mit einem Linux-Betriebssystem namens Raspbian ausgestattet. Für das hier vorgestellte Projekt wird ein aktuelles Raspbian in der vollständigen Desktop-Version empfohlen.
Auch das kleinste Modell aus der Raspberry-Pi-Reihe, der Zero, besitzt eine GPIO-Leiste. Wir verwenden ihn in diesem Projekt, um zu zeigen, dass auch er für größere Aufgaben geeignet ist. Das Zero-Modell ist hardwareseitig allerdings nicht für den Desktopbetrieb geeignet. Deshalb haben wir hier eine Raspbian-Lite-Version installiert.
Welche Hardware brauchen wir?
Für die Ausführung von Betriebssystem-(OS)-Befehlen und für die Programmierung gibt es hardwareabhängig verschiedene Möglichkeiten: An den Raspberry Pi sind Bildschirm, Tastatur und eine Maus angeschlossen. Dann können alle Arbeiten direkt auf dem Raspberry Pi ausgeführt werden. Wenn keine separaten Ein- und Ausgabegeräte angeschlossen sind, besteht die Möglichkeit, sich über das Remote-Desktop-Protokoll (RDP) von einem anderen PC mit dem Raspberry Pi zu verbinden und dann quasi vor Ort zu arbeiten.
Unabhängig von angeschlossener Hardware wird auf einem beliebigen anderen PC programmiert. Die Skripte werden dann auf den Raspberry Pi übertragen, dort kompiliert und ausgeführt. In unserem Projekt kommt Variante 3 zum Einsatz. Wir programmieren auf einem Windows-PC und senden die C#-Skripte mit dem Tool WinSCP an den Raspberry Pi Zero. Der Kompilierung der Skripte und die Ausführung der Programme zur Bildschirmausgabe erfolgt auf der Kommandozeile des Raspbian-OS vor Ort. Hierzu benutzen wir das Terminal-Emulatorprogramm Putty.
Das Display
Als Bildschirm verwenden wir das RGB-Matrixmodul LED-MATRIX01 von Joy-IT. Bei diesem Modul handelt es sich um ein quadratisches Panel mit einer Kantenlänge von 192 mm, das mit 4.096 RGB-LEDs in einem 3-mm-Raster bestückt ist. Die Versorgungsspannung beträgt 5 V bei einer maximalen Leistungsaufnahme von 40 W. Weitere Informationen gibt es auf dem Datenblatt des Herstellers(öffnet im neuen Fenster) .
Auf dem LED-Panel kann jedes einzelne Pixel in 255 verschiedenen Farben zum Leuchten gebracht werden. Außer Pixeln und Objekten wie Linien oder Kreise besteht auch die Möglichkeit, Bilder auszugeben und Filme abzuspielen. Letzteres ist natürlich bei der gegebenen Auflösung nicht so sinnvoll, zeigt aber die Leistungsfähigkeit des Panels. Die Bildwiederholfrequenz ist konfigurierbar und beträgt maximal 60 Hertz. Auch die Helligkeit der LEDs können wir über die Programmierung einstellen.
Tipp: Im Einzelhandel sind Bilderrahmen in den Abmaßen 20 cm x 20 cm erhältlich. In so einen Rahmen passt das LED-Panel perfekt hinein. Zum Bilderrahmen gehören eine Front-Glasscheibe und eine Back-Hartfaserplatte. In Letztere muss nur eine Aussparung für die Kabel eingearbeitet werden. Damit ist auf einfache Weise ein schickes, professionell aussehendes Gehäuse für das LED-Panel fertiggestellt.
Stromversorgung und Verbindung zwischen Panel und Pi
Das LED-Panel benötigt eine eigene Stromversorgung. Wir verwenden ein geschlossenes Schaltnetzteil von POS-Power, das am Ausgang eine Leistung von 90 W, eine Spannung von 5 V und einen Strom von 18 A liefert.
Es besteht die Möglichkeit, auch den Raspberry Pi an dieses Netzteil mit anzuschließen, so dass letztendlich alles über einen einzigen Stromstecker läuft. Hierzu ist ein Kabel erforderlich, das für die Raspberry-Seite einen USB-Micro-B-(M)-Stecker benötigt. Auf der anderen Seite sind zwei freie Enden erforderlich, die an die Klemmen des LED-Panel-Netzteils angeschlossen werden.
Als Beispiel sei hier das Delock-Kabel 82697 USB 2.0 Micro B Stecker auf 2 x offene Kabelenden genannt, das es beim Elektronikhändler zu kaufen gibt. Alternativ besteht die Möglichkeit, so ein Kabel aus einem ausrangierten USB-Kabel selbst herzustellen. Die USB-Pin-Belegung kann im Web nachgeschlagen werden, zum Beispiel hier(öffnet im neuen Fenster) .
Der Einfachheit halber verwenden wir in unserem Projekt zwei separate Stromversorgungen: Das LED-Panel schließen wir an das genannte Netzteil an und den Raspberry Pi Zero an einen eigenen USB-Stromadapter.
Die einfachste Verbindung zwischen Raspberry Pi und LED-Panel bietet der Controller RB-MatrixCTRL ebenfalls von Joy-IT (mehr zu den Spezifikationen des Controllers unter diesem Link(öffnet im neuen Fenster) ).
Der Controller wird mit der einen Seite direkt auf die GPIO-Leiste des Raspberrys gesteckt. Auf der anderen Seite wird er über die HUB75-Schnittstellen mit dem vom LED-Panel-Hersteller mitgelieferten Flachbandkabel verbunden. Damit ist die Verbindung hergestellt. Leider funktioniert der Controller nicht zusammen mit dem Raspberry Pi Zero.
Aufwendigere Lösungen sind manuelle Verkabelungen. Hierfür werden Kabel mit sogenannten Female-to-Female-Steckschuhen benötigt. Das sind Kabelenden, die auf die Pins des LED-Panels und der GPIO-Leiste aufgesteckt werden.
Es besteht natürlich die Möglichkeit, diese Kabel selber herzustellen. Dazu benötigen wir Draht als Meterware, entsprechende Steckschuhe, Isoliermaterial und eine Crimp-Zange. Der Vorteil dieser Art Verkabelung ist, dass wir etwas längere Kabel verwenden können. Dadurch müssen wir Raspberry Pi und LED-Panel nicht dicht an dicht aufstellen und haben mehr Platz zum Experimentieren.
Für unser Projekt kaufen wir beim Elektronikhändler zehnadriges Flachbandkabel mit den entsprechenden Steckschuhen an beiden Enden.
.jpg)
.png)
Pin-2-Pin-Verbindung
Die Aufgabe besteht jetzt darin, die einzelnen Pins des LED-Panels korrekt mit dem jeweils richtigen Pin der GPIO-Leiste zu verbinden. Gesucht ist also eine 16-aus-40-Lösung. Hierbei dürfen wir natürlich keine Fehler machen, da sonst unsere Bildschirmausgabe nicht funktioniert und im schlimmsten Fall sogar etwas kaputtgeht.
Zur Unterstützung erstellen wir eine Skizze des genauen Anschluss-Layouts, wobei wir uns die unterschiedlichen Farben der Kabel zunutze machen. Welcher Pin mit wem zusammengehen soll, entnehmen wir der Pinout-Vorgabe des LED-Panel-Herstellers. Nachfolgend ein Beispiel basierend auf den oben genannten zehnadrigen Kabeln:
Wir bereiten den Raspberry Pi vor
Zunächst deaktivieren wir den Onboard-Sound: LED-Panel an der GPIO-Leiste und native Sound-Einstellungen des Raspberrys vertragen sich nicht gleichzeitig miteinander. Hierzu editieren wir die Datei config.txt im boot-Ordner:
sudo nano /boot/config.txt
In der Datei muss die folgende Zeile eingetragen beziehungsweise angepasst werden:
dtparam=audio=off
Damit wird der üblicherweise vorhandene Audio-Onboard-Anschluss des Raspberrys deaktiviert. Wenn wir später Sound parallel zum Betrieb des LED-Panels benötigen, müssen wir eine externe Audioanlage über USB anschließen.
Zum Betrieb des LED-Panels sind Softwarebibliotheken erforderlich. Die zugrunde liegenden Dateien holen wir uns zunächst aus der Versionsverwaltung git wie folgt:
sudo apt-get update sudo apt-get install git git clone https://github.com/hzeller/rpi-rgb-led-matrix
(Siehe hierzu auch die Joy-IT-Dokumentation.(öffnet im neuen Fenster) )
Danach muss der Raspberry neu gestartet werden:
sudo reboot
Im Home-Verzeichnis des Raspberry-Pi-Users gibt es jetzt den neuen Ordner rpi-rgb-led-matrix. Zur Erstellung der Bibliotheken und Beispieldateien wechseln wir in diesen Ordner hinein und führen dort folgende Befehle aus:
make -C examples-api-use
und
make build-csharp
Wenn die letzte Anweisung fehlschlägt, kann es daran liegen, dass die Laufzeitumgebung Mono auf dem Raspberry Pi fehlt. Dies ist besonders bei Raspbian-Lite-Versionen möglich. In unserer Konstellation mit dem Raspberry Pi Zero war das der Fall. Wir installieren also Mono mit folgenden Befehlen:
sudo apt update sudo apt install mono-complete
Danach sollte das make build-csharp fehlerfrei durchlaufen. Jetzt lohnt sich ein Blick ins Dateisystem. Dort stehen einige Demo-Programme bereit. Diese rufen wir beispielsweise wie folgt auf:
examples-api-use/demo -D 0 --led-rows=64 --led-cols=64
oder aus dem c#-Examples-Ordner:
mono minimal-example.exe
Nun geht es weiter zur Programmerstellung.
So erstellen wir ein Programm
Für die Bearbeitung von c#-Skripten kann auf einem Raspberry mit Desktop-Betriebssystem Geany verwendet werden.
Geany ist eine integrierte Entwicklungsumgebung, die sowohl die Ausführung von Compiler- beziehungsweise Execute-Befehlen ermöglicht als auch über Syntax-Highlighting und Intellisense verfügt.
Wir sind auf einem Windows-PC unterwegs und haben uns die Community-Version des Visual-Studios von Microsoft installiert.
Damit können wir hier schon diverse C#-Basisklassen fertigstellen, ohne die Skripte an den Raspberry schicken und dort kompilieren zu müssen.
Das ist für unser kleines Projekt zwar nicht erforderlich, aber bei größeren Vorhaben sehr praktisch. Für Windows-Betriebssysteme gibt es weitere kostenlose Editoren, die zumindest über Syntax-Highlighting verfügen, zum Beispiel Notepad++ oder Visual Studio Code.
Die Erzeugung von ausführbaren Programmen geschieht immer auf dem Raspberry. Hierzu kompilieren wir die C#-Skripte wie folgt:
mcs -r:RGBLedMatrix.dll -out: appname csscript
Dabei sind:
| mcs | Mono C# Compiler für die Kommandozeile |
| -r:RGBLedMatrix.dll | Über den Parameter r werden Bibliotheken eingebunden. Die hier angegebene Datei RGBLedMatrix.dll wurde bei der Installation der LED-Panel-Software erstellt. Sie muss zusammen mit einer Datei namens librgbmatrix.so im selben Verzeichnis liegen. Die Endung so steht für ein Shared-Object-File. Auch diese Datei kommt aus der Bibliothek des LED-Panels. dll- und so-Datei übernehmen wir beide aus dem c#-Examples-Ordner. |
| -out:<appname> | Über den Parameter out wird der Name derjenigen Datei definiert, die am Ende als ausführbare Datei herauskommen soll. Sie ist das Ergebnis des Compile-Prozesses. |
| <csscript> | Dies ist das zu kompilierende c#-Skript. Sind mehrere c#-Skripte beteiligt, geben wir sie hier nacheinander an. |
Werden beim Kompilieren Fehler im C#-Skript gemeldet, können wir diese natürlich auch auf kurzem Wege mit einem örtlichen Editor wie zum Beispiel nano korrigieren.
Die erzeugte App-Datei ist eine Mono-Applikation. Zur Ausführung in der zugehörigen Runtime müssen wir die Anweisung mono voranstellen:
mono appname
Hinweis: Diverse Anweisungen beziehungsweise Konsolenprogramme auf dem Raspberry Pi benötigen erweiterte Berechtigungen. Wir vergeben die Rechte nicht explizit, sondern verwenden den Kommandozeilenzusatz sudo. Aus Gründen der Übersichtlichkeit ist dieser nicht bei allen hier aufgeführten Befehlen angegeben.
Eine Linie und Bewegungen: Beispiele für Ausgaben auf dem LED-Panel
Das nachfolgende Beispiel zeigt auf dem LED-Panel eine Linie von links oben nach rechts unten.
// File test_draw_line.cs
using System;
using System.Threading;
using rpi_rgb_led_matrix_sharp; // RGBLedMatrix.dll
namespace rgbmatrixclock
{
class Program
{
static int Main(string[] args)
{
// Instanzierung der Objekte
var matrix = new RGBLedMatrix(new RGBLedMatrixOptions
{
Rows = 64,
Cols = 64,
GpioSlowdown = 2,
LimitRefreshRateHz = 60,
Brightness = 35,
DisableHardwarePulsing = false
});
var canvas = matrix.CreateOffscreenCanvas();
var yellow = new Color(255,255,0);
// Der Ursprung des Koordinatensystems ist links oben.
// Die y-Achse zeigt nach unten.
// Linie diagonal über den Bildschirm zeichnen:
canvas.DrawLine(0, 0, 63, 63, yellow);
// Die "Leinwand" auf das Panel übertragen
canvas = matrix.SwapOnVsync(canvas);
// 10 Sekunden warten
Thread.Sleep(10000);
// Mit Programmende wird das LED-Panel zurückgesetzt.
return 0;
}
}
}
Das Objekt matrix (Zeile 14) entspricht dem LED-Panel. Im Konstruktor RGBLedMatrix sind diverse Optionsparameter zur Konfiguration des Panels definiert. Informationen zu diesen Parametern entnehmen wir der Herstellerdokumentation zum Panel. Zusätzliche Informationen gibt es in verschiedenen readme- und Header-Dateien im Bibliotheksverzeichnis, wie zum Beispiel hier \rpi-rgb-led-matrix\README.md oder hier \rpi-rgb-led-matrix\include\led-matrix.h.
Das Objekt canvas (Zeile 23) ist mit einem 64-x-64-Pixel-Bitmap vergleichbar, das im Speicher liegt. Jedes Pixel dieses Bitmaps entspricht einer LED des Panels. Auf dem Bitmap zeichnen wir mit der Methode DrawLine (Zeile 28).
Das canvas-Objekt beherrscht weiterhin die Methoden DrawCircle, DrawText, SetPixel und Fill – mehr aber auch nicht. Umfangreiche Draw- und Fill-Methoden, wie wir sie beispielsweise aus dem .Net-Framework-Namespace Drawing kennen, gibt es hier leider nicht. Mit ein bisschen Mathematik erstellen wir uns diese Methoden jedoch bei Bedarf leicht selbst.
Die Matrix-Methode SwapOnVsync (Zeile 30) überträgt das Bitmap dann auf das LED-Panel. Erst durch diese Methode ist auf dem Panel etwas zu sehen.
Der nachfolgende Codeschnipsel zeigt, wie Bewegungen auf dem LED-Panel ausgegeben werden. Die grundlegenden Schritte sind immer die gleichen: eine Schleife erstellen, darin pro Durchlauf die Leinwand zurücksetzen, eine Situation zeichnen, SwapOnVsync anweisen, neue Situation berechnen und nächsten Schleifendurchlauf ausführen. In diesem Beispiel wird die Linie um den Panel-Mittelpunkt gedreht:
int x = 0;
int y = 0;
// Eine Endlosschleife
for ( ; ; )
{
// Leinwand zurücksetzen
canvas.Clear();
// Linie zeichnen
canvas.DrawLine(x, y, 63 - x, 63 - y, yellow);
// Auf dem Panel ausgeben
canvas = matrix.SwapOnVsync(canvas);
// Neue Koordinaten berechnen
if (++y > 63)
{
y = 63;
x++;
}
if (x > 63)
{
x = 0;
y = 0;
}
}
Für die Ausgabe von Text stehen im Arbeitsverzeichnis fonts diverse Font-Dateien zur Verfügung. Auf diese muss bei der Instanziierung des Font-Objekts explizit verwiesen werden. Mit den folgenden Anweisungen geben wir Text auf dem LED-Panel aus:
RGBLedFont font = new RGBLedFont("/home/pi/rpi-rgb-led-matrix/fonts/7x13.bdf");
canvas.DrawText(font, 10, 30, yellow, "Hallo");
canvas.DrawText(font, 10, 45, yellow, "Welt!");
Fazit
In diesem Projekt haben wir gezeigt, wie mit einfacher C#-Programmierung Ausgaben auf einem LED-Panel gemacht werden. Wenn auch zum Zeichnen nur 64 x 64 Bildpunkte zur Verfügung stehen, sind die Möglichkeiten doch vielfältig.
Darüber hinaus besteht die Möglichkeit, mehrere LED-Panels parallel und/oder in Reihe verkettet an einem einzigen Raspberry Pi zu betreiben. So bilden zum Beispiel vier LED-Panels im Quadrat ein circa 40 x 40 cm großes Display mit 128 x 128 Bildpunkten.
Damit sind schon viel mehr Ideen für Hobby und Beruf realisierbar. Auch die Anordnung von vier Panels nebeneinander (circa 20 x 80 cm) ist eine Lösung für verschiedene praktische Aufgaben. Als ein Beispiel sei hier die Textausgabe mittels Laufschrift genannt.
Natürlich ist bei solchen Konstellationen mehr Augenmerk auf die Raspberry-Hardware zu richten. Hier empfehlen wir zum Beispiel die Ausrüstung mit einer aktiven Kühlung. Die Zero-Version des Raspberrys ist dafür nicht geeignet.