Installation und Einrichtung des Raspberry Pi mit umfangreicher Netzwerkfunktionalität
Dr. Olaf Simon / IPG417.11.2021
Version von 17.11.2021
Mit der Installation eines Raspberry Pi befassen sich im Internet bereits unzählige Beiträge. Leider befassen sich die meisten Beiträge nur mit thematisch sehr eingegrenzten Schritten oder gesuchte Funktionalitäten müssen aus Beiträgen mit anderem Kerninhalt heraus kristallisiert werden.
Aus diesem Grund sind hier in einem etwas größerem Umfang diejenigen Informationen zusammengefasst, die den Raspberry Pi mit umfangreicher Netzwerkfunktionalität ausstatten. Dazu gehören Schritte vom WLAN-Zugang, über Fernzugriff (Remote Desktop) bis hin zum HTTP-Server. Auch weitergehende Schnittstellen wie die serielle Schnittstelle oder Bluetooth werden behandelt.
Die Anleitung richtet sich im Wesentlichen an Personen mit Grundwissen über Computer, die einen Einstieg in Linux, dem Betriebssystem des Raspberry Pi, suchen.
Die Erläuterungen können (mindestens) auf die Hardware ZeroW, Pi3 und aufwärts angewendet werden.
Die Möglichkeiten zur Installation des Betriebssystems beim Raspberry Pi sind sehr vielfältig. In diesem Beitrag habe ich eine Variante gewählt, die das Abspeichern bzw. Sichern einer kompletten nach individuellen Wünschen durchgeführten Installation ermöglicht, so dass deren Wiederherstellung oder Kopie auf eine andere Hardware möglich ist. Diese Vorgehensweise ist nicht zwingend, andere (durchaus komfortablere) Wege zur Installation (genannt seien hier die Stichworte ‚Raspberry Pi Imager‘ und ‚NOOBS‘) können gleichwertig gewählt werden.
Die Basis bildet ein Image, d.h. eine komplette Kopie des dauerhaften Speichermediums. Bei gewöhnlichen Rechnern handelt es sich um eine Festplatte, beim Raspberry Pi in der Regel um eine SD-Speicherkarte. Gespeichert wird diese Kopie in einem File mit der Endung *.img.
Ein Basis-Image mit einem lauffähigem Betriebssystem wird vom Hersteller des Rechners herausgegeben und bereitgestellt.
Für die 32-bit Rechnerarchitekturen (ZeroW, Pi3) erhält man diese unter:
https://www.raspberrypi.com/software/operating-systems/#raspberry-pi-os-32-bit
Sofern das Image als Archiev (z.B. *.zip) bereitgestellt wird, so ist dieses zunächst zu entpacken. Dieses Image muss nun auf die SD-Karte des Raspberry Pi geschrieben werden.
An einem „Arbeits-PC“ (hier beispielsweise ein Windows-PC, jedoch ähnlich auch bei Mac und Linux) erfolgt dies in zwei Schritten:
1. Eine neue SD-Karte muss zunächst als ‚FAT32‘ formatiert werden. Dies kann mit dem Programm ‚SD Formatter 4.0‘ erfolgen (https://www.sdcard.org/downloads/formatter/).
Das Programm ist soweit selbst erklärend.
2. Anschließend muss das heruntergeladene Image auf die SD-Karte geschrieben werden. Dazu kann das Programm ‚Win32DiskImager‘ verwendet werden (https://sourceforge.net/projects/win32diskimager/). Das Image File laden, das Laufwerk der SD-Karte auswählen und das Image schreiben.
Der bei weitem einfachste Weg für die Benutzung und Einrichtung des Raspberry Pi ist der Anschluss eines Monitors mittels HDMI Kabels sowie einer USB-Tastatur und einer USB-Maus. Die Alternative einer Inbetriebnahme ohne Ein-/Ausgabemedien (‚headless‘) beschreibt der nächste Abschnitt.
Beim Raspberry ZeroW ist darauf zu achten, dass ein HDMI-Adapter benötigt wird. Zudem gibt es dort nur einen funktionellen USB-Port, so dass entweder eine Kombinierte Tastatur mit integrierter Maus (vorteilhaft auch als kabellose Funkvariante) oder ein USB-Hub angeschlossen werden muss.
Wenn die genannten Geräte angeschlossen sind und die mit dem Image beschriebene SD-Karte in den nicht an der Spannungsversorgung angeschlossenen Raspberry eingeschoben ist, kann der Raspberry Pi durch Anschließen der Spannungsversorgung gestartet (gebootet) werden.
Sobald die Oberfläche geöffnet ist, klicken Sie mit der rechten Maus auf die Oberfläche und wählen ‚Open in Terminal‘. Danach öffnet sich ein Terminal-Fenster, in welches Kommandozeilenbefehle eingegeben werden können.
Den folgenden Abschnitt können Sie überspringen.
Möchte man den Raspberry ohne Anschluss von Monitor und Tastatur in Betrieb nehmen, so benötigt man in irgendeiner Weise einen Zugang vom Arbeits-PC auf den Raspberry, damit Monitor und Tastatur des Arbeits-PCs verwendet werden können. Diese Verbindung muss auf physischer Ebene für einen Datenaustausch zwischen Arbeits-PC und Raspberry gegeben sein. Danach kann über ein Terminal-Programm am Arbeits-PC eine Kommandozeilenumgebung des Raspberry Pi geöffnet werden, so dass dort Programme und Befehle „aus der Ferne“ ausgeführt werden können.
Grundsätzlich kann das über eine serielle Schnittstelle geschehen. Wenn man aber schon weder Tastatur noch Monitor anschließen möchte, so wird man vermutlich auch keine serielle Schnittstelle anschließen wollen.
Es bleibt dann noch die Ethernet-Schnittstelle. Leider besitzt der ZeroW noch nicht einmal eine kabelgebundene Ethernet-Schnittstelle, sondern kann lediglich eine Ethernet-Verbindung über WLAN herstellen.
Die Ethernet-Schnittstelle (kabelgebunden oder kabellos per WLAN) lässt jedoch einen Terminal-Zugang nur dann zu, wenn dieser auch explizit freigegeben wurde.
Für eine Inbetriebnahme des Raspberry ohne Ein-/Ausgabemedien (‚headless‘ operation) müssen daher mindestens eine, beim ZeroW zwei, Vorbereitungen zu treffen, bevor die SD-Karte in den Raspberry eingelegt werden kann.
Wird die mit dem Image beschriebene SD-Karte in den Arbeits-PC eingelegt, so erscheint diese dort in zwei Partitionen, d.h. mit zwei Laufwerksbuchstaben! Die ‚boot‘-Partition hat ein unter Windows lesbares Format und kann geöffnet werden. Die zweite Partition enthält das eigentliche Betriebssystem, ist jedoch in einem für Windows nicht lesbarem Format angelegt.
1. Für die Freigabe der Terminal-Konsole über Ethernet muss auf der Boot-Partition im Ordner ‚boot‘ ein leeres File mit dem Namen ‚ssh‘ (ohne irgendeine Endung) angelegt werden.
Quelle: https://thaicademy.com/article/config-ssh-on-raspberry-pi
Anmerkungen:
- Ob die Datei leer ist, oder einen Inhalt besitzt, hat keine Bedeutung.
- Nach dem späteren Einschalten des Raspberries wird diese Datei automatisch wieder gelöscht, d.h. die Freigabe ist nur für einen Boot-Vorgang wirksam!
2. Für einen WLAN-Zugang müssen die entsprechenden Zugangsdaten angelegt werden. Dies erfolgt in gleicher Weise durch das Anlegen einer Textdatei mit dem Namen
‚wpa_supplicant.conf’
und folgendem Inhalt.
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=DE
network={
ssid="WLAN-123456"
psk="WLANPASSWORD
proto=RSN
key_mgmt=WPA-PSK
pairwise=CCMP
auth_alg=OPEN
}
Anmerkung:
Sofern diese Datei vorhanden ist, wird diese vom Linux Betriebssystem automatisch an die Stelle /etc/wpa_supplicant/wpa_supplicant.conf kopiert und dort verwendet.
Nach diesen beiden Schritten kann die SD-Karte in den nicht an der Spannungsversorgung angeschlossenen Raspberry eingeschoben werden. Durch Anlegen der Spannungsversorgung wird der Raspberry gebootet.
Öffnen Sie nun auf dem Arbeits-PC ein Terminal-Programm, welches das ssh-Protokoll beherrscht (‚Secure Shell‘). Eine Option ist das Programm ‚PuTTY‘ (https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html).
Mittels Angabe des standard ‚host‘-Namens ‚raspberrypi‘ oder der IP-Adresse des Raspberry Pi kann das Terminalprogramm eine Verbindung herstellen. Die IP-Adresse können Sie über die Bedienoberfläche Ihres Routers herausbekommen. Geben Sie als Nutzer ‚pi‘ an und benutzen Sie das Standardpasswort ‚raspberry‘. Dieses Passwort sollten Sie zur Vermeidung von Missbrauch über das Internet, wie im späteren Verlauf beschrieben, unbedingt abändern.
Sobald die Kommandozeile vom Terminalprogramm bereitgestellt wird, besteht der erste Schritt darin, die Freigabe für den Zugang zum Terminal über Ethernet dauerhaft freizuschalten. Geben Sie dazu die beiden folgenden Befehle ein:
$ sudo systemctl enable ssh
$ sudo systemctl start ssh
Für den Fall, dass der Monitor gedreht werden soll, editieren Sie folgende Datei:
$ sudo nano /boot/config.txt
und fügen für eine 180° Drehung am Ende die folgende Zeile an.
lcd_rotate=2
(Da der 'boot'-Ordner in der von Windows lesbaren Partition der SD-Karte liegt, kann diese Änderung ggf. auch am Arbeitsrechner vorgenommen werden.)
Zur Durchführung der wichtigsten Grundeinstellungen kann ein Konfigurationsprogramm verwendet werden, welches eine „textuelle Oberfläche“ bereitstellt. Starten Sie dies über folgenden Befehl:
$ sudo raspi-config
Stellen Sie unbedingt aus Sicherheitsgründen ein neues Passwort ein.
System Options → Password
Alternativ kann dies auch über ein Kommando erfolgen.
$ passwd pi
Wählen Sie einen individuellen Namen des Rechners, unter dem dieser im Netzwerk erscheint.
System Options → Hostname
(Dieser Eintrag kann auch in den Files '/etc/hostname' und '/etc/hosts' direkt vorgenommen werden.)
Für den Zugriff auf den Rechner über das Netzwerk muss die 'secure shell' (SSH) freigeschaltet werden (sofern über die obigen Kommandozeilen noch nicht geschehen). Hierdurch wird auch der Dienst SDP zur verschlüsselten Übertragung von Dateien freigegeben.
Interface Options → SSH
Vor der Installation neuer Programme ist immer eine Aktualisierung der Liste der neuesten verfügbaren Programm Updates sinnvoll bzw. sogar notwendig:
$ sudo apt-get update
eventuell ergänzt um den Parameter: --allow-releaseinfo-change
Führen Sie auch möglichst die tatsächliche Installation dieser Updates auf den neuesten Stand durch:
$ sudo apt-get upgrade
1.Terminal öffnen:
Mit rechter Maus auf der Oberfläche oder das Ubuntu-Icon oben links zur Programmsuche wählen
2.Ordner öffnen:
System-Ordner$ cd /.
User-Ordner '/home/[User]'$ cd ~
3.File-Liste:$ ls
4.Ordner anlegen:$ mkdir
5.File kopieren$ cp
6.File löschen$ rm
7.„super/root“-Rechte$ sudo vor dem Kommando eingeben
8.Starten eines Programms:$ ./[Programmname]
9.Netzwerkadapter$ ifconfig
10.Datei ausgeben$ cat [Dateiname]
11.Hilfe zu einem Befehl xyz$ xyz --help
$ man xyz
12.Kommandozeileneditor$ nano, vi, vim
13.Editor der Oberfläche $ leafpad, mousepad
14.Geladene Treiber listen $ dmesg
15.Besitz- und Zugriffsrechte $ chown
Für die Inbetriebnahme ohne Ein-/Ausgabegeräte gemäß dieser Anleitung zwingend, ansonsten optional, ist die Einrichtung des Fernzugriffs auf die grafische Oberfläche des Raspberry von einem beliebigen PC im Netzwerk, also insbesondere vom Arbeits-PC.
Für eine Windows Remote Desktop-Verbindung wird auf dem Raspberry xrdp installiert. Um dies durchführen zu können, muss jedoch das für den Remote-Zugriff bereits vorinstallierte Programm realVNC deinstalliert werden.
$ sudo apt-get purge realvnc-vnc-server
$ sudo apt-get install xrdp
Damit Sie sich mit dem Raspberry Pi über das Netzwerk verbinden können, müssen Sie die IP-Adresse (oder den Host-Namen) kennen. Die IP-Adresse können Sie durch den Befehl
$ sudo ifconfig
anzeigen lassen.
Weitere Hinweise, die auch die SSH Terminal Verbindung betreffen, können dem folgenden Link entnommen werden.
https://www.raspberrypi.org/documentation/remote-access/ip-address.md
Auf Ihrem Windows-Arbeits-PC können Sie nun das Programm 'Remotedesktopverbindung' starten. Geben Sie die IP-Adresse an und verbinden sich. Als User geben Sie 'pi', als Passwort 'raspberry' an.
Der Arbeits-PC zeigt nun die grafische Oberfläche des Raspberry Pi. Damit haben die Inbetriebnehmer mit Tastatur und Monitor und die 'headless' Inbetriebnahme einen gemeinsamen Stand.
Um für einen Programmstart ein Icon auf der Grafischen Oberfläche zu erhalten, muss man auf dieser ein sogenanntes desktop-file anlegen (rechte Maus → New File). Hierbei handelt es sich um eine Textdatei mit der Namensendung '.desktop' mit folgendem Inhalt. Beispielsweise können Sie diese 'Edit.desktop' nennen.
[Desktop Entry]
Name=Text Editor
Name[de]=Texteditor
Comment=Simple text editor
Comment[de]=Einfache Textbearbeitung
TryExec=/usr/bin/mousepad
Exec=/usr/bin/mousepad %F
Icon=/usr/share/desktop-base/debian-logos/logo-256.png
Terminal=false
Type=Application
MimeType=text/plain
Categories=Utility;TextEditor;
StartupNotify=true
Sobald die Datei existiert, erscheint auf dem Desktop das entsprechende Icon. Der Editor kann nun per Doppelklick → Ausführen gestartet werden.
Übrigens können Desktop-Dateien mit folgendem Befehl auch über die Kommandozeile ausgeführt werden:
$ xdg-open Edit.desktop
Möchte man nach der Systemanmeldung (bzw. dem Einschalten) automatisch Programme starten, so gibt es ähnlich zu Windows einen Autostart-Ordner, der angelegt und genutzt werden kann.
Zunächst öffen Sie ihren Home-Ordner (/home/pi) im Dateimanager und lassen sich versteckte Dateien anzeigen (Ansicht → Versteckte anzeigen). Nun können Sie den Ordner '.config' öffnen. In diesem Ordner legen Sie einen neuen Ordner mit Namen 'autostart' an. In diesem Ordner können dann mehrere '.desktop'-Dateien angelegt werden, die alle nach der Systemanmeldung parallel gestartet werden.
Verschiebt man obige 'Edit.desktop'-Datei in den 'autostart'-Ordner, kann man diese Funktion testen.
Befehle, die über die Kommandozeile eingegeben werden, können in einem Skript, d.h. einer Textdatei, zusammengefasst und anschließend gemeinsam in Folge ausgeführt werden. Derartige Skripte werden Shell-Skripte genannt und von dem Programm 'bash' ausgeführt.
Die vom Programm 'bash' ausführbaren Befehle sind sehr umfangreich und durchaus komplex. Letztendliches kann man hier durchaus von einer Programmiersprache reden. Eine ausführliche Beschreibung würde hier zu weit gehen, dazu gibt es diverse Tutorials im Internet. Hier sei lediglich ein sehr kleines Beispiel behandelt.
Erstellen Sie im Ordner '/home/pi/Dokumente' eine Textdatei mit dem Namen 'program.sh'. Die Dateiendung steht für 'shell'. Fügen Sie in diese Datei die folgenden Zeilen (d.h. die folgenden Befehle) ein:
wert=7
echo Der Wert ist $wert
Öffnen Sie dann den Ordner 'Dokumente' im Terminal. Zur Probe können Sie diese beiden Befehlszeilen nacheinander in den Terminal eingeben. Der erste Befehl legt eine Variable an, der zweite gibt einen Text und den Inhalt der Variablen aus.
Das gleiche Ergebnis kann nun auch dadurch erreichen, dass man das Shell-Skript 'programm.sh' zur Ausführung bringt:
$ bash program.sh
Da es sich bei dem Skript ja letztendlich um ein Computerprogramm handelt, gibt uns Linux die Möglichkeit, dieses Skript auch bezüglich der Formalität des Aufrufes wie ein 'echtes' Programm zu behandeln. In der Windows-Sprache würde man sagen, dass sich 'program.sh' wie eine '*.exe' Datei verhält und durch einen direkten Aufruf in der Kommandozeile ausgeführt werden kann. Dazu sind zwei Schritte notwendig:
1.In der ersten Textzeile muss eine Information darüber stehen, welches Programm zur Abarbeitung der Textdatei angewendet werden muss. (Anders als in Windows ist die Auswertung von Endungen von File-Namen für diesen Zweck nicht vorgesehen!) Damit kann der Inhalt von 'programm.sh' wie folgt erweitert werden.
#! /bin/bash
wert=7
echo Der Wert ist $wert
(Übrigens kann in der ersten Zeile anstelle von '/bin/bash' auch jedes andere Programm angegeben werden, an welches die Textdatei als Parameter übergeben werden soll.)
2.Aus Sicherheitsgründen müssen ausführbare Dateien in Linux als solche gekennzeichnet werden. Das wiederum kann nur mit root-Rechten durch ausführen des folgenden Befehls erfolgen. Mittels 'sudo' erlangt man root-Rechte (ggf. unter Aufforderung zur Eingabe eines Passwortes), 'chmod' ändert Dateieigenschaften und +x steht für das Ergänzen der Ausführungseigenschaft ('execute').
$ sudo chmod +x program.sh
Nach diesen beiden Schritten, lässt sich das Shell-Skript wie jedes andere Programm starten.
$ ./program.sh
Leider muss man durch './' immer noch angeben, dass sich das auszuführende Programm im aktuellen Ordner befindet. Das liegt daran, dass der Ordner, in dem 'program.sh' gespeichert ist, nicht in der PATH-Systemvariablen angegeben ist. Die dafür notwendige Ergänzung wird im folgendem Abschnitt erläutert.
Quelle: https://linuxhandbook.com/run-shell-script/
Zwischen dem Einschalten des Raspberry Pi bis zur Ausführen eines Programms in einem Terminal werden vom Linux-Betriebssystem im Hintergrund zu verschiedenen Zeitpunkten automatisch drei verschiedene Shell-Skripte zur Ausführung gebracht. Durch Erweiterung dieser Skripte können zusätzliche automatisierte individuelle Systemeinstellungen vorgenommen werden.
1. Systemweit: /etc/profile
$ sudo nano /etc/profile
Dieses Skript wird beim Hochfahren des Linux-Betriebssystems ausgeführt. Einstellungen in diesem File sind systemweit gültig, d.h. für alle Benutzer.
2. User-weit: ~/.profile
$ nano ~/.profile
Einstellungen dieses Skriptes werden während der Anmeldung eines Benutzers ausgeführt und gelten daher ausschließlich und individuell für einen einzelnen Benutzer.
3. Terminal-weit: ~/.bash_profile und ~/.bashrc
$ nano ~/.bash_profile
$ nano ~/.bashrc
Einstellungen hier werden erst dann ausgeführt, wenn ein Terminal-Fenster geöffnet wird, in dem folgend Kommandos ausgeführt werden.
Um nun die Problemstellung des vorigen Abschnitts zu lösen, ist die Zielsetzung, den Ordner '/home/pi/Dokumente' in der PATH Systemvariablen zu ergänzen. Das es sich bei diesem Ordner um einen Ordner des Benutzers 'pi' handelt, ist es sinnig, diesen Ordner auch nur für den Benutzer 'pi' in die PATH-Variable zu übernehmen. Daher editieren wir das File .profile.
$ mousepad ~/.profile
und fügen am Ende folgende Zeile an:
export PATH=/home/pi/Dokumente:$PATH
Wirksam wird dies erst, wenn '.profile' auch ausgeführt wird, d.h. in diesem Fall ist mindestens ein ausloggen und wieder einloggen notwendig. Da beim Raspberry Pi normaler Weise kein expliziter Vorgang des Einloggens vorgesehen ist und man nach dem Einschalten automatisch und ohne Passworteingabe als User 'pi' angemeldet wird, ist das Aus- und Einschalten der einfachste Weg.
Nun können Sie aus einem Terminal unabhängig vom aktuellen Ordner das selbst als Shell-Skript geschriebene Programm genauso wie jeden Systembefehl aufrufen.
$ programm
Im folgenden sind einige Programme aufgelistet, die je nach den eigenen Bedürfnissen recht interessant sein können:
$ sudo apt install net-tools
Ein einfaches grafisches Programm für Screen Shots kann wie folgt installiert werden. Nach der Installation befindet sich das Programm im Start-Menü unter 'Zubehör' mit Namen 'Bildschirmfoto'.
$ sudo apt install gnome-screenshot
Siehe auch: https://itigic.com/essential-programs-to-install-on-raspberry-pi/
Bei den Raspberry Pis mit bluetooth wird eine serielle Schnittstelle für das bluetooth-modul verwendet. Die andere „einfache“ Schnittstelle auf den Header-Pins ist mit Einschränkungen verbunden. Die folgenden Ausführungen zeigen welche Konfigurationen durchzuführen sind, um diese Schnittstelle für eigene Zwecke und nicht als Terminal-Schnittstelle zu verwenden. (Wesentlich einfacher ist die Verwendung eines USB-Seriell-Umsetzers.)
Eine Eigenschaft der einfachen seriellen Schnittstelle ist die Tatsache, dass diese mit dem Prozessortakt gekoppelt ist. Um deren Taktrate von dynamischen Energiesparanpassungen des Prozessors unabhängig zu machen, welche unter anderem Taktverringerungen beinhalten, müssen diese deaktiviert werden. Dies erfolgte früher über eine eigene Einstellung (core_freq=250), heute wird dies jedoch mit der Aktivierung der Schnittstelle automatisch vorgenommen.
Dazu in '/boot/config.txt' die Zeile
enable_uart=1
einfügen!
Weiterhin muss die Terminal- bzw. Konsolenfunktion von der Schnittstelle genommen werden. Dazu folgende zwei Schritte ausführen:
$ sudo raspi-config
aufrufen und in
Interfacing Options -> serial -> login shell: no, serial hardware enable: yes
setzen. Als zweites die Datei '/boot/cmdline.txt' editieren und den Eintrag
console=…
entfernen.
Nach einem Neustart
$ reboot
ist die Schnittstelle dann unter dem Namen '/dev/ttyS0' (null) ansprechbar. Unter Linux stehen diese Bezeichnungen für die unter Windows gewohnten Namen 'COM1'.
Zum Testen der Datenübertragung können Sie das Kommandozeilen Terminal Programm
$ minicom
verwenden. Ein Programm für die grafische Oberfläche ist (vgl. Abschnitt 1.2.1):
$ sudo apt-get install putty
Quellen:
https://www.abelectronics.co.uk/kb/article/1035/raspberry-pi-3--4-and-zero-w-serial-port-usage
https://www.raspberrypi.org/documentation/configuration/uart.md
Für Anzeige- und Steuerungszwecke sind die Ein- / Ausgangsanschlüsse (I/O pins) des Raspberry Pi die bei weitem einfachsten Schnittstellen. Gerade bei der Verwendung eines Raspberry Pi ohne Monitor, bilden an I/O pins angeschlossene LEDs (neben der einen an Board befindlichen) eine geringe aber sehr wichtige Anzeigemöglichkeit.
Insbesondere sind natürlich die an Board befindliche zwei LEDs (bei ZeroW sogar nur eine) interessant, da man keine externe Elektronik aufbauen muss.
Raspberry Pi model 2 B, B+ and A+:
Zunächst muss die LED als 'gpio' (general purpose input or output) nutzbar gemacht werden. 'led0' entspricht der mit 'ACT' beschrifteten LED, 'led1' entspricht der 'PWR' beschrifteten LED. (Der Befehl 'tee' schreibt Eingaben in ein File und im Gegensatz zum '>' Kommando kann diesem das notwendige 'sudo' vorangestellt werden.)
$ echo gpio | sudo tee /sys/class/leds/led1/trigger
Zum Ein- bzw. Ausschalten kann nun die '1' oder '0' verwendet werden.
$ echo 1 | sudo tee /sys/class/leds/led1/brightness
Der LED kann das ursprüngliche Verhalten durch folgenden Befehl wiedergegeben werden:
$ echo input | sudo tee /sys/class/leds/led1/trigger
Raspberry Pi ZeroW:
Quelle:
https://www.jeffgeerling.com/blogs/jeff-geerling/controlling-pwr-act-leds-raspberry-pi
Zur Ansteuerung der vielen I/Os der Stiftleiste finden sich auf folgendem Link entsprechende Hinweise.
Der CAN Bus ist eine Entwicklung aus dem Automobilbereich, hat aber auch in der Industrie und bei Controllern eine weite Verbreitung erlangt. Interessant ist dieser Abschnitt daher nur für Entwickler, die mit diesem Bus arbeiten wollen.
Von Natur aus bringt der Raspberry Pi keine CAN-Schnittstelle mit. Diese kann aber z.B. durch einen USB zu CAN Umsetzer (ähnlich zu seriellen Schnittstellen) ergänzt werden. Hier beschrieben ist ein derartiger Umsetzer der Firma PEAK.
Das Linux Betriebssystem bringt bereits einen CAN-Treiber mit, so dass der Umsetzer mittels dieses ‚Socket CAN‘ bereits nutzbar ist.
Die Installation des originalen Linux-Treibers von PEAK mit zusätzlichen Funktionalitäten erfordert auf dem Raspberry Pi (wie auch auf anderen Linux-Betriebssysemen) eine eigene Kompilierung, da es keine Distributionen von lauffähigen Binärdateien gibt. Es sind daher die im Abschnitt ‚Entwicklungstools – C/C++ – Kompiler‘ beschriebenen Installationsschritte durchzuführen.
Zunächst ist, wie bei Installationen grundsätzlich, eine Aktualisierung der bereits installierten Softwaremodule zu empfehlen:
$ sudo apt-get update
$ sudo apt-get upgrade
Die Treiberinstallation erfolgt mit folgenden Schritten. Zunächst sind die für die Kompilierung notwendigen ‚header‘ Dateien des Kernels zu installieren.
$ sudo apt install raspberrypi-kernel-headers
Die ‚header‘ Dateien werden je nach Kernel Version z.B. in /usr/src/=/usr/src/linux-headers-4.19.66-v7+ abgespeichert. Die Version der installierten header files sollte man zur Prüfung mit der Kernel Version des Raspberry vergleichen. Diese erhält man mit:
$ uname -a
Anschließend die Linux-Treiber (peak-linux-driver-8.1.tar.gz) von PEAK herunterladen, entpacken und in den Ordner der entpackten Daten als aktuellen Ordner gehen. Es müssen vor der Kompilierunt folgende Libraries installiert werden:
$ sudo apt-get install libpopt-dev
Danach kann der Kompiliervorgang des Linux-Triebers gestartet warden.
$ make PCI=NO PCIEC=NO PCC=NO DNG=NO PAR=NO ISA=NO KERNEL_LOCATION=/usr/src/linux-headers-4.19.66-v7+
$ sudo make install KERNEL_LOCATION=/usr/src/linux-headers-4.19.66-v7+
$ sudo modprobe pcan
Die Installation kann anhand der Ausgabe des folgenden Befehls überprüft werden:
$ cat /proc/pcan
Anmerkung: Eine Deinstallation des Treibers ist mittels $ sudo make uninstall möglich.
Zur Installation des Programmes „pcanview“, mit dem der Datenverkehr auf dem CAN-Bus beobachtet und Nachrichten gesendet werden können, sind folgende Schritte notwendig:
Das file peak-system.list in den Ordner /etc/apt/sources.list.d kopieren.
$ wget -q http://www.peak-system.com/debian/peak-system-public-key.asc -O- | sudo apt-key add
$ sudo apt-get update
$ sudo apt-get install pcanview-ncurses
Für einen Test kann in einem Terminal $ pcanview aufgerufen werden.
Quelle:
PEAK-Linux Driver on Raspberry Pi:
https://forum.peak-system.com/viewtopic.php?t=283&start=90
Post by M.Maidhof » Tue 28. Jun 2016, 11:39
Für den CAN-Support aus Python heraus bietet PEAK entsprechende Lösungen an. Es kann auch die folgende dynamische Bibliothek (Hinweise zur Compilierung siehe unten) installiert werden. Diese bietet als besondere Funktion eine Schnittstelle zum ‚Movi-Link‘-Protokoll der Firma SEW-Eurodrive an, so dass auf deren Produkte zugegriffen werden kann. Dazu
libPcanMoviLink.so
in den Ordner /usr/lib kopieren, allgemeine Leserechte für diese Datei vergeben und am System anmelden.
$ sudo chmod 777 /usr/lib/libPcanMoviLink.so
$ sudo ldconfig
Anmerkungen zur Übertragung des Linux x64 Projektes von libPCanMoviLink auf den Raspberry Pi:
Das für Linux x64 Rechner angelegte Projekt ‚Python/pyPcanMoviLink‘ auf den Raspberry kopieren. Die GNU-C-Compiler sind durch die Schritte der Installation des PCAN-Treibers bereits installiert.
In allen *.mk Files innerhalb von ‚…/pyPcanMoviLink/Prj_Lx_x64/Release‘ den korrekten absoluten Pfad eintragen. Dabei ist in der Regel ‚desimola/Dokumente‘ durch ‚pi/Documents‘ zu ersetzten. *.mk Files sind in allen Unterordnern von ‚Source‘ enthalten und müssen alle angepasst werden.
Danach kann im Release-Ordner mit ‚make clean‘ und ‚make all‘ kompiliert werden.
Sowohl über die Oberfläche als auch über die Konfigurationsdatei ist aufgrund der notwendigen Passworteingabe eine relativ umständliche Angelegenheit. Moderne Router verfügen in der Regel über eine WPS-Funktion, die eine Netzwerkanmeldung per Knopfdruch erfmöglichen. Insbesondere für diejenigen, die den Raspberry Pi ohne Monitor verwenden und diesen in einem anderen Netwerk verwenden wollen, ist die WPS-Methode die einzig praktikable.
Leider ist die WPS Funktion in der grafischen Oberfläche nicht enthalten, kann aber über die Kommandozeile aktiviert werden.
$ wpa_cli wps_pbc -i wlan0
Für eine automatisierte WPS Funktion ist die Ergänzung einer LED-Anzeige sinnvoll. Sie können dafür das Shell-Skript wps.sh herunterladen. Es kann z.B. in '.profile' gestartet werden. Am Paspberry ZeroW ist der Parameter 'ZeroW' zu ergänzen.
Eine weitere interessante Netzwerkfunktion besteht in der Möglichkeit, Dateiordner vom Raspberry Pi für alle Nutzer im Netzwerk freizugeben und somit den Zugriff auf diese Ordner von allen am Netzwerk verbundenen Rechnern bereitzustellen.
Die hier gezeigte Einrichtung gibt den Zugriff nur für angelegte Benutzer frei.
Für Ordnerfreigaben gibt es verschiedene Protokolle. In Windows-Netzwerken ist das 'samba'-Protokoll üblich, welches durch das gleichnamige Programm bereitgestellt wird.
$ sudo apt-get update
$ sudo apt-get install samba
Damit von anderen Rechnern über das Netzwerk auf freigegebene Ordner des File-Servers zugegriffen werden kann, muss man sich als 'Nutzer' anmelden. Bei dieser Anmeldung über das Netzwerk meldet man sich als 'samba'-User an und nicht als User des Linux-Betriebssystems! Daher muss man sich am File-Server als 'samba'-User einrichten. Es ist empfehlenswert gleiche User-Namen und Passwörter für Betriebssystem und File-Freigabe anzulegen. Dies erfolgt mit:
$ sudo smbpasswd –a <user>
Es ist natürlich sinnvoll, als '<user>' den Linux-User 'pi' zu verwenden.
Das Anzeigen bereits angelegter Nutzer erfolgt mit:
sudo pdbedit –L
Die eigentliche Ordnerfreigabe kann sehr einfach über die Nutzeroberfläche erfolgen. Legen Sie zum Beispiel einen Ordners 'Share' in Ihrem Nutzerverzeichnis an. Über die rechte Maustaste auf dem Ordner können Sie die 'Eigenschaften' anzeigen. Unter dem Tab 'Freigabe' können Sie die Freigabe einstellen.
Sollte das Scannen der am Netz befindlichen Rechner im Windows Netz nicht funktionieren, um auf die Netzwerkfreigabe von anderen Linux-Rechnern zugreifen zu können, müssen die Rechner manuell aufgerufen werden. (Meiner Erfahrung nach konnten die Linux-Rechner von den Windows-Rechnern aus gefunden werden, umgekehrt hat dies nicht immer geklappt.)
Dazu im ‚Dateien‘-Programm unter ‚andere Orte‘ unten rechts bei ‚Mit Server verbinden‘ den Zielrechner (z.B. den Arbeitsrechner) mit Namen oder IP-Adresse eingeben und den bei der Freigabe des Ordners im Arbeitsrechner gewählten Freigabenamen angeben:
smb://myWindowsWorkPC/Freigabe/
smb://192.168.178.32/Freigabe/
eingeben.
Danach vorzugsweise mit der rechten Maus auf das Laufwerkssymbol in der linken Spalte und ‚Lesezeichen hinzufügen‘ anwählen.
Um eine eigene Web-Seite zu betreiben oder Daten per Web-Zugriff vom Raspberry Pi auszulesen, kann auf diesem ein Web-Server eingerichtet werden. Als Beispiel verwende ich hier den ‚apache‘ Web-Server, es gibt aber z.B. ‚Tomcat‘ als Alternative.
$ sudo apt-get install apache2
Die Webseiten liegen unter /var/www/html. Für individuelle Seiten kann die Datei index.html ausgetauscht werden.
Anmerkung: Eventuell muss ‚start.sh‘ aufgerufen werden.
Um über HTML-Seiten eine flüssige Datenübertragung mit echtzeitfähigen Eigenschaften zu erreichen, ist die Nutzung der Web-Socket Programmiertechnologie ein zielführender Lösungsweg. (Eine Beschreibung hierzu folgt.)
Die Einrichtung des Raspberry Pi begann im Abschnitt 1.1 mit dem Schreiben eines vom Hersteller bereitgestellten Images auf die SD Karte des Raspberry Pi unter Verwendung des Programms ‚Win32DiskImager‘. Dieses Programm ist ebenso in der Lage, eine SD-Karte zu lesen und deren Inhalt in einer Image Datei (*.img) abzuspeichern.
Wenn dies mit der SD-Karte des nun eingerichteten Raspberry Pi durchgeführt wird, ist man im Besitz eines eigenen individuellen Images. Dieses kann jederzeit auf eine neue SD-Karte aufgespielt werden, so dass eine Wiederherstellung eines Systems oder ein Aufbau eines zweiten identischen Raspberry Pis mit dem eigenen Image und dem im Abschnitt 1.1 beschriebenen Verfahrens möglich ist.
Die Programmiersprache Python ist auf den Raspberry Pis bereits vorinstalliert. Die neueste Python Version 3.8 kann jedoch (noch) nicht auf dem einfachen Weg über 'apt-get' installiert werden. Es ist jedoch über folgenden Weg möglich.
$ sudo apt-get install -y build-essential tk-dev libncurses5-dev libncursesw5-dev libreadline6-dev libdb5.3-dev libgdbm-dev libsqlite3-dev libssl-dev libbz2-dev libexpat1-dev liblzma-dev zlib1g-dev libffi-dev
$ wget https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tar.xz
$ tar xf Python-3.8.0.tar.xz
$ cd Python-3.8.0
$ ./configure --prefix=/usr/local/opt/python-3.8.0
$ make -j 4
$ sudo make altinstall
Zum Aufräumen jetzt überflüssiger Dateien:
$ cd ..
$ sudo rm -r Python-3.8.0
$ rm Python-3.8.0.tar.xz
Da jetzt mehrere Versionen von Python installiert sind, kann eine Version als Standard eingerichtet werden:
$ sudo update-alternatives --config python
$ python -V
Eine andere Möglichkeit ist die Anlage eines 'softlinks' (ähnlich einer 'Verknüpfung' unter Windows):
$ ln -s -f /usr/bin/python3.8 /usr/bin/python
Quelle: https://itheo.tech/install-python-3-8-on-a-raspberry-pi
Auch Entwicklungsumgebungen für Python sind auf dem Raspberry bereits vorinstalliert. Allerdings handelt es sich um sehr einfache IDEs und größere Projekte erfordern leistungsfähigere Entwicklungsumgebungen. Hierzu ist das Programm ‚Spyder‘ empfehlenswert. (Genauere Installationshinweise folgen später.)
Letztendlich bietet jedoch die plattformunabhängigkeit der Programmiersprache Python den großen Vorteil, dass Programme außerhalb des Raspberry Pi, z.B. auf dem Arbeits PC, entwickelt und programmiert werden können. Nach Übertragung des Programms auf den Raspberry ist es dort ebenso lauffähig. Ausnahmen bilden hier lediglich Programmelemente, die einen speziellen Hardwarezugriff (z.B. auf die Header-Pins erfordern.
- Dieser Abschnitt ist noch nicht Aufbereitet und stellt lediglich eine lose Stichwortsammlung dar! -
Für die Entwicklung von Python Programmen mit einer grafischen Oberfläche stellt Python die Bibliothek 'tkinter' zur Verfügung. QT ist eine Alternative dazu und bietet unter anderem den Vorteil, dass diese auch für C++ zur Verfügung steht und eine Portierung von Python Programmen auf C++ dadurch erheblich vereinfacht wird.
Für die Verwendung von QT muss die Python Version mindestens 3.7 betragen!
- Installation über apt-get
$ sudo apt-get upgrade
$ sudo apt-get update
$ sudo apt install qt5-default pyqt5-dev pyqt5-dev-tools
$ sudo apt-get install qtcreator
- Installation über pip3 install
- ist bislang an SSL-Zertifikatsproblemen gescheitert! -
Beim Raspberry pip3 anstelle von pip verwenden, da zwei Python Versionen installiert sind.
$ python --version bzw. python3 --version
Für die SSL-Zertifizierung müssen Server freigegeben werden.
$ pip3 config set global.trusted-host= "pypi.org files.pythonhosted.org pywheels.org"
erzeugt einen Eintrag in /home/pi/.config/pip/pip.conf (pip3?) oder /etc/pip.conf (pip?):
[global]
trusted-host = pypi.org
pypi.python.org
files.pythonhosted.org
pywheels.org
Dieses File kann auch direkt editiert werden.
Zur Lösung der Zertifikatsprobleme folgende Aktualisierungen.
$ sudo apt-get install libffi-dev, libssl-dev
$ pip3 install –upgrade ndg-httpsclient
Bei Raspberry müssen die Setup-Tools aktualisiert werden.
$ python3 -m pip install --upgrade pip setuptools wheel
Sofern die Meldung angezeigt wird, dass /home/pi/.local/bin im PATH fehlt, so zunächst neu starten, da das System den Pfad nur dann übernimmt, wenn dieser existiert. Sollte das nicht erfolgreich sein, in ~.profile (notfalls in /etc/profile) die Zeile
export PATH=/home/pi/.local/bin:$PATH
einfügen.
Alternativen sind:
$ sudo apt-get install python-setuptools
$ sudo apt-get install python-dev
$ sudo apt install python-pip
Weiterhin ist durchzuführen:
$ pip3 install ez_setup
$ pip3 install unroll
Dann kann PyQt5 installiert werden.
$ sudo pip3 install pyqt5
oder
$ sudo pip3 install pyqt5 --trusted-host pypi.org --trusted-host “files.pythonhosted.org pypi.org”
oder
$ sudo apt-get install qt5-default
Java Programme laufen auf einem eigenen virtuellen Betriebssystem (Virtual Machine), der Java Runtime Environment (JRE). Da diese für viele Rechnerarchitekturen und Betriebssysteme, u.a. auch Linux und Windows, zur Verfügung steht, sind Java-Programme hardware- und betriebssystemunabhängig lauffähig. Für die Entwicklung von Java-Programmen ist das Java Development Kit (JDK) notwendig, welches die JRE mit umfasst.
Das Java JDK ist auf den Raspberry Pis bereits vorinstalliert.
ZeroW hat (momentan) eine für seinen Prozessor ungeeignete Java Version. Daher ist eine nachträgliche Installation notwendig:
$ sudo apt update
$ sudo apt-get install openjdk-8-jdk
Um diese Java Version als Standardversion einzurichten kann folgendes Kommando ausgeführt werden.
$ sudo update-alternatives --config java
Anmerkung: Möchte man vorherige Java Versionen entfernen, kann vorher
$ sudo apt remove default-jdk ausgeführt werden.
Auch Entwicklungsumgebungen für Java sind auf Raspberry Pis bereits vorinstalliert. Allerdings sind dies sehr einfache IDEs, die für größere Projekte nicht wirklich geeignet sind.
Eine leistungsfähige für Java-Entwicklungen gängige Umgebung ist ‚Eclipse‘.
Momentan kann Eclipse nicht installiert werden – die Quelle der lauffähigen Version ist nicht klar!
Eclipse ist selber ein Java-Programm, daher ist es notwendig, das JDK zu installieren (siehe voriger Abschnitt). Eclipse benötigt die Version 8, d.h. selbst wenn neuere Java-Versionen installiert sind, muss die JRE 8 / JDK 8 installiert werden.
$ sudo apt update
$ sudo apt-get install eclipse
Für einen komfortablen Programmaufruf kann man ggf. eine Desktop-Datei erstellen.
Leider bringt die JRE keine Unterstützung für serielle Schnittstellen mit. Aus diesem Grund muss dafür die RXTX Bibliothek installiert werden. Diese stellt eine über das ‚Java native interface (JNI)‘ realisierte Erweiterung der ‚Java virtual machine‘ dar. Sie liefert auch die zugehörige Java Programmierschnittstelle ‚applicaton user interface (API)‘ mit und ergänzt die Java Programmiersprache um Objekte zur Verwendung von seriellen Schnittstellen http://users.frii.com/jarvi/rxtx/download.html
Die Installation erfolgt in einem Terminal durch Eingabe des Befehls:
$ sudo apt-get install librxtx-java
Es wird dabei jeweils mehrere Dateien in folgende Ordner installiert:
- /usr/share/java/RXTXcomm… .jar Java API
- /usr/lib/jni/librxtx… .so Dynamische Linux Bibliothek (JRE Erweiterung)
Zur Einrichtung sind folgende Schritte notwendig:
1. Folgende Konfigurationsdatei editieren:
$ sudo nano /etc/ld.so.conf
2. Pfad der .so Bibliotheken in einer neuen Zeile hinzfügen:
/usr/lib/jni
3. Aktivieren dieser Systembibliothek mit dem Befehl:
$ sudo ldconfig
4. Für die Anmeldung der API an die Java-Programme ist der Pfad zum .jar-File der folgenden Umgebungsvariable hinzuzufügen. Dazu folgendes File editieren:
$ nano /home/pi/.bashrc
5. und folgende Zeile am Ende hinzufügen:
export LD_LIBRARY_PATH=/usr/lib/jni:${LD_LIBRARYPATH}
Alternativ dazu kann (bei jedem) Java Programmaufruf dieser Pfad auch mitgegeben werden:
$ java -Djava.library.path=/usr/lib/jni -jar myProgram.jar
6. Gegebenenfalls neu starten.
Die I/Os werden unter Java von der JNI-Bibliothek ‚pi4j‘ zur Verfügung gestellt.
Die Installation erfolgt mittels:
$ curl -sSL https://pi4j.com/install | sudo bash
(Ruft mehrere apt-get … Befehle auf.)
Für die Benennung der GPIO pins auf dem 40-pin-header siehe:
https://pi4j.com/1.0/pins/model-a-plus.html
Es ist strikt zwischen Pin-Nummern des physischen ‚header‘s und den logischen I/O Nummern GPIOx zu unterscheiden!
In Java sind die API-Bibliotheken des folgenden Ordners als ‚Library‘ einzubinden:
/opt/pi4j/lib
Folgendes Beispielprogramm beschreibt die Anwendung der Bibliothek.
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;
public class LedControl {
public static void main(String[] args) throws InterruptedException {
final GpioController gpio = GpioFactory.getInstance();
final GpioPinDigitalOutput pin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "PinLED", PinState.HIGH);
Thread.sleep(2000);
pin.low();
gpio.shutdown();
}
}
Die Java Bibliothek für Bluetooth ist ‚Bluecove‘. (Weiterführende Angaben zu Installation und Anwendung folgen.)
Für die Entwicklung von C/C++ Programmen ist die Installation des Gnu-Compilers notwendig.
$ sudo apt update
$ sudo apt-get install gcc
$ sudo apt-get install g++
$ sudo apt-get install make
Für C/C++ kann wie auch für Java die ‚Eclipse‘ IDE verwendet werden. Diese ist daher wie im Abschnitt ‚Java‘ beschrieben zu installieren.
Anschließend erfolgt die Installation einer Erweiterung von Eclipse für C/C++.
$ sudo apt-get install eclipse-cdt
Um Programme auszuführen, die nur in für x86-Prozessoren kompilierten Versionen zur Verfügung stehen, kann auf der ARM-Prozessorstruktur des Raspberry Pi eine virtuelle Umgebung mit Namen 'box86' installiert werden.
$ sudo apt update
$ sudo apt full-upgrade
$ sudo apt install git build-essential cmake
$ git clone https://github.com/ptitSeb/box86
$ cd ~/box86
$ mkdir build
$ cd build
$ cmake .. -DRPI3=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo
Dieser 'cmake' Aufruf ist für den Raspberry Pi 3, für den Raspberry Pi 4 muss der Aufruf gemäß der unten angegebenen Quelle angepasst werden.
Bei Fehlermeldungen bezüglich des Python Interpreters muss 'ccmake' aufgerufen werden, um unter „erweitert“ den korrekten python3.8 pfad einzutragen.
make -j$(nproc)
Sollten Fehler auftreten, kann die Option 'j' weggelassen werden.
$ sudo make install
$ sudo systemctl restart systemd-binfmt
$ reboot
Nach dieser Installation kann ein für die x86-Architektur kompiliertes Programm wie jedes andere Programm aufgerufen werden. 'box86' wird vom Betriebssystem automatisch aufgerufen.
Quelle: https://pimylifeup.com/raspberry-pi-x86/
Das Programm 'Skype' steht für Linux nur für die x86 Rechnerarchitektur zur Verfügung. Die Installation von 'box86' ist daher vonnöten. Außerdem kann es nur auf 64 bit Systemen betrieben werden. Aus diesem Grund ist ein Raspberry Pi 4 notwendig.
$ wget https://repo.skype.com/latest/skypeforlinux-64.deb
$ sudo apt-get install -f
Quelle: https://vitux.com/how-to-install-skype-on-debian-10/
In diesem Dokument genannte Produkte und Firmennamen sind lediglich benannt, weil ich mit diesen Produkten erfolgreich gearbeitet habe und ich Lesern damit die Möglichkeit geben will, die damit realisierten Funktionen oder Anwendungen zu reproduzieren.
Es werden durch diese Nennungen keine Werbeeinnahmen erzielt.
Ich habe mich bemüht, weitgehend die Quellen der Informationen zur Verfassung dieses Dokumentes anzugeben. Gerne ergänze ich weitere gegebenenfalls weitere Quellen.
Die in diesem Dokument beschriebenen Funktionen habe ich persönlich angewendet. Die rasante Entwicklung neuer Soft- und Hardwareversionen insbesondere beim Rapberry Pi werden jedoch unweigerlich dazu führen, dass Teile dieses Dokuments unkorrekt oder wesentlich einfachere Lösungen möglich werden. Sofern sich also Fehler eingeschlichen haben oder Inhalte zeitlich überholt sind, bin ich über derartige Hinweise dankbar.
Haftungsausschluss für den Download von Software.