Asus Tinkerboard

Das Asus Tinkerboard ist, wie der Raspberry Pi, ein Einplatinencomputer.

Neben wesentlich stärkerer Hardware, hat das Tinkerboard sogar exakt das selbe Layout wie der Raspberry Pi, so kann man z.B. Gehäuse oder Erweiterungsboards quasi 1:1 am Tinkerboard nutzen.

Asus Tinkerboard – Herstellerseite

Aufmerksam geworden bin ich auf das Board, als ich meinen Raspberry Pi 2 als Fhem-Server ersetzen wollte. Ein Pi 3 hätte die logische Nachfolge sein können, doch die interessanten Leistungsdaten und das identische Layout des Asus Tinkerboards haben mich sehr neugierig gemacht.

Zum Geburtstag ließ ich mir dann eins schenken und habe mich dann an die Arbeit gemacht, hier ein paar Eindrücke

P_20180308_122213_vHDR_Auto

Auf der Rückseite sind die Leistungsdaten abgebildet:

P_20180308_122222_vHDR_Auto

Inbesondere durch die 4k Dekodierung sollte sich das Board auch optimal als Mediacenter eignen – für mich hat das alles vorerst aber keine Bedeutung.

Inhalt

Unboxing

Tinkerboard, Kühlkörper, Anleitung

P_20180308_122310_vHDR_Auto

Das Board selbst ist, wie von Asus nicht anders zu erwarten, sehr hochwertig verarbeitet. Das Layout entspricht nahezu exakt dem des Raspberry Pi (2,3) – dementsprechend können Gehäuse und Zubehör vom Raspberry Pi verwendet werden.

P_20180308_122317_vHDR_Auto

Ob man den Kühlkörper wirklich braucht?! Ich hab ihn natürlich montiert, da sich mein Homeserver in einem Hutschienengehäuse befindet.

P_20180308_122420_vHDR_Auto

zurück zum Inhalt

ARMbian

Vor der Inbetriebnahme habe ich mir eine neue SD Karte besorgt.

Ab jetzt ist man mehr oder weniger auf sich allein gestellt.

Im Vorfeld habe ich mich schon mit diversen Betriebssystemen des Tinkerboards auseinandergesetzt. Asus selbst bietet das sog. „TinkerOS“  mit Desktop an. Android ist auch möglich.

Für meinen Homeserver reicht mir natürlich eine Version ohne Desktop völlig aus – da stieß ich bei meiner Suche auf das Projekt „Armbian„. Ich entschied mich für Ubuntu desktop – mainline kernel „Server and light desktop usage scenarios“.

Nach dem Download des Image kann man Selbes mit dem Programm Etcher wie gehabt auf eine SD Karte schreiben und das Tinkerboard im Anschluss in Betrieb nehmen.

armbian

In der Dokumentation von Armbian ist natürlich beschrieben, wie weiter vorzugehen ist. Als erstes meldet man sich als User „root“, mit dem Passwort „1234“ an. Danach wird man aufgefordert das Kennwort für „root“ zu ändern. Im Anschluss daran wird ein neuer User angelegt, dem man Namen und Passwort geben muss.

Unter  Raspbian nutzen die meisten dann erstmal den Befehl:

sudo raspi-config

um die wichtigsten Einstellungen vorzunehmen. Unter Armbian heisst der Befehl:

sudo armbian-config

Dort können dann, ähnlich wie unter Raspbian, grundlegende Einstellungen vorgenommen werden.

ambian-config

Ab hier kann es dann weitergehen, wie man es von den meisten Debian-basierenden Systemen gewohnt ist

sudo apt-get update && sudo apt-get upgrade

bringen das System auf den neusten Stand und das Tinkerboard ist für alles Weitere vorbereitet.

In meinem Fall habe ich noch den Desktop deaktiviert, für einen reinen Server reicht der „Headless“ Betrieb natürlich vollkommen.

Die Installation von Fhem z.B. kann nach den gängigen Anleitungen vorgenommen werden.

zurück zum Inhalt

Gpios steuern und schalten

Am Raspberry Pi lassen sich die GPIOs dank WiringPi ziemlich einfach steuern. Leider ist WiringPi  exklusiv für den Raspberry und lässt sich am Tinkerboard nicht nutzen.

Asus selbst stellt für die Nutzung der GPIOs am Tinkerboard eine Python und eine C API bzw. Libary bereit, zu finden auf Github. Beide findet man auch im Tinkerboard-Wiki, samt Installationsanleitung.

Diese lassen sich mit den dort beschriebenen Anleitungen recht leicht installieren.

Um die Python API zu nutzen, müssen ggf. noch zwei Pakete installiert werden

sudo apt-get install idle-Python2.7

&

sudo apt-get install idle3

zurück zum Inhalt

C-Libary

Shell/Terminal-Befehle

Die Shell/Terminal Befehle zum Schalten der GPIOs basieren auf der C-Libary – dementsprechend sind auch die Befehle.

Leider konnte ich die Shell bzw. Terminal Befehle nur als angemeldeter Root ausführen (ARMbian)- das ist für eine spätere Verwendung natürlich etwas ungünstig.

Der Zustand der GPIOs und die korrekte Bezeichnung der Pins kann man übrigens mit

gpio readall

einsehen – das ist ein Befehl, den Raspberry Pi-Nutzer natürlich kennen.

readall

Für die im Wiki genannten Befehle, ist die Nummerierung unter „CPU“ anzuwenden.

Es ist auch wichtig die Reihenfolge einzuhalten. Der GPIO muss erstmal exportiert werden

echo 188 > /sys/class/gpio/export

erst dann kann die Direktion, oder Value gesetzt werden

echo out > /sys/class/gpio/gpio188/direction
echo 1 > /sys/class/gpio/gpio188/value

im Anschluss kann man den GPIO wieder zurück bzw. un-exportieren

echo 188 > /sys/class/gpio/unexport

Dann gibt es dort noch den Cat-Befehl. Dieser gibt den aktuellen Status des GPIO aus. Value ob High oder Low

cat

Direction ob In- oder Output

cat2

Nicht unbedingt elegant, aber funktional.

Bash-Skript

Man kann diese Befehle aber  ziemlich gut in ein kleines Bash-Skript verpacken, gefunden habe ich diese Möglichkeit im Fhem-Wiki. Das Skript legt den jeweiligen GPIO als Ausgang (out) fest und man kann zwischen Low und High bzw 1 und 0 wählen um dem Pegel des GPIO zu setzen.

Als erstes erstellt man sich dazu eine neue Datei. Da ich die Gpios auch aus Fhem heraus schalten will, erstelle ich die Datei im entsprechenden Verzeichnis:

sudo touch /opt/fhem/FHEM/fhem-gpio.sh

Fhem-spezifisch: Da es sich um eine .sh Datei handelt, kann man diese auch leicht über die Fhem-Weboberfläche bearbeiten. Dazu reicht ein Klick im Fhem-Web auf Edit files – das Skript taucht dann unter Own modules and helper files auf und kann dort bequem bearbeitet werden. (Bei den unten vorgestellten Python-Skripten ist das nicht der Fall, da die Dateiendung .py von Fhem nicht berücksichtig wird).

oder, bzw. wenn man schon im Terminal ist:

sudo nano /opt/fhem/FHEM/fhem-gpio.sh

in dem Fall öffnet sich, wie sollte es auch anders sein, der Nano-Editor und man kann den Code aus dem Wiki einfügen:

#!/bin/bash
PORT=$1;
if ! [ -d /sys/class/gpio/gpio$PORT ]
then
  echo "$PORT" > /sys/class/gpio/export
  echo "out" > /sys/class/gpio/gpio$PORT/direction
fi
STATE=$2;
if [ $STATE -ge 1 ]
then
  STATE=1
fi
echo "$STATE" > /sys/class/gpio/gpio$PORT/value

Das Skript wird nun noch an den User Fhem übergeben und per Chmod ausführbar gemacht

sudo chmod 700 opt/fhem/FHEM/fhem-gpio.sh && sudo chown -R fhem:root /opt/fhem/FHEM/fhem-gpio.sh

Da da Skript immer mit root-Rechten (sprich einem vorangestelltem sudo) ausgeführt werden muss, sollte Fhem die entsprechenden Rechte dafür haben. (Das gilt ebenfalls für die Python-Skripe, die unten vorgestellt werden.)

Das Skript kann nun, je nach dem wo es bearbeitet wurde, gespeichert und geschlossen werden (bei Nano mit STRG+O, Editor mit STRG+X verlassen -unter Fhem-Web reicht ein klick auf Save as fhem-gpio.sh).

Das gute an dem Skript ist, dass es nicht nur für einen GPIO anwendbar ist, sondern für einen beliebigen. Dazu muss hinter den Aufruf nur die jeweilige CPU-GPIO-Nummer und der Zustand angegeben werden

  • Linux-Terminal
sudo sh /opt/fhem/FHEM/fhem-gpio.sh 188 1 &
sudo sh /opt/fhem/FHEM/fhem-gpio.sh 188 0 &
  • Fhem-Kommandozeile
{system("sudo sh /opt/fhem/FHEM/fhem-gpio.sh 188 1 &")}
{system("sudo sh /opt/fhem/FHEM/fhem-gpio.sh 188 0 &")}

Diesen Befehl, inkl. der passenden CPU-Nummer des zu schaltenden GPIO, kann man so problemlos in ein Notify oder ein Doif verpacken.

zurück zum Inhalt

Python-Libary

Mehr oder weniger elegant kann man die GPIOs mit einem kleinen Python Skript beschalten. Das interessante dabei ist, dass man Python das Pin-Out der GPIOs auch vom Raspberry vorgeben kann. Die GPIOs haben dann nicht die Nummerierung, wie in der C-Libary (CPU) – sondern z.B. die BCM-Nummern vom Raspberry. Für die Anpassung bereits vorhanderer Python Skripte ist das natürlich ein Vorteil, da nur Kleinigkeiten geändert werden müssen.

Ich hab an mein Tinkerboard, wie auch an seinem Vorgänger Raspberry 2, eine Relaiskarte mit vier Relais gesteckt.

Je ein Relais hängt an den Pins 32, 36, 38 und 40 des Tinkerboards. Anhand der oben bereits bekannten CPU Nummerierung ergäbe das die 239, 223, 187 und 188.

Müntz man das nun auf die BCM-Nummerierung des Raspberry um, so erhält man 12, 16, 20 und 21.

Damit kann man arbeiten.

Nun kann man sich ein kleines Test-Skript für Python schreiben. In meinem Fall setze ich damit die (BCM)-GPIOs 12, 16, 20 und 21 als Ausgang und den Zustand auf Low.

Zuerst also eine Datei anlegen (das kann man natürlich auch am Windows PC erledigen und die fertige Datei anschließend per FileZilla auf das Board schieben)

sudo nano gpiolowtest.py

das erzeugt eine leere Datei mit dem Namen gpiolowtest.py und öffnet direkt den Editor Nano. Der folgende Code wird dann einfach in die Datei geschrieben/kopiert

#importieren der Module
import ASUS.GPIO as GPIO
import time,sys
#GPIO Grundeinstellungen
GPIO.setmode (GPIO.BCM) #Hier wird die Nummerierung für Raspberry BCM gesetzt
GPIO.setwarnings(False) #Das verhindert die Ausgabe von Warnhinweisen
#GPIO Modus setzen
GPIO.setup (12,GPIO.OUT) #setzt GPIO 12 auf Ausgang
GPIO.setup (16,GPIO.OUT)
GPIO.setup (20,GPIO.OUT)
GPIO.setup (21,GPIO.OUT)
#Zustand der GPIOS festlegen
GPIO.output (12,False) #setzt GPIO 12 auf Low
GPIO.output (16,False)
GPIO.output (20,False)
GPIO.output (21,False)

Danach kann man die Datei mit STRG+O abspeichern und Nano mit STRG+X verlassen. Ausgeführt werden kann das ganze nun mit

sudo python3 gpiolowtest.py

Da wir keine Ausgabe in das Skript geschrieben haben, erfolgt auch keine. An, in meinem Fall, der Relaiskarte kann man anhand der LEDs nun sehen, dass die GPIOs den entsprechenden Zustand eingenommen haben.

P_20180509_221102_vHDR_Auto.jpg

Um die LEDs wieder abzuschalten bzw. die GPIOs in den High-Zustand zu versetzen, erstellt man ein zweites Skript, diesmal nennen wir es einfach

sudo nano gpiohightest.py

und fügt einen leicht geänderten Inhalt ein

#importieren der Module
import ASUS.GPIO as GPIO
import time,sys
#GPIO Grundeinstellungen
GPIO.setmode (GPIO.BCM) #Hier wird die Nummerierung für Raspberry BCM gesetzt
GPIO.setwarnings(False) #Das verhindert die Ausgabe von Warnhinweisen
#GPIO Modus setzen
GPIO.setup (12,GPIO.OUT) #setzt GPIO 12 auf Ausgang
GPIO.setup (16,GPIO.OUT)
GPIO.setup (20,GPIO.OUT)
GPIO.setup (21,GPIO.OUT)
#Zustand der GPIOS festlegen
GPIO.output (12,True) #setzt GPIO 12 auf High
GPIO.output (16,True)
GPIO.output (20,True)
GPIO.output (21,True)

diesmal habe ich auch ein Bild davon

test

speichern mit STRG+O, Nano mit STRG+X beenden und das Ganze dann mit

sudo python3 gpiohightest.py

einmal angeworfen. Siehe da, die LEDs sind aus

P_20180509_222724_vHDR_Auto.jpg

zurück zum Inhalt

Zwischenfazit

Nachdem ich mir meinen eigenen NAS-Server gebaut habe, ist mein Fhem-Server erneut umgezogen und das Tinkerboard wurde außer-betrieb genommen. Bis zu diesem Zeitpunkt (etwa 6 Monate) kann ich nur Gutes über das Board und ARMbian berichten. Als Fhem-Server halte ich das Board für sehr geeignet. In den meisten Fällen kann man seine Anwendungen problemlos über den Paketmanager installieren und nutzen – man merkt also gar keinen Unterschied. Lediglich bei der Einbindung der Gpios ist, im Gegensatz zum Raspberry/Raspbian, ein wenig Eigeninitiative gefragt. Sicherlich gibt es bei den Systemen weitere markante Unterschiede, jedoch nichts unüberwindbares.

Stand 8/2018 hängt das Board noch an alter Wirkungsstätte  – aber ich habe schon eine Idee für die weitere Nutzung in der Pipeline. Wahrscheinlich wird es auf ein Mediacenter hinauslaufen – aber auch eine Fhem2Fhem Lösung finde ich sehr interessant.

Mein neuer NAS-Server bietet genug Leistung um alles unter einem Dach zu betreiben, daher sehe ich momentan keinen Grund unnötigerweise mehr als einen Server zu betreiben.

zurück zum Inhalt