Raspberry Pi on zefanjas.de - Open Source & Education

Open Source Digital Signage für Schulen

Wed, 03 Apr 2019 03:43:03 +0000

Digital Signage oder „Digitale Beschilderung“ bietet auch für Schulen neue Möglichkeiten. Was früher mit Aushängen an sogenannten „schwarzen Brettern“ oder Informationstafeln gelöst wurde, wird zunehmend von Monitoren übernommen. Egal ob Hinweise zu kommenden Veranstaltungen, Vertretungspläne, Raumbeschilderung oder sonstige wichtige Informationen – vieles lässt sich flexibler auf Monitoren darstellen. Aktualisierungen kann man von zentraler Stelle aus vornehmen bzw. auch automatisieren (z.B. beim Vertretungsplan). Welche Open Source Digital Signage Lösungen gibt es? Was könnten Anforderungen sein, die man als Schule hat? Ich möchte heute einige Lösungen auflisten, die in späteren Artikeln noch einmal genauer beleuchtet werden sollen.

Was sollte ein Digital Signage System können?

Die Anforderungen werden sicher von Schule zu Schule verschieden sein, aber es gibt doch ein paar wesentliche Eigenschaften, die von einer Open Source Digital Signage Lösung erfüllt sein sollten:

einfach zu benutzen (z.B. Editor zum Erstellen von Folien / Slides)
einfache und schnelle Darstellung von Bilder, Videos und anderen Dokumenten
zentrale Verwaltung mehrerer Monitore (am besten mit verschiedenen Gruppen / Kanälen, um verschiedene Informationen auf verschiedenen Monitoren anzeigen zu können)
Möglichkeiten zur Automatisierung / Zeitplan
möglichst kostenfrei (Lizenzen oder monatliche Gebühren)

Welche Open Source Digital Signage Lösungen gibt es?

Wenn man sich nach Open Source Digital Signage Lösungen umschaut, wird man schnell fündig. Allerdings sind viele von den sogenannten „Open Source“ Lösungen eher Freemium – Lösungen bzw. nur teilweise Open Source. Ich habe keine dieser Lösungen bisher selbst im Einsatz gehabt. In den kommenden Monaten werde ich mir aber einige dieser Lösungen anschauen, da wir als Schule noch auf der Suche nach einem passenden Digital Signage System sind.

Screenly OSE

Wenn auf Github nach Digital Signage schaut, ist Screenly OSE mit Abstand das populärste System. Screenly OSE ist für den Raspberry Pi konzipiert. Es bietet grundlegende Features, allerdings muss beim Einsatz mehrerer Geräte, jeder Raspberry Pi einzeln verwaltet werden. Die Unterschiede zur Bezahlversion sind hier aufgelistet.auch

Xibo

Direkt hinter Screenly OSE folgt Xibo, wenn man nach der Anzahl der Sterne auf Github geht. Xibo gibt es schon eine ganze Weile. Im Gegensatz zu Screenly gibt es keine Pro vs. Open Source Version, sondern alle Features sind für alle verfügbar. Xibo besteht aus einem CMS, welches man auch in einem Docker-Container installieren kann und den zugehörigen Player, die auf den Anzeigegeräten selbst installiert werden. Der Player für Windows ist kostenfrei und Open Source, für alle anderen Player müssen Lizenzgebühren bezahlt werden. Es gibt den Xibo Player für Windows, Android und webOS. Ein Player für Linux ist wohl geplant, aber noch nicht verfügbar.

Concerto

Ebenfalls schon länger am Markt ist Concerto. Concerto bietet viele Features und kann selbst gehostet werden. Technisch basiert es auf Ruby. Wenn man sich in dem Projekt auf Github etwas umschaut, scheint die Entwicklung etwas zu stocken. Dem Webinterface sieht man sein Alter auch schon etwas an. Insgesamt aber eine 100% Open Source Lösung.

LibreSignage

LibreSignage ist noch recht neue Open Source Lösung und zu 100%, Browser basiert. Es braucht also keine speziellen „Player“, sondern kann über den Browser benutzt werden. Grundlegende Features und auch Mehrbenutzerbetrieb sind vorhanden.

Foyer

Foyer ist ein WordPress-Plugin. Man kann damit verschiedene Seiten erstellen, Kanäle und verschiedene Displays diesen Kanälen zuweisen. Es ist wie LibreSignage Browser basiert und braucht deshalb keinen besonderen Player.

tabula.info

Tabula.info ist die einzige Lösung, die ich gefunden habe, die speziell für Schulen entwickelt wurde. Es bietet viele nette Features, die in man in einer Schule braucht und ist auf die Anzeige von Vertretungsplänen, HTML-Seiten und zusätzlichen Infos spezialisiert.

Weitere Lösungen

Infobeamer

Infobeamer ist nur für den privaten, nicht öffentlichen Gebrauch kostenfrei. Sonst ist wohl eine der leistungsstärksten und flexibelsten Lösungen. Die Hardware eines Raspberry Pi’s wird maximal ausgenutzt (z.B. Hardwarebeschleunigung – ein Nachteil, den alle Browser basierten Lösungen haben).

Display Monkey

Display Monkey ist ebenfalls eine Open Source Lösung, die allerdings einen Windows Server voraussetzt. Die einzelnen Displays brauchen nur einen Browser.

piSignage

Eine weitere Lösung für Digital Signage ist piSignage. Der Server ist OpenSource und kann auch selbst gehostet werden. Für die einzelnen Displays / Players müssen aber Lizenzen gekauft werden (einmalig). Wie der Name vermuten lässt, verwendet piSignage Raspberry Pi’s als Player. Der Code dafür ist nicht Open Source.

Fazit

Auf den ersten Blick gibt es scheinbar viele Open Source Lösungen. Welche kennst du noch, die hier fehlen? Mit welchem Systemen hast du gute Erfahrungen gemacht? Der Praxistest wird zeigen, welche Lösung für unsere Situation am besten geeignet ist.

Wie man ein mobiles Feinstaubmessgerät bauen kann

Sat, 09 Mar 2019 09:45:29 +0000

Vor ca. einem Jahr habe ich beschrieben, wie man mit einem Raspberry Pi und einem Feinstaubsensor die Luftqualität messen kann. Das Setup setzen wir so seit einigen Jahren bei uns in der Schule bzw. auch privat ein. Einen Nachteil hat dieses Projekt allerdings: es ist nicht mobil, sondern abhängig von einem WLAN-Netz bzw. einer Netzwerkverbindung. Wenn der Raspberry Pi und das Smartphone / ein Rechner nicht im gleichen Netz sind, kann man nicht auf die Messdaten zugreifen. Deshalb haben wir vor einiger Zeit den Raspberry Pi um einen kleinen Bildschirm ergänzt, sodass man die Werte direkt am Gerät ablesen kann. Wie man diesen Bildschirm für unser mobiles Feinstaubmessgerät einrichtet und welche zusätzlichen Konfigurationen notwendig sind, möchte ich in diesem Artikel kurz vorstellen.

Bildschirm für den Raspberry Pi einrichten

Auf Amazon oder AliExpress gibt es verschiedene Displays für den Raspberry Pi. Diese reichen von ePaper-Screens bis hin zu LCDs mit Touchfunktion. Wir haben uns für einen 3,5″ LCD mit Touch entschieden, welcher eine Auflösung von 320×480 Pixel hat (Modell MPI3501). Man kann diesen Bildschirm einfach auf die GPIO Pins stecken. Dazu kostet er gerade mal 10-15€. Schön ist auch, dass er mit 3,5″ genauso groß wie ein Raspberry Pi ist.

Wenn man den Bildschirm aufsteckt und den Raspberry Pi startet, bleibt der Bildschirm weiß. Man muss zuerst noch die passenden Treiber für das Display installieren. Dazu meldet man sich per SSH an und führt folgende Befehle aus:

$ rm -rf LCD-show
$ git clone https://github.com/goodtft/LCD-show.git
$ chmod -R 755 LCD-show
$ cd LCD-show/

Je nach Bildschirmmodell muss man nun den passenden Befehl ausführen um die Treiber zu installieren. In unserem Fall (für das Modell MPI3501):

$ sudo ./LCD35-show

Dieser Befehl installiert die entsprechenden Treiber und startet den Raspberry Pi anschließend neu.

Pixel-Desktop installieren und Autostart einrichten

Damit wir die Website mit den Messwerten direkt beim Start auf dem Bildschirm angezeigt bekommen sind noch einige Schritte notwendig. Zuerst muss man die Pixel-Desktopumgebung installieren (falls man bisher Raspian Lite verwendet hat) mit

$ sudo apt install raspberrypi-ui-mods

Dann fehlt noch der Chromium-Browser, um die Website anzuzeigen:

$ sudo apt install chromium-browser

Standardmäßig ist der Autologin für das Benutzer „pi“ nicht eingerichtet. Dies ist aber notwendig, damit die Messwerte direkt nach dem Start angezeigt werden können, ansonsten begrüßt einen nur der Anmeldebildschirm. Den Autologin kann man über das raspi-config Programm einrichten:

sudo raspi-config

Im Menü wählt man dann 3 Boot Options → B1 Desktop / CLI → B4 Desktop Autologin.

Zu guter Letzt fehlt noch die Einrichtung des Autostarts, damit Chromium nach dem Booten automatisch mit der AQI-Seite gestartet wird. Dazu legt man den Ordner /home/pi/.config/lxsession/LXDE-pi/ an:

$  mkdir -p /home/pi/config/lxsession/LXDE-pi/

Anschließend erstellt man in diesem Ordner die Datei autostart

$ nano /home/pi/.config/lxsession/LXDE-pi/autostart

und fügt diesen Inhalt ein:

#@unclutter
@xset s off
@xset -dpms
@xset s noblank

# Chromium im Vollbild beim Start öffnen
@chromium-browser --incognito --kiosk http://localhost

Möchte man noch den Mauszeiger ausblenden, muss man noch das Paket _unclutter installieren _und am Anfang der autostart das Kommentarzeichen entfernen:

$ sudo apt install unclutter

Da ich im letzten Jahr ein paar kleine Änderungen am Code vorgenommen habe, empfiehlt es sich das Skript und die Dateien der AQI-Website neu herunterzuladen (wie das geht, steht im Originalartikel).

Fazit

Durch das Display hat man nun ein mobiles Feinstaubmessgerät. Wir setzen sie an unserer Schule ein um z.B. die Qualität der Luft in den Klassenzimmern zu überprüfen oder um Vergleichsmessungen durchzuführen. Mit diesem Setup ist man nicht mehr auf eine Netzwerkverbindung oder WLAN angewiesen, sondern kann die kleine Messstation überall einsetzen – mit einer Powerbank sogar noch unabhängig vom Stromnetz.

Wie man Feinstaub mit einem Raspberry Pi messen kann [Update]

Tue, 27 Feb 2018 12:20:56 +0000

Wir messen an unserer Schule regelmäßig den Feinstaubgehalt in der Luft. Besonders zwischen Februar und Mai sind die Werte hier in Süd-Ost Asien sehr hoch, da es in dieser Zeit kaum regnet, es sehr trocken und heiß ist und viele Wiesen und Felder abgebrannt werden. Das alles wirkt sich negativ auf die Qualität der Luft aus. Heute möchte ich zeigen, wie man den Feinstaub mit einem Raspberry Pi messen kann. Doch vorher möchte ich kurz auf die Frage eingehen: Was ist Feinstaub überhaupt und was wollen wir messen?

Was ist Feinstaub?

Ganz grob kann man sagen, dass es sich bei Feinstaub um sehr kleine Partikel / Teilchen in der Luft handelt. Man unterscheidet dabei zwischen PM10 und PM2.5 (Particulate Matter, auch Feststoffteilchen). Bei PM10 handelt es sich dabei um alle Partikel in der Luft, die kleiner als 10µm sind, bei PM2.5 entsprechend alle Teilchen, die kleiner als 2.5µm sind. Je kleiner die Teilchen, also v.a. alles kleiner als 2.5µm, desto gefährlicher sind sie für die Gesundheit, da sie bis in die Lungenbläschen eindringen können.

Die [WHO][1] empfiehlt z.B. folgende Grenzwerte:

Jahresmittel PM₁₀ 20 µg/m³
Jahresmittel PM_2,5 10 µg/m³
Tagesmittel PM₁₀ 50 µg/m³ ohne zulässige Tage, an denen eine Überschreitung möglich ist.
Tagesmittel PM_2,5 25 µg/m³ ohne zulässige Tage, an denen eine Überschreitung möglich ist.

Diese Werte liegen unter den in den meisten Ländern festgelegten Grenzen. In EU ist ein Jahresmittel für PM₁₀ von 40 µg/m³ zulässig.

Was ist der Air Quality Index (AQI)?

Ausgehend von dem Feinstaubgehalt in der Luft kann man den Air Quality Index berechnen. Er gibt an, wie „gut“ oder „schlecht“ die Luft gerade ist. Leider gibt es hier keinen einheitlichen Standard, da verschiedene Länder diesen jeweils anders berechnen oder andere Skalen haben. Der Wikipedia-Artikel zum Air Quality Index liefert dafür einen gute Übersicht. An unserer Schule richten wir uns nach der Einteilung wie sie von der EPA ([United States Environmental Protection Agency][2]) festgelegt wurde.

Soweit ein kurzer Abriss zum Thema Feinstaub und AQI.

Was brauchen wir für die Feinstaubmessung?

Eigentlich braucht es nur zwei Dinge:

einen Raspberry Pi (jedes Modell geht, am besten ein Modell mit WLAN)
Feinstaubsensor SDS011

Das war es schon 🙂 Wer sich für einen Raspberry Pi Zero W entscheidet, benötigt noch ein Adapterkabel auf einen Standard-USB Anschluss, da der Zero nur Micro-USB hat. Den Sensor bekommt man am besten bei Aliexpress. Dort kostet er um die 17-20$. Der Sensor hat eine USB-Adapter für die serielle Schnittstelle mit dabei.

Installation

Für unseren Raspberry Pi laden wir uns das entsprechende Raspbian Lite Image herunter und schreiben es auf die Micro-SD Karte. Dokumentiert ist das z.B. [hier][3]. Auf die Einrichtung der WLAN-Verbindung gehe ich an dieser Stelle nicht ein. Dazu gibt es viele Tutorials im Netz.

Wer nach dem Booten gleich SSH aktiviert haben möchte, muss in der boot-Partition einen leere Datei mit dem Namen ssh anlegen. Die IP des Raspberry Pis bekommt man am besten über den eigenen Router / DHCP Server heraus. Danach kann man sich per SSH anmelden (Standardpasswort ist raspberry):

$ ssh pi@192.168.1.5

~~Für unseren Sensor verwenden wir eine kleines Python-Modul, was uns einiges an Arbeit abnimmt.~~ Dazu müssen wir noch einige Pakete installieren ~~und das Repository auf den Pi klonen~~.

$ sudo apt install python-serial python-enum lighttpd

Alle benötigten Pakete sollten jetzt installiert sein und das Modul für unseren Sensor befindet sich in /home/pi/sds011. Unter /home/pi/sds011/Code/text.py gibt es ein Testprogramm, mit dem man den Sensor testen kann. Bevor wir das Programm aufrufen können, müssen wir noch wissen, an welchem seriellen Port der USB-Adapter steckt. dmesg hilft uns weiter:

$ dmesg
[ 5.559802] usbcore: registered new interface driver usbserial
[ 5.559930] usbcore: registered new interface driver usbserial_generic
[ 5.560049] usbserial: USB Serial support registered for generic
[ 5.569938] usbcore: registered new interface driver ch341
[ 5.570079] usbserial: USB Serial support registered for ch341-uart
[ 5.570217] ch341 1-1.4:1.0: ch341-uart converter detected
[ 5.575686] usb 1-1.4: ch341-uart converter now attached to ttyUSB0

In der letzten Zeile steht unsere Schnittstelle: ttyUSB0. Wir brauchen jetzt noch zwei Dinge: einmal ein kleines Python-Skript, welches die Daten ausliest und in eine JSON-Datei speichert und dann werden wir eine kleine HTML-Seite basteln, die diese Daten ausliest und darstellt.

Daten auf dem Raspberry Pi auslesen [Update]

Wir erstellen zuerst eine Instanz des Sensors und lesen dann alle 5 Minuten für 30 Sekunden den Sensor aus. Diese Werte können natürlich angepasst werden. Zwischen den Messintervallen versetzen wir den Sensor in einen Schlafmodus, um die Lebensdauer zu erhöhen (Lebensdauer beträgt laut Hersteller ca. 8000 Stunden).

[Update, 27.02.2018] Ich habe festgestellt, das meine Python3 Version des Skripts die serielle Schnittstellen nicht ansprechen konnte, z.B. nach einem Reboot. Erst nach mehrmaligem Starten des Skripts konnten dann die Daten gelesen werden. Woran das liegt, habe ich leider nicht herausgefunden, aber mit Python2.7 funktioniert es ohne Probleme. Deshalb hier eine neue Version des Skripts, welche auf Python2.7 basiert.

Im Homeverzeichnis legen wir eine Datei mit dem Namen aqi.py an und kopieren den folgenden Inhalt hinein:

#!/usr/bin/python
# coding=utf-8
# "DATASHEET": http://cl.ly/ekot
# https://gist.github.com/kadamski/92653913a53baf9dd1a8
from __future__ import print_function
import serial, struct, sys, time, json

DEBUG = 0
CMD_MODE = 2
CMD_QUERY_DATA = 4
CMD_DEVICE_ID = 5
CMD_SLEEP = 6
CMD_FIRMWARE = 7
CMD_WORKING_PERIOD = 8
MODE_ACTIVE = 0
MODE_QUERY = 1

ser = serial.Serial()
ser.port = "/dev/ttyUSB0"
ser.baudrate = 9600

ser.open()
ser.flushInput()

byte, data = 0, ""

def dump(d, prefix=''):
    print(prefix + ' '.join(x.encode('hex') for x in d))

def construct_command(cmd, data=[]):
    assert len(data) <= 12
    data += [0,]*(12-len(data))
    checksum = (sum(data)+cmd-2)%256
    ret = "\xaa\xb4" + chr(cmd)
    ret += ''.join(chr(x) for x in data)
    ret += "\xff\xff" + chr(checksum) + "\xab"

    if DEBUG:
        dump(ret, '> ')
    return ret

def process_data(d):
    r = struct.unpack('<HHxxBB', d[2:])
    pm25 = r[0]/10.0
    pm10 = r[1]/10.0
    checksum = sum(ord(v) for v in d[2:8])%256
    return [pm25, pm10]
    #print("PM 2.5: {} μg/m^3  PM 10: {} μg/m^3 CRC={}".format(pm25, pm10, "OK" if (checksum==r[2] and r[3]==0xab) else "NOK"))

def process_version(d):
    r = struct.unpack('<BBBHBB', d[3:])
    checksum = sum(ord(v) for v in d[2:8])%256
    print("Y: {}, M: {}, D: {}, ID: {}, CRC={}".format(r[0], r[1], r[2], hex(r[3]), "OK" if (checksum==r[4] and r[5]==0xab) else "NOK"))

def read_response():
    byte = 0
    while byte != "\xaa":
        byte = ser.read(size=1)

    d = ser.read(size=9)

    if DEBUG:
        dump(d, '< ')
    return byte + d

def cmd_set_mode(mode=MODE_QUERY):
    ser.write(construct_command(CMD_MODE, [0x1, mode]))
    read_response()

def cmd_query_data():
    ser.write(construct_command(CMD_QUERY_DATA))
    d = read_response()
    values = []
    if d[1] == "\xc0":
        values = process_data(d)
    return values

def cmd_set_sleep(sleep=1):
    mode = 0 if sleep else 1
    ser.write(construct_command(CMD_SLEEP, [0x1, mode]))
    read_response()

def cmd_set_working_period(period):
    ser.write(construct_command(CMD_WORKING_PERIOD, [0x1, period]))
    read_response()

def cmd_firmware_ver():
    ser.write(construct_command(CMD_FIRMWARE))
    d = read_response()
    process_version(d)

def cmd_set_id(id):
    id_h = (id>>8) % 256
    id_l = id % 256
    ser.write(construct_command(CMD_DEVICE_ID, [0]*10+[id_l, id_h]))
    read_response()

if __name__ == "__main__":
    while True:
        cmd_set_sleep(0)
        cmd_set_mode(1);
        for t in range(15):
            values = cmd_query_data();
            if values is not None:
                print("PM2.5: ", values[0], ", PM10: ", values[1])
                time.sleep(2)

        # open stored data
        with open('/var/www/html/aqi.json') as json_data:
            data = json.load(json_data)

        # check if length is more than 100 and delete first element
        if len(data) > 100:
            data.pop(0)

        # append new values
        data.append({'pm25': values[0], 'pm10': values[1], 'time': time.strftime("%d.%m.%Y %H:%M:%S")})

        # save it
        with open('/var/www/html/aqi.json', 'w') as outfile:
            json.dump(data, outfile)

        print("Going to sleep for 5min...")
        cmd_set_mode(0);
        cmd_set_sleep()
        time.sleep(300)
```

Schneller geht es mit:

```
$ wget -O /home/pi/aqi.py https://raw.githubusercontent.com/zefanja/aqi/master/python/aqi.py
```

Damit das Skript fehlerfrei durchläuft sind noch zwei kleine Dinge nötig:

```
$ sudo chown pi:pi /var/www/html/
$ echo [] > /var/www/html/aqi.json

```

Nun kann man das Skript starten:

```
$ chmod +x aqi.py
$ ./aqi.py
PM2.5: 55.3 , PM10: 47.5
PM2.5: 55.5 , PM10: 47.7
PM2.5: 55.7 , PM10: 47.8
PM2.5: 53.9 , PM10: 47.6
PM2.5: 53.6 , PM10: 47.4
PM2.5: 54.2 , PM10: 47.3
...
```

### Skript automatisch starten lassen [Update]

Damit wir nicht jedes mal das Skript von Hand starten müssen, können wir es mit einem Cronjob z.B. bei jedem Neustart des Raspberry Pis mit starten lassen. Dazu öffnen wir die crontab-Datei

```
$ crontab -e
```

und ergänzen am Ende die nachfolgende Zeile:

```
@reboot cd /home/pi/ && ./aqi.py
```

Nun startet unser Skript automatisch bei jedem Neustart mit.

### HTML-Seite für Anzeige der Messwerte und AQI

Weiter oben haben wir bereits einen leichtgewichtigen Webserver `lighttpd` installiert. Unsere HTML-, Javascript- und CSS-Datei müssen wir also im Verzeichnis _**/var/www/html/**_ speichern, damit wir von einen anderem Computer / Smartphone auf die Daten zugreifen können. Mit den nächsten drei Befehlen laden wir die entsprechenden Dateien einfach herunter:

```
$ wget -O /var/www/html/index.html https://raw.githubusercontent.com/zefanja/aqi/master/html/index.html
$ wget -O /var/www/html/aqi.js https://raw.githubusercontent.com/zefanja/aqi/master/html/aqi.js
$ wget -O /var/www/html/style.css https://raw.githubusercontent.com/zefanja/aqi/master/html/style.css
```

Die Hauptarbeit findet in der Javascript-Datei statt, die unsere JSON-Datei öffnet, den letzten Wert nimmt und anhand dieses Wertes den AQI berechnet. Dann werden noch die Hintergrundfarben anhand der Skala der EPA angepasst.

Nun man die Adresse des Raspberry Pis einfach im Browser aufrufen und die aktuellen Feinstaubwerte betrachten, z.B. _http://192.168.1.5_:

 

Die Seite ist sehr einfach gestaltet und kann noch erweitert werden, z.B. um eine Grafik, die den Verlauf der letzten Stunden anzeigt usw. Pull Requests sind willkommen 🙂 Der komplette [Quellcode befindet sich auf Github][4].

### Fazit

Für relativ wenig Geld können wir jetzt den Feinstaub mit einem Raspberry Pi messen. Ob draußen fest installiert oder als mobiles Messgerät – Einsatzmöglichkeiten gibt es viele. An unserer Schule haben wir beides im Einsatz. Einerseits einen Sensor der Tag und Nacht die Werte im Freien misst und einen mobilen Sensor, mit dem wir die Effektivität unserer Luftfilter in den Klassenzimmern überprüfen.

So sieht das ganze bei uns in der Schule aus:

 

Unter  gibt es noch eine andere Möglichkeit einen ähnlichen Sensor zu bauen. Da bekommt man die Software bereits fertig geliefert und das Messgerät ist noch mal kompakter, da kein Raspberry Pi verwendet wird. Tolles Projekt!

Ein Feinstaubsensor ist ein Projekt, was sich auch gut mit Schülern im Informatikunterricht oder einer Arbeitsgemeinschaft umsetzen lässt!


  Wofür setzt du einen Raspberry Pi ein?


 [1]: https://de.wikipedia.org/wiki/Feinstaub#WHO
 [2]: https://en.wikipedia.org/wiki/United_States_Environmental_Protection_Agency "United States Environmental Protection Agency"
 [3]: https://www.raspberrypi.org/documentation/installation/installing-images/README.md
 [4]: https://github.com/zefanja/aqi

Kann man einen Computerraum für weniger als 1500€ einrichten? Ja!

Thu, 11 Jan 2018 07:49:33 +0000

Ausgangssituation

Einen Computerraum einzurichten, kann schnell sehr teuer werden. Computer, Monitore, Tastaturen, Kabel, Switche, usw. müssen gekauft werden, um später einen zuverlässigen Computerraum zu haben, der gern genutzt wird. Gerade kleine Schulen und Vereine, welche nur über kleine Budgets verfügen, sind in dieser Hinsicht kaum oder nur schlecht ausgestattet. Auch in Entwicklungsländern und weniger wohlhabenden Teilen der Welt (es ist der größere Teil!) teilen sich statistisch gesehen oft mehrere hundert Schüler einen einzigen Computer – wenn überhaupt. Deshalb möchte ich heute eine Idee vorstellen, wie man einen kompletten Computerraum für verhältnismäßig wenig Geld einrichten kann.

Anforderungen an den Computerraum

Damit ein Computerraum auch von allen genutzt wird, müssen die technischen Hürden sehr gering sein. Auf der anderen Seite, muss sich das System an sich einfach verwalten lassen, ohne das man dafür mehrere Stunden / Woche aufwenden muss.

Aus meiner Sicht sollten folgende (minimale) Anforderungen erfüllt sein:

einfach zu benutzen
schnell einen Soll-Zustand herstellen können
kurze Startzeiten
verlässliche Infrastruktur
keine Viren etc.
wartungsarm

Zutaten

Hardware

Damit wir das gesteckte Ziel von maximal 1500€ erreichen, müssen wir v.a. bei der Hardware „sparen“. Für die meisten Dinge, die Schüler heutzutage in einem Computerraum erledigen, brauchen sie i.d.R. nur einen Browser und evtl. ein Officepaket. Dafür braucht man keine aktuelle leistungsstarke Hardware. Ein Raspberry Pi oder gebrauchte Computer sind da völlig ausreichend.

Wir brauchen:

einen Server: das kann ein 3-7 Jahre alter Rechner sein mit einer größeren Platte (ca. 15-20GB pro Rechner) – z.B. von AfB, ca. 150€
Router (falls nicht schon vorhanden): ca. 20-50€
Switch gebraucht (Gigabit): ca. 50€
Raspberry Pi 3 (Starterkit): 50€
Bildschirm (meist schon vorhanden), sonst ca. 30-50€
Steckdosenleisten, Netzwerkkabel: ca. 100€
Tastatur+Maus: 15-20€

Wenn wir nicht mehr als 1500€ ausgeben wollen, reicht unser Budget für 12 Raspberry Pis. Falls z.B. Bildschirme schon vorhanden sind / gespendet werden, können wir natürlich entsprechend mehr Rechner kaufen.

Software

Gerade für den Raspberry Pi gibt es verschiedene Projekte, die uns die Verwaltung der Rechner sehr leicht machen und auch sehr wartungsarm sind. Schon seit einiger Zeit gibt es das PiNet Projekt, welches speziell für Schulen entwickelt wurde. Es bietet eine zentrale Benutzer- und Speicherverwaltung, d.h. die Kids können sich an jedem Rechner anmelden und können von dort auf ihre Daten zugreifen.

Letzte Woche hat die Raspberry Pi Foundation ein ganz ähnliches Projekt veröffentlicht: PiServer. Es hat ebenfalls den Fokus auf Schulen, aber nicht nur. Auch hier lassen sich Benutzer und Speicher zentral verwalten. Die Raspberry Pis starten hier auch über das Netzwerk und benötigen keine SD-Karte.

Alternativ kann man auch einen Raspberry Pi so einrichten, wie man es möchte und dieses Image dann auf die anderen Rechner verteilen. Ein zentraler Samba-Server dient zum Speichern der Arbeitsergebnisse. Marek hat so eine Lösung in seiner Schule umgesetzt (sogar für weniger als 1500€!).

Vor- und Nachteile

Wie bei jedem Projekt gibt es auch hier Vor- und Nachteile. Oben hatten wir unsere minimalen Voraussetzungen aufgeschrieben. Dazu kommen sicher noch weitere v.a. wenn es an die Auswahl der Software geht. Lernsoftware setzt meist Windows voraus. Vielleicht soll eine andere (rechenintensive) Software verwendet werden für die die Raspberry Pis zu leistungsschwach sind.

Vorteile sind auf jeden Fall:

sehr preisgünstig
stromsparend
platzsparend und leise
wartungsarm

Nachteile könnten sein:

Windows Lernsoftware läuft nicht (da PiNet und PiServer auf Linux setzen)
ungewohntes System für die meisten Kollegen. Der Mensch ist ein Gewohnheitstier – was man nicht kennt, lehnen viele leider erstmal ab. Hier ist sicher Überzeugungsarbeit gefragt und es ist gut, wenn man z.B. eine Einführung oder Fortbildung in das neue System anbietet um Berührungsängste zu nehmen.
Raspberry Pi sind evtl. nicht leistungsstark genug für rechenintensive Anwendungen
Netzwerkschnittstelle des Rapsberry Pi ist nicht sehr schnell (das ändert sich hoffentlich in einer zukünftigen Version)

Fazit

Gerade für Grundschulen, Bibliotheken oder andere (kleine) Vereine, welche Computerarbeitsplätze anbieten wollen, könnte eine Lösung mit Raspberry Pis eine Lösung sein. Für verhältnismäßig wenig Geld kann man ein verlässliches und wartungsarmes System einrichten. Wenn mehr Geld zur Verfügung steht, kann man mit leistungsstärkeren (durchaus gebrauchten) Rechnern auf linuxmuster.net setzen. Mit dieser Lösung hat man noch mehr Möglichkeiten und kann viele Rechner (Ubuntu / Windows) mit relativ wenig Aufwand verwalten.

Setzt du einen Raspberry Pi in der Schule oder im Verein ein? Welche Erfahrungen hast du damit gemacht?

(Beitragsbild CC BY-SA 4.0 by DGately)

Server bei Stromausfall herunterfahren – UPS, NUT & Co

Mon, 27 Nov 2017 22:29:51 +0000

An unserer Schule gibt es immer wieder Stromausfälle. Manchmal dauern sie nur wenige Sekunden, manchmal aber auch mehrere Stunden. Damit unsere IT-Infrakstruktur nicht darunter leidet, haben wir für unsere Server und Netzwerkgeräte eine [UPS/USV][1] installiert. Diese helfen kürzere Stromausfälle (bis zu 1 Stunde) oder Stromschwankungen zu überbrücken. Für alle längeren Ausfälle fahren wir unsere Server automatisch herunter, wenn die UPS ein kritisches Batterielevel erreicht. Dafür nutzen wir NUT ([Network UPS Tools][2]).

Unser Setup besteht aus folgenden Komponenten:

Raspberry Pi als UPS-Server bzw. Master
Liebert GXT4 UPS
Server als Clients bzw. Slaves

UPS / USV in NUT auf dem Raspberry Pi einrichten

Für den Raspberry Pi verwenden wir das Standard [Raspian Stretch Lite Image][3]. Zu beachten ist, dass SSH seit 2016 standardmäßig nicht mehr aktiviert ist. Die verschiedenen Möglichkeiten, wie man SSH wieder aktiveren kann, sind [hier dokumentiert][4]. Nachdem SSH nun wieder aktiviert ist, kann man sich nun auf dem Raspberry Pi einloggen (die IP des Raspberry Pi kann man z.B. mit avahi-browse -ar von einem Rechner im gleichen Netzwerk herausfinden oder man schließt einen Monitor und Tastatur an). Die IP brauchen wir später noch, deshalb ist es sinnvoll dem Raspberry Pi [eine statische IP][5] zu geben.

Als nächstes installieren wir den NUT-Server mit

sudo apt-get install nut-client nut-server usbutils
```

Falls die UPS / USV per USB angeschlossen ist (wie in unserem Fall), kann man mit lsusb überprüfen, ob sie auch erkannt wurde. So sieht die Ausgabe auf dem Raspberry Pi aus:

$ lsusb
Bus 001 Device 004: ID 10af:0000 Liebert Corp. UPS
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter
Bus 001 Device 002: ID 0424:9514 Standard Microsystems Corp. 
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
```

In der ersten Zeile sieht man, dass unsere Liebert UPS erkannt wurde.

Nun müssen wir unsere UPS / USV in der Datei _**/etc/nut/ups.conf**_ konfigurieren. Für unsere UPS sieht der Eintrag folgendermaßen aus:

[gxt4]
     driver = usbhid-ups
     port = auto
     productid = 0000
     desc = "Emerson Liebert GXT 4"
```

Auf der [Website der Network UPS Tools][6] findet man eine Liste mit allen unterstützen UPS /USV und mit welcher Treiber am besten funktioniert.

Als nächstes wollen wir testen, ob die Einstellungen korrekt sind der UPS Daemon mit der UPS kommunizieren kann. Dazu starten wir **upsd** mit sudo upsdrvctl start . Eine erfolgreiche Ausgabe sollte ungefähr so aussehen:

Network UPS Tools - UPS driver controller 2.7.2
Network UPS Tools - Generic HID driver 0.38 (2.7.2)
USB communication driver 0.32
Using subdriver: Belkin HID 0.16
```

NUT enthält einen kleines Programm, mit dem man die Kommunikation mit der UPS /USV testen kann. Es heißt **upsc** und gibt alle lesbaren Parameter der UPS / USV aus.

$ upsc gxt4
Init SSL without certificate database
battery.charge: 100
battery.charge.low: 20
battery.charge.warning: 0
battery.type: PbAc
battery.voltage: 0.0
battery.voltage.nominal: 0.0
device.mfr: Emerson Network Power
device.model: Liebert GXT4
device.serial: 1607000060AFC23
device.type: ups
driver.name: usbhid-ups
driver.parameter.pollfreq: 30
driver.parameter.pollinterval: 2
driver.parameter.port: auto
driver.parameter.productid: 0000
driver.version: 2.7.2
driver.version.data: Belkin HID 0.16
driver.version.internal: 0.38
ups.mfr: Emerson Network Power
ups.model: Liebert GXT4
ups.productid: 0000
ups.serial: 1607000060AFC23
ups.status: OL CHRG
ups.vendorid: 10af
```

Nun ist unsere UPS /USV erfolgreich eingerichtet. Als nächsten richten wir den NUT Server, den UPS Monitor **upsmon** und noch zwei Benutzer für den Master und die Slaves ein.

### NUT Server konfigurieren

In der _**/etc/nut/nut.conf**_ legen wir fest, dass der Raspberry Pi unser Master ist:

MODE=netserver
```

Auf dem NUT-Server läuft der UPS Daemon (**upsd**). Er ist für die (physikalische) Verbindung zur UPS verantwortlich. Die einzelnen Clients/Slaves greifen mit Hilfe des **upsmon** auf den Status der UPS zu. So können mehrere Clients immer über den Zustand der UPS informiert sein und gegebenenfalls das Herunterfahren auslösen, wenn die UPS den Status „On Low Battery“ liefert.

Damit unser NUT Server aus dem Netz erreichbar ist, müssen noch folgende Zeilen in der _**/etc/nut/upsd.conf**_ hinzugefügt werden (IP bitte anpassen):

LISTEN 127.0.0.1
LISTEN 192.168.1.2 #IP des Raspberry Pis
```

Als nächstes legen wir die Benutzer fest mit der sich ein Client beim Master anmelden kann (in der Datei _**/etc/nut/upsd.user**_):

```
[upsmaster]
    password = geheim
    upsmon master

[upsremote]
        password  = geheim
        upsmon slave
```

Damit **upsmon** die UPS auch überwacht, müssen wir nun noch eine letzten Eintrag in der Datei **/etc/nut/upsmon.conf** hinzufügen:

```
MONITOR gxt4@localhost 1 upsmaster geheim master
```

Damit man weiß, ob alle Dienste richtig laufen, kann man den Status des Servers als auch den lokalen Clients auf dem Raspberry Pi (denn der soll ja auch heruntergefahren werden, wenn kein Strom mehr da ist) mit folgendem Befehlen überprüfen:

```
$ sudo systemctl status nut-server
$ sudo systemctl status nut-client
```

Nun ist unser Master fertig eingerichtet und die Clients bzw. Slaves können jetzt konfiguriert werden.

### Clients / Slaves einrichten (z.B. Server, andere Computer)

Zuerst müssen auf einem Client die notwendigen Pakete installiert werden:

```
sudo apt-get install nut-client
```

Diesmal müssen wir nur zwei Dateien editieren. In der _**/etc/nut/nut.conf**_ legen wir den Modus fest:

```
MODE=netclient
```

Danach müssen wir wieder **upsmon** sagen, welche UPS er überwachen soll (in _**/etc/nut/upsmon.conf**_):

```
MONITOR gxt4@192.168.1.2 upsremote geheim slave
```

Die IP und das Passwort müssen natürlich noch angepasst werden. Bitte auch das **slave** am Ende beachten! Zuletzt noch den entsprechenden Service neu starten und überprüfen, ob alles läuft:

$ sudo systemctl restart nut-client
$ sudo systemctl status nut-client
```

Glückwunsch! Nun sollte alles eingerichtet sein, aber wie kann man testen, dass es wirklich funktioniert?

### Herunterfahren testen

Der folgende Befehl löst das Signal zum Herunterfahren aus (wie es auch im Falle eines Stromausfalls sein würde):

```
$ sudo upsmon -c fsd
```

### UPS mit Check_MK überwachen [Update]

#### Check_MK Agent einrichten

Nachdem die UPS jetzt fertig eingerichtet ist, wäre es natürlich toll, wenn wir sie auch im Monitoring überwachen können. Wir nutzen dafür Check\_MK. Clients können in Check\_MK mit dem Check_MK Agenten oder per SNMP überwacht werden. Der Agent ist in den Standard-Paketquellen von Debian und Ubuntu enthalten, weshalb wir ihn einfach mit diesem Befehl auf dem Raspberry Pi installieren können:

```
$ sudo apt-get install check-mk-agent xinetd
```

Standardmäßig ist der Check_MK Agent nicht aktiviert, sodass wir ihn noch in der Datei _**/etc/xinetd.d/check_mk**_ noch aktivieren müssen. Am Ende der Datei muss disable = yes  in disable = no  geändert werden. Wenn man möchte, kann man auch noch den Zugriff einschränken, indem man mit only_from = IP-des-Check-MK-Severs  die Server-IPs einträgt, die die Erlaubnis haben die Daten des Check_MK Agenten abzufragen.

Als nächstes muss xinetd neu gestartet werden. Mit dem zweiten Befehl überprüfen wir, ob der Check_MK Agent richtig konfiguriert ist und läuft (IP anpassen!).

```
$ sudo service xinetd restart
$ telnet 192.168.1.2 6556
```

#### NUT Plugins

Bisher weiß der Check_MK Agent noch nichts von unserer UPS und liest die entsprechenden Daten auch nicht aus. Mit folgendem kleinen Skript können wir die Ausgabe von upsc dem Agenten mitteilen:

```
#!/bin/sh

if which upsc > /dev/null 2>&1 ; then
    echo '<<<nut>>>'
    for ups in $(upsc -l)
    do
        upsc $ups| sed "s,^,$ups ,"
    done
fi
```

Diese kleine Plugin speichern wir unter _**/usr/lib/check\_mk\_agent/plugins/nut**_. Auf dem Raspberry Pi sind wird nun fertig. Es fehlen jetzt noch die Anpassungen auf dem Check_MK Server.

Auf dem Server brauchen wir ein weiteres Skript, welches die Daten des Check_MK Agenten ausliest. Dieses Skript ist umfangreicher, deshalb [verlinke ich es hier][7]. Es muss unter _**/opt/omd/versions/default/share/check_mk/checks/nut**_ gespeichert werden. Das Original-Plugin kann man hier finden: . Ich habe es minimal angepasst für unsere UPS angepasst.

Wenn man nun den Raspberry Pi als neuen Host in Check_MK hizufügt, werden die Services für die UPS / USV mit angezeigt.

 NUT Services 

### Fazit

NUT ist ein [weiteres tolles Open Source Projekt][8], mit dem sehr flexible Anpassungen möglich sind. In [dieser PDF][9] sind noch viele weitere (komplexe) Anwendungsszenarien enthalten. Während ich diesen Artikel schreibe, haben wir wieder einen Stromausfall und alle unsere Server sind zuverlässig heruntergefahren worden!

 

 [1]: https://de.wikipedia.org/wiki/Unterbrechungsfreie_Stromversorgung
 [2]: http://networkupstools.org/
 [3]: https://www.raspberrypi.org/downloads/raspbian/
 [4]: https://www.raspberrypi.org/documentation/remote-access/ssh/
 [5]: http://www.imakeyouintelligent.com/raspberry-raspbian-stretch-static-ip/
 [6]: http://networkupstools.org/stable-hcl.html
 [7]: https://gist.github.com/zefanja/585a96988656f24c507e573042564d8e#file-nut-plugin-server
 [8]: https://zefanjas.de/2017/11/18/5-grossartige-open-source-programme-die-wir-in-unserer-schule-einsetzen/
 [9]: http://rogerprice.org/NUT/ConfigExamples.A5.pdf

Build a Robot #2 – Fernsteuerung mit dem Smartphone

Fri, 20 Dec 2013 13:28:39 +0000

Heute soll es uns um die Steuerung des kleinen Roboters mit einem Smartphone/Tablet gehen. Dabei soll die Fernsteuerung möglichst plattform-unabhängig sein. Aus diesem Grund habe ich mich für eine einfache Website entschieden, welche die Daten des [Gyroskop][1] ausliest und entsprechende Befehle an den Roboter schickt.

Die Serverseite

Ich habe in den letzten Jahren viel mit Javascript programmiert und aus diesem Grund habe ich mich für eine [nodejs][2] basierte Lösung entschieden. Javascript ist für die Steuerung von GPIOs eigentlich nicht wirklich geeignet (single threading, Latenzen, …), aber für das An- und Ausschalten von Motoren passt es ganz gut.

Zuerst sollte man also nodejs auf dem Raspberry Pi installieren. Da die Version in den Repositories nicht gerade aktuell ist, kann man sich manuell ein compiliertes Paket direkt bei nodejs downloaden. Die Installation ist in [diesem Artikel][3] ganz gut beschrieben.

Bei Github findet man verschiedene Pakete für die Ansteuerung der GPIOs. Ich habe mich für node-rpio entschieden, da die API der Python-API entspricht, die wir im letzten Beitrag verwendet haben. Weiterhin ist die API synchron, was in unserem Fall sinnvoll ist, da wir sonst mit vielen vielen Callbacks zu tun hätten 😉 Um node-rpio zu nutzen, muss es noch compiliert werden. Dazu gibt man einfach den Befehle

npm install -g node-gyp
node-gyp rebuild

ein, nachdem man das Github-Repo geklont hat. Nun ist alles fertig, um die Motoren über nodejs zu steuern. Da die API gleich ist, können wir im Prinzip den Quelltext aus dem letzten Beitrag nehmen und nur ein klein wenig anpassen:

var gpio = require("./node-rpio/lib/rpio");

//Setup GPIO Pins
gpio.setmode(gpio.BOARD);
gpio.setup(13, gpio.OUT);
gpio.setup(15, gpio.OUT);
gpio.setup(16, gpio.OUT);
gpio.setup(18, gpio.OUT);

gpio.output(13, 1);
gpio.output(15, 0);
gpio.output(16, 1);
gpio.output(18, 0);

process.on('SIGINT', function() {
    console.log("\nGracefully shutting down from SIGINT (Ctrl+C)");
    //Cleanup
    gpio.cleanup();
    process.exit();
});
```

Der letzte Teil dient dazu, dass man mit Ctrl+C das Skript abbrechen kann, denn sonst würden die Motoren ständig weiterdrehen.

Ok, jetzt können wir zwar die Motoren ansteuern, aber nur direkt am Raspberry Pi. Die Verbindung zum Smartphone fehlt noch. [Socket.io][4] ist ein großartiges Projekt, welches eine direkte Verbindung über webSockets zwischen Server und Client ermöglicht. Man kann Daten sehr einfach hin- und herschicken und eigene Ereignisse definieren, auf die dann der Server bzw. Client reagieren kann. Was wir brauchen ist nun eine HTML-Datei, welche den Gyroskop ausliest und die entsprechenden Befehle an den nodejs Server sendet, welche dieser dann verarbeitet:



Als nächstes wird der nodejs Server mit

```
sudo node robot.js
```

gestartet. Nun muss man nur noch die Adresse: _http://IP-des-Raspberry-Pi_ aufrufen und schon kann man den Roboter mit einem Smartphone oder Tablet steuern.

### Stromversorgung und Wlan

Es gibt nur noch ein Problem. Der Rapsberry Pi hängt bisher noch an zwei Kabeln: dem Netzwerkkabel und dem USB-Kabel für die Stromversorgung. Für beiden gibt es Lösungen. Das Netzwerkkabel habe ich durch einen Wlan-USB Dongle ersetzt. Wie man diesen einrichtet und welchen man kaufen sollte, findet man in [diesem Artikel][5].

Das verbleibende USB-Kabel habe ich einfach durch ein mobiles USB-Ladegerät ersetzt, welches man für wenig Geld zu kaufen bekommt. Diese liefern die benötigen 5V. Man sollte darauf achten, dass sie neben den 5V auch mindestens 1A liefern, ansonsten wird der Raspberry Pi nicht starten.

Und so sieht das ganze jetzt aus 😉

[][6] [][7]Ich werde in den nächsten Tagen noch ein ein Video machen…

Wie geht es jetzt weiter? Die Steuerung muss noch verbessert werden. Gerade das Lenken ist noch ungenau und das Fahren somit etwas schwierig. Ein weiteres Ziel ist, mit Hilfe eines Ultraschall-Sensors dem Roboter das autonome Fahren beizubringen.

Bisherige Artikel

  * [Build a Robot #0][8]
  * [Build a Robot #1][9]

 

 [1]: http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CCoQFjAA&url=http%3A%2F%2Fde.wikipedia.org%2Fwiki%2FKreiselinstrument&ei=_Ta0Uvj5FomQrQfdsICoAg&usg=AFQjCNEHAKMqVWmSUSBdCNu9kxia2kbt6w&sig2=KMKcBikD9QcDjF387qaMQg&bvm=bv.58187178,d.bmk
 [2]: http://nodejs.org/
 [3]: http://thefloppydisk.wordpress.com/2013/03/08/server-side-javascript-on-a-raspberry-pi-how-to-install-node-js/
 [4]: http://socket.io
 [5]: http://www.howtogeek.com/167425/how-to-setup-wi-fi-on-your-raspberry-pi-via-the-command-line/
 [6]: http://zefanjas.de/wp-content/uploads/2013/12/IMG_0815.geaendert.jpg
 [7]: http://zefanjas.de/wp-content/uploads/2013/12/IMG_0817.geaendert.jpg
 [8]: http://zefanjas.de/2013/12/18/build-a-robot-0-ziele-und-material/
 [9]: http://zefanjas.de/2013/12/18/build-a-robot-1-motoren-ansteuern/