Archiv der Kategorie: IoT

(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 7)

Theorie zur Langzeitspeicherung von Wetterdaten

Wie im letzten Teil 6 beschrieben, werden die Daten des Chart-Nodes nur zur Laufzeit des Dashboards im Node gespeichert. Nach einem Neustart des Raspberry sind die Daten weg und bauen sich nach den Einstellungen des Nodes erst wieder auf. Nun gibt es einige Überlegungen, die das Speichern dieser Daten auch auf lange Sicht gewährleistet.

  1. Speichern der Chart-Node-Daten in eine oder mehrere Dateien wie z.B. CSV.
  2. Speichern der ankommenden Daten in einer SQL-Datei, wie z.B. MySQL.
  3. Speichern der ankommenden Daten in einer Round-Robin-Datenbank (RRD), wie z.B. RRDtool von Tobias Oetiker.
  4. Speichern der ankommenden Daten in einer weiteren Version einer RRD, wie z.B. InfluxDB.

Alle genannten Methoden haben für sich gesehen einen gewissen Charme, ihre Vorteile und aber auch ihre Nachteile.

Zu 1.

Das Speichern der Daten aus dem Chart-Node macht vielleicht dann Sinn, wenn man es einmal macht und die Daten hinterher für irgendwelche anderen Zwecke weiter verwendet. Die Ausgabe in eine Datei oder in eine Datenbank ist ohne Zweifel möglich, aber für meine weiteren Überlegungen sinnlos.

Zu 2.

Ja, die ankommen Daten können im Nodered in einen Chart-Node geschoben werden und parallel dazu in eine SQL-Datenbank. Bei der SQL-Datenbank hat man sogar die Freiheit sich seine eigene Datenbank aufzubauen, wie auch die Struktur der Tabellen. Beim Wegschreiben der Daten gibt es zunächst keine Probleme. Problematisch wird es allerdings, wenn man eine Abfrage gestaltet.

Dazu ein Beispiel:
Alle zwei Minuten kommen Daten aus meiner Wetterstation. Das bedeutet, Nodered erzeugt alle zwei Minuten einen Datensatz, der zwar im Moment nur aus der Temperatur besteht, aber auch weitere Felder haben könnte. Z.B. Luftfeuchte, Luftdruck, Windgeschwindigkeit, Windrichtung, Lichtdauer und was einem noch so alles einfällt.

So entstehen im Laufe eines Tages 30 x 24 = 720 Datensätze, pro Woche dann schon 5.040 Datensätze. Im Jahr werden somit 262.080 Datensätze erzeugt. Der kleine Raspberry Pi muss dann z.B. in einer Jahresübersicht 262.080 Daten in den Chart-Node schicken. Die Abfrag ginge vielleicht noch recht schnell, aber das Auffüllen des Knoten könnte schon mal 5 Minuten und mehr benötigen. Außerdem ist es noch abhängig vom Speicher des Raspberry, der in älteren Versionen schnell zugestopft wird.

Eine andere Methode wäre die Aufbereitung von z.B einem Stundenmittel. Dabei würden alle 30 Werte einer Stunde zu einem Mittelwert gebildet, was in einer Jahresübersicht durchaus gefällig ist. Dann wären statt der 262.080 Datensätze nur noch 52w x 7d x 24h = 8.736 Datensätze zu berücksichtigen. Man kann sich schnell ausmalen, welchen Vorteil dies mit sich bringt. Besonders beim Vergleich über Monate oder Jahre hinweg, könnte man alle diese Daten mitteln und diese Mittelwerte in weitere Tabellen einer Datenbank speichern.

Da sind dann die SQL-Programmierer, so wie ich, wieder gefragt, die z.B. über Stored Procedures o.ä. diese Berechnungen fortwährend durchführen. Der Aufwand ist mir aber ehrlich gesagt zu hoch.

Und sowas gibt es schon fertig und bringt mich weiter zu 3.

Zu 3.

Die Round Robin Datenbank RRDtool macht genau das, wie zu 2. in den letzten Absätzen geschrieben. Die Datenbank wird im Vorfeld konstruiert. Dabei werden die zyklischen Abstände und die Anzahl der Messpunkte pro Zyklus definiert. Beim Ankommen der Daten, werden nicht nur die aktuellen Werte oder die Durchschnittswerte auf Basis der Konfiguration verarbeitet, sondern auch gleich die korrekte Zeit mitgegeben. Diese Datenbank ist dann in ihrer Eigenschaft fest eingestellt und kann nachträglich nur sehr umständlich verändert werden. Wenn überhaupt, ich hab’s noch nicht gemacht oder versucht.

Die Ausgabe der Daten erfolgt dann als Grafiken, die mit einem Skript erzeugt werden und als Datei im Filesystem des Raspberry abgelegt werden. Sinnvollerweise macht man das z.B. in einem Verzeichnis, das über einen Webservice (z.B. Apache mit PHP-Skripts) im Raspberry in einem Browser beim Client dargestellt wird. Das hat dann mit dem Nodered Dashboard eher weniger zu tun.

Vorteil:
Die Datei, die die Datenbank beinhaltet (z.B. wetter.rrd) hat immer die selbe Größe. Daten, die aus einem Zyklus herausfallen, z.B. nach einer Woche, werden nach draußen geschoben, um den neuen Datensatz zu speichern.

Nachteil
Eine dynamische Bedienung ist nicht möglich. Ausgabe nur auf Grafikdateien möglich (.PNG, .JPG).

Zu 4.

Aus all den vorangegangenen Überlegungen, komme ich somit nun zu einer ganz anderen Lösung, nämlich eine Kombination aus allen Vorteilen. In aller Munde ist momentan (2019) der Einsatz eines kostenlosen Trios, erhältlich im Internet:

  • NodeRed
  • InfluxDB
  • Grafana

Hier wird Nodered lediglich als Plattform zur Übermittlung der Daten an die InfluxDB Datenbank genutzt. Das Dashboard mit seinen Nodes von NodeRed wird hier nicht mehr benutzt, sondern Grafana.

  1. ist Nodered dafür wie geschaffen mit Hilfe seine Knoten Daten zu empfangen, zu verarbeiten und weiter zu geben.
  2. bietet InfluxDB als weiter entwickelte sog. Timeline Datenbank wie die Round Robin Datenbank alle erforderlichen Mechanismen wie bei den RRDtools an und
  3. liefert Grafana ein Dashboard mit allen Möglichkeiten zur Darstellung von Werten in bestimmten Zeitfenstern, Perioden oder sonstigen Formen an, die um einiges flexibler sind in ihrer Gestaltung, Darstellung und Bedienung als das Nodered Dashboard.

 

Die Praxis zur Langzeitspeicherung von Wetterdaten

Ich entscheide mich somit für meine weitere Entwicklung meiner kleinen Wetterstation für genau diese Konstellation von Werkzeugen.

Vorbereitung

Es kann nicht schaden das Betriebssystem des Raspberry auf den neuesten Stand zu bringen:

$ sudo apt update
$ sudo apt upgrade
$ sudo reboot

Installation NodeRed

Diese Installation wurde schon beschrieben. Hier ist nichts weiter mehr erforderlich.

 

Installation InfluxDB

Download vom Internet und Installation

Die nachfolgenden Aktivitäten beschreiben die Erweiterung des Repos im Raspberry, die Installation und die Konfiguration zum automatischen Start beim Booten des Raspberry.

$ curl -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add -

$ echo "deb https://repos.influxdata.com/debian stretch stable" | sudo tee /etc/apt/sources.list.d/influxdb.list

$ sudo apt update

$ sudo apt install influxdb

$ sudo systemctl enable influxdb

$ sudo systemctl start influxdb

Einrichten InfluxDB

Nun richte ich mir erstmal einen Benutzer dafür ein.

$ influx
> CREATE USER "pi" WITH PASSWORD 'raspberry' WITH ALL PRIVILEGES
> show users
user admin
---- -----
pi   true
> quit
$

Anpassen der Umgebung

Die Datei /etc/influxdb.conf muss nun noch angepasst werden, In der Sektion [http] sind die Zeilen zu finden, bei denen im Grunde nur die Raute # entfernt werden muss. Ich benutze dafür meinen Midnight Commander und rufe ihn mit sudo mc auf, navigiere auf die Datei und prüfe die folgenden Einträge:

[http]
enabled = true
bind-address = ":8086"
auth-enabled = true

Wenn man nun in einem Browser die Adresse des Raspberry mit der Portadresse der Datenbank http://raspberry-pi:8086 eingibt, sollte eine Meldung 404 page not found erscheinen. Das ist richtig so, weil noch kein Seite angelegt ist. Alles andere deutet auf eine falsche Installation hin.

 

Installation Grafana

Am besten schaut man direkt bei Grafana vorbei und holt sich die aktuelle Installation für seine Rechner-Plattform. Zu diesem Zeitpunkt hat Grafana speziell für den Raspberry eine Installation der Version 6.4.3 veröffentlicht, die ich von dieser Webseite aufrufe: https://grafana.com/grafana/download?platform=arm

Dort steht unter Ubuntu & Debian (ARMv6) die Vorgehensweise zur Installation

$ wget https://dl.grafana.com/oss/release/grafana-rpi_6.4.3_armhf.deb
$ sudo dpkg -i grafana-rpi_6.4.3_armhf.deb

Bei dieser Installation gibt es eine Meldung, dass eine Abhängigkeit nicht vorhanden ist und deswegen die Installation abgebrochen ist. Diese Abhängigkeit installiere ich nach:

$ sudo apt install libfontconfig

und beende die unfertige Installation mit

$ sudo apt --fix-broken install

Nun wird der Dienst in das System eingebunden

$ sudo systemctl daemon-reload
$ sudo systemctl enable grafana-server
$ sudo systemctl start grafana-server

Wenn alles korrekt durchgelaufen ist, sollte nun in einem Browser Grafana aufrufbar sein, Grafana benutzt den Port 3000 zur Kommunikation. Also: http://raspberry-pi:3000. In der nachfolgenden Anmeldung wird der Standardbenutzer admin mit Kennwort admin eingetragen.

In den weiteren Schritten werde ich nun meine Datenquellen, also die Sensoren einrichten und die gelieferten Daten abholen, speichern und zur Anzeige bringen.

Im Übrigen benutze ich immer noch den Raspberry Pi 2 mit Raspbian 9 (Stretch)!

(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 6)

Sensoren

Temperatur mit dem DS18B20

Aus dem Internet habe ich mir seinerzeit ein paar Temperatursensoren vom Typ Dallas (Maxim) DS18B20 beschafft. Der Stückpreis für einen solchen Sensor liegt mittlerweile weit unter 1 Euro. Der Vorteil dieses Sensors ist, dass er mit dem I2C-Protokoll angesprochen werden kann. Somit kann er mit einem Raspberry Pi direkt kommunizieren. D.h. man stellt ein Anfrage an das Device und man erhält eine Antwort. In diesem Fall die Temperatur des Gerätes. Die Kommunikation findet dabei von Haus aus über den GPIO 4 des Raspberry statt und kann im Grunde direkt angeschlossen werden.

Um aber keinen unkontrollierten Datenwust auf der Leitung zu bilden, benötigt der Daten-Pin GPIO 4 einen Pull-Up-Widerstand von irgendwas zwischen 1 und 47 kOhm gegen VDD (3,3V). Da es sich bei dem I2C-Anschluss um einen sog. Bus handelt, können an dieser Leitung mehrere Devices unabhängig voneinander angeschlossen werden. Sie unterscheiden sich voneinander erstmal in ihrer I2C-Bus-Nummer. Der DS18B20 hat zudem noch eine eigene Seriennummer, die über den Bus mit ausgeliefert wird. Dadurch kann man jeden einzelnen Sensor direkt mit seiner individuellen ID ansprechen und bestimmte Ausgaben zuordnen.

Der DS18B20 ist in einem TO-92-Gehäuse untergebracht und sieht demnach aus wie ein kleiner Transistor. Hier ein Bild mit der Pin-Belegung:

DQ ist dabei die Datenleitung, VDD ist die Stromversorgung 3,3V und GND eben die Masse (0V). Die nachfolgenden Anschluss-Bilder habe ich bei instructables.com ausgeliehen.

Single Anschluss DS18B20

 

Multipler Anschluss DS18B20

Natürlich nimmt man die Verkabelung im stromlosen Zustand des Raspberry vor. Nach dem Neustart des Raspberry kann man an der Konsole das Vorhandensein des Sensors abfragen.

Der DS18B20 Sensor mit der ID 28-00000756f09e ist somit ordentlich erkannt.

Nun braucht man natürlich noch eine Software zur Kommunikation mit dem Sensor. Nodered kann dafür einen zusätzlichen Knoten bereit stellen. Über den Paletten-Manager im Nodered wird das Modul node-red-contrib-sensor-ds18b20 dazu nachinstalliert. Bitte auf die Schreibweise achten, es gibt auch andere Nodes, die ähnlich geschrieben werden.

Nach der Installation ist in der Palette der Node zu sehen.

In der Node-Liste Raspberry Pi taucht nun auch der Knoten zur weiteren Verwendung auf:

Ich brauche diesen Node zweimal auf meinem Flow und schiebe dazu noch einen Chart- und einen Gauge-Node auf den Flow. Jetzt verbinde ich den ersten Sensor-Node mit dem Chart-Node und den zweiten Sensor-Node mit dem Gauge-Node.
Mit jeweils Doppelklick auf die Nodes öffnen sich die Eigenschaften. Beim Sensor-Node werden in einer Dropdown-Liste alle verfügbaren DS18B20-Sensoren angezeigt. Im ersten Node setze ich eine 300-Sekunden-Abfrage an meinen Sensor. Die zurückgegebene Temperatur wird dann im Chart-Node ausgegeben.

Einstellung des ersten Sensor-Nodes

 

Einstellung des Chart-Nodes

Nun die Einstellungen für den zweiten Sensor-Node und der verbundene Gauge-Node.

 

 

Einstellung des zweiten Sensor-Node

 

Einstellung des Gauge-Node

 

Mit dem Klick auf Deploy wird dieser Flow nun generiert und veröffentlicht.

Das sieht dann nach 7 Tagen Laufzeit in etwa so aus:

Dabei aktualisiert der Temperatur-Zeiger alle 10 Sekunden und die Temperatur-Kurve alle 5 Minuten.

Das sieht nun schon recht fluffig aus. Jedoch werden die Daten im Chart-Node nur solange zwischengespeichert, wie der kleine Rechner läuft. Nach jedem Neustart des Raspberry Pi beginnt der Node mit leeren Daten und füllt das Chart alle 5 Minuten mit einem neuen Wert auf.

Also wieder 7 Tage warten? Nicht doch… Das führt mich nun dahin, dass ich solche Daten in einer Datenbank ablege und nach Bedarf eine Darstellung von aktuellen sowie historischen Daten generiere. Wie man das macht erkläre ich im nächsten Teil 7 (m)einer kleinen Wetterstation.

Andere Sensoren

Der Vollständigkeit halber: Es gibt für den schmalen Geldbeutel eine Menge weiterer Sensoren und Aktoren für die unterschiedlichsten Anwendungen. Eine Übersicht findet man im Internet z.B. auf dieser Seite https://tutorials-raspberrypi.de/raspberry-pi-sensoren-uebersicht-die-50-wichtigsten-module/

 

(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 5)

Vorbereitung für die Ausgabe der Daten

Node-Red Sicherheit

Sobald die Wetterstation aus dem lokalen Netzwerk auch im Internet erreichbar ist, kann jeder, der die IP-Adresse kennt und Zugriff auf den Port hat, die Bedienoberfläche erreichen und alle Veränderungen in meinen Programmierungen vornehmen, die er möchte. Damit das nicht passiert, sichere ich den Zugang mit einem Benutzernamen und Kennwort ab. Beschrieben wird der Vorgang auf der Seite Node-RED : Security unter diesem Link: https://nodered.org/docs/security Die erforderliche Einstellung dazu wird in der Datei ~/.node-red/settings.js vorgenommen. Zusätzlich habe ich dazu Tool node-red-admin installiert. Das ist übrigens auf der Seite Node-Red : Command-line Administration unter diesem Link beschrieben: https://nodered.org/docs/node-red-admin.

Raspberry Pi aus dem Internet erreichbar

In meinem Router gebe ich für den Raspberry Pi den (Standard-) Port 1880 frei. Nach einem Neustart von Node-Red mit

node-red-stop
node-red-start

oder Neustart des Raspberry Pi ist der Zugang zur Entwicklungsoberfläche aus dem Internet nun über diesen Link erreichbar: dl8aap.ddns.net:1880. Wie man eine solche DynDNS-Adresse einrichtet. steht in vielen Beiträgen im Internet und soll nicht Bestandteil meiner Aufbaubeschreibung sein.

Installation Node-Red-Dashboard

Damit Daten auf einer Webseite im Internet dargestellt werden können, muss das Node-Red-Dashboard nachinstalliert werden.

Ich melde mich mit meinen Zugangsdaten an der Entwicklungsoberfläche an und installiere das Dashboard über den Paletten-Manager:

Über die Seite Palette wähle ich den Tab Install (1) und suche nach dashboard (2). Ich wähle den Eintrag node-red-dashboard und klicke auf den kleinen Button install (3). Das dauert nun eine Weile, bis der Button Close erscheint. 

Mit Close (4) schließe ich den Palettenmanager, und es stehen jetzt die Dashboard-Elemente zur weiteren Verwendung zur Verfügung. Im Grunde sind dies alles Elemente, die zur Darstellung auf (m)einer Internetseite benutzt werden können. Es stehen einige Tausend Nodes zum Download bereit. Es dürfen auch eigene Nodes erstellt werden.

Bei jeder Änderung wechselt der Button Deploy auf rot.

Mit einem Klick auf Deploy (1) werden dann die Änderungen gespeichert und übernommen und die neue Ausgabe erzeugt. Diese Ausgabe kann ich mir anschauen mit Klicken auf das Grafik-Symbol (2) und auf das Link-Symbol (3).

Da ich noch keine Elemente (UI nodes) hinterlegt bzw. programmiert habe, begrüßt mich Node-Red entsprechend und weist mich freundlich darauf hin noch einige Elemente in einen Flow hinzuzufügen und auszuliefern.

Der erste Flow

Ein erster Test könnte so aussehen:

Aufgabe: Gib mir jede Sekunde die aktuelle Rechnerzeit aus.

Lösung: Dazu platziere ich einen inject-node und einen debug-node auf die Arbeitsoberfläche und verbinde die beiden Nodes.

Ich öffne mit einem Doppelklick den inject-node. Im Edit-Fenster ändere ich den Repeat-Modus auf interval und stelle auf every 1 seconds. Die blauen Punkte zeigen an, dass eine Veränderung an diesem Knoten vorgenommen, aber noch nicht gespeichert wurde. Ein Klick auf Done, und der Node ist programmiert. 

Der debug-node ist schon passend vorbereitet, um eine Nachrichtenladung msg.payload vom inject-node im Debugfenster darzustellen.

Mit einem Klick auf Deploy wird dieser kleine Flow 1 gespeichert und ausgeliefert.

Jetzt erscheint im Debug-Fenster jede Sekunde die Ausgabe der aktuellen Rechnerzeit. Aber 1536668952289? Das ist die Unix-Zeit in Tausendstel Sekunden beginnend mit 1.1.1970 00:00 Uhr, die im Raspberry Pi läuft. Umgerechnet ist das 11.09.2018 14:32:03.289 Uhr.

 

Test des Internet-Dashboard

Aufgabe: Gib mir alle 7 Sekunden den Rückgabewert eines Internet-Ping von www.google.de und zeige den aktuellen Wert in einem Gauge-Knoten, sowie die Werte der letzten 12 Stunden in einer Liniengrafik auf dem Dashboard (für das Internet).

Lösung: Zunächst muss eine Oberfläche für das Dashboard vorbereitet werden. Node-Red weiß sonst nicht, wohin es die Elemente platzieren soll.

In der Sektion dashboard den Tab Layout wählen. Nun den Button +tab klicken. Damit wird quasi eine neue Seite erzeugt. Hinter diesem neuen Tab 1 kann man mit edit die Eigenschaften dieses Tabs anpassen. Ich wähle den Namen Home und bestätige dies mit Klick auf Update. Hinter dem neuen Home-Tab klicke ich auf +group. Es wird eine quasi eine Matrix für die neue Seite angelegt. Hierauf können die Ausgabe-Knoten ausgerichtet werden.

Jetzt platziere ich die notwendigen Nodes. Ein Ping-Node, ein Gauge-Node und ein Chart-Node und verbinde sie untereinander.

Doppelklick auf den Ping-Node öffnet den Edit-Modus. Hinter Target gebe ich ein: www.google.de. Hinter Ping (S) gebe ich ein: 7 und bestätige mit Done. Dieser Knoten sendet einen Internet-Ping alle 7 Sekunden an Google.de

Doppelklick auf den Gauge-Node öffnet den Edit-Modus. Hinter Group wähle ich aus der Auswahlbox den Eintrag Group 1 [Home]. Damit wird dieses Element auf die zuvor erzeugte Matrix gesetzt. Hinter Units gebe ich ein: ms, weil der Ping seine Nachrichtenladung in Millisekunden übergibt. Die Range bestimme ich mit min=0 und max=300. Bestätigung mit Done.

Doppelklick auf den Chart-Node öffnet den Edit-Modus. Hinter Group wähle ich aus der Auswahlbox den Eintrag Group 1 [Home]. Damit wird dieses Element ebenfalls auf die zuvor erzeugte Matrix gesetzt. Hinter x-axis gebe ich ein: last 12 hours. Hinter Y-axis gebe ich für min=0 und max=300 ein. Bestätigung mit Done.

Nun den Flow mit Deploy ausliefern und das fertige Ergebnis über das Link-Symbol anschauen.

Die Aufgabe ist somit erfüllt, das Dashboard funktioniert zur vollen Zufriedenheit.

Node-Red bietet die Möglichkeit den entwickelten Flow zu Speichern bzw. als Backup auszugeben. Das geht über den Menü-Button, Export und Clipboard. Der Flow wird damit in die Zwischenablage exportiert.

Über die Funktion Import kann so ein vollständiger Flow z.B. von Dritten oder aus einem Backup importiert werden.

In der folgenden Box ist das “Skript” für den obigen Flow enthalten. Per Copy & Paste kann der Flow importiert werden.

[{"id":"7f2aead6.b4c26c","type":"tab","label":"Flow 1","disabled":false,"info":""},{"id":"2886ee67.f5ad1a","type":"ping","z":"7f2aead6.b4c26c","name":"","host":"www.google.de","timer":"7","x":170,"y":120,"wires":[["6b9edf2f.a2da28","65f085df.5a9574"]]},{"id":"6b9edf2f.a2da28","type":"ui_gauge","z":"7f2aead6.b4c26c","name":"","group":"80e206a9.0b295","order":0,"width":0,"height":0,"gtype":"gage","title":"gauge","label":"ms","format":"{{value}}","min":0,"max":"300","colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","x":350,"y":100,"wires":[]},{"id":"65f085df.5a9574","type":"ui_chart","z":"7f2aead6.b4c26c","name":"","group":"80e206a9.0b295","order":0,"width":0,"height":0,"label":"chart","chartType":"line","legend":"false","xformat":"HH:mm:ss","interpolate":"linear","nodata":"","dot":false,"ymin":"0","ymax":"300","removeOlder":"12","removeOlderPoints":"","removeOlderUnit":"3600","cutout":0,"useOneColor":false,"colors":["#1f77b4","#aec7e8","#ff7f0e","#2ca02c","#98df8a","#d62728","#ff9896","#9467bd","#c5b0d5"],"useOldStyle":false,"x":350,"y":140,"wires":[[],[]]},{"id":"80e206a9.0b295","type":"ui_group","z":"","name":"Group 1","tab":"898387fe.649cd8","order":1,"disp":true,"width":"6","collapse":false},{"id":"898387fe.649cd8","type":"ui_tab","z":"","name":"Home","icon":"dashboard","order":1}]

Für alle weiteren Aktivitäten mit Node-Red empfehle ich das Studium des Node-Red Kochbuchs hinter diesem Link: https://cookbook.nodered.org/

Im Internet finden sich auch eine Menge Beiträge, die die unterschiedlichsten Themen zum Node-Red behandeln. Auch ich bin hier für ein paar spezielle Dinge schnell fündig geworden, die ich im weiteren Verlauf meines Installationsberichtes gerne weitergebe.

Ich denke es ist nun an der Zeit mit meiner Beschreibung im Teil 6 mit der Auswahl der passenden Sensoren am Raspberry Pi und die Verbindung mit dem Node-Red fortzufahren.

 

 

(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 4)

Weitere Grundkonfiguration des Raspberry Pi

Der Löwenanteil von Software ist auf dem Raspberry Pi nun erstmal vorinstalliert. Jedoch soll noch die IP-Adresse des Gerätes festgelegt werden. Eigentlich ist das nicht nötig, aber ich möchte das Gerät später in einer anderen Umgebung betreiben, in der ausschließlich mit festen IP-Adressen gearbeitet wird.

Festlegen der statischen IP-Adresse

Die Einstellung findet statt in der Datei /etc/dhcpcd.conf. Vorher aber muss man sich den Namen der momentanen Schnittstelle ausgeben lassen. Das passiert mit der Eingabe von 

ifconfig

Das Ergebnis sieht dann in etwa so aus:

Kenner haben nun gesehen, dass es die altbekannte Bezeichnung eth0 nicht mehr gibt. Dafür gibt es nun eine eindeutige Zuordnung der Bezeichnung, beginnend mit enx und nachfolgend der MAC-Adresse der Schnittstelle, hier rot umrandet. Diese Bezeichnung merke ich mir und werde sie gleich in die Datei /etc/dhcpcd.conf zur weiteren Bearbeitung eintragen.
Warum es keine eth0-Bezeichnung mehr geben soll, oder wie man das System wieder in diese Form versetzen kann, ist ausführlich an anderen Stellen im Internet beschrieben.

Ich starte den Midnight Commander mit sudo mc und editiere die Datei /etc/dhcpcd.conf.

Weiter unten In den letzten Zeilen finde ich den Eintrag # Example static IP configuration und setze die vier Zeilen dadrunter wie folgt:

# Example static IP configuration:
interface enxb827eb2e9d7f
static ip_address=192.168.80.80/24
static routers=192.168.80.200
static domain_name_servers=8.8.8.8 8.8.4.4 192.168.80.200

Alles andere bleibt erstmal so wie es ist.

Ich setze die IPv4-Adresse nun fest auf 192.168.80.80 mit der Subnetzmaske 255.255.255.0. Das sagt die Angabe von /24 aus. Mein Router hat die Adresse 192.168.80.200. Danach wird die Liste der DNS-IPs angegeben, sie lauten Google1-DNS, Google2-DNS, Router-DNS. Sorry, ja Google-DNS (sorry) bietet neben den Telekom und Vodafone Servern einen ziemlichen Geschwindigkeitsvorteil.

Die oben genannten privaten IP-Adressen (192.168.x.y) sind natürlich in anderen Netzwerken entsprechend anzupassen.

Nach dem Speichern der Datei und einem Neustart des Raspberry Pi bekommt dieser statt der IP-Konfiguration vom DHCP-Server nun die IP-Konfiguration aus der soeben angepassten dhcpcd.conf. Bei einem Wechsel in ein anderes Netzwerk kann ich nun später bequem die Einstellung an dieser Stelle anpassen.

IPv6 Protokoll deaktivieren

Um IPv6 dauerhaft zu deaktivieren, sollte man erstmal feststellen, ob IPv6 aktiviert ist. Das bekommt man heraus mit der Eingabe von

ip addr show | grep inet6

Nun werden bei aktiviertem IPv6 Einträge markiert ausgegeben. Ansonsten ist die Ausgabe leer. Mit den folgenden zwei Eingabezeilen wird die Datei /etc/sysctl.conf um einen Eintrag ergänzt,

echo "net.ipv6.conf.all.disable_ipv6 = 1" >> /etc/sysctl.conf 
sysctl -p

Nach einem Neustart des Raspberry Pi sollte nun IPv6 deaktiviert sein. Das kann wieder mit dem obigen Befehl kontrolliert werden. Auch die Ausgabe von ifconfig bestätigt die Änderung

Wenn man diese nun letzte Zeile in dieser Datei entfernt und den Raspberry Pi neu startet, ist IPv6 wieder aktiviert. Ob man IPv6 wirklich deaktivieren sollte oder nicht, ist in jedem Anwendungsfall unterschiedlich. Es gibt mittlerweile einige Webseiten-Betreiber, die ihre Anschlüsse auf IPv6 umgestellt haben. In meinem Fall aber brauche ich dieses Protokoll nicht.

Die richtige Uhrzeit

In meinem Netzwerk wird die Uhrzeit schon vom Router bezogen. Dafür haben auch bereits die Einstellungen im Konfigurationsprogramm raspi-config gesorgt. Siehe dazu bitte den Beitrag “(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 2)” meines Tagebuches. Da sind auch die Umschaltungen von Sommer- und Winterzeit schon inbegriffen. Das lasse ich auch erstmal so. Wer das allerdings ändern möchte, ist z.B. hier gut beraten: https://linuxconfig.org/how-to-setup-ntp-server-and-client-on-debian-9-stretch-linux

Im Standard arbeitet der Raspberry Pi mit seinem Linux in der UTC-Zeit – genau das richtige für den Amateurfunk, denn diese ist auf unserer Erdkugel überall gleich.

RTC?

Allerdings überlege ich mir, wenn das Gerät irgendwo alleine ohne Netzwerk stehen sollte, ob ich ihm nicht eine batteriegepufferte RTC, eine sog. Real-Time-Clock einsetze. Wie das mit einer kleinen preisgünstigen I2C-Schaltung geht, kann man hier erfahren: https://tutorials-raspberrypi.de/raspberry-pi-rtc-modul-i2c-echtzeituhr/

GPS?

Auch der Einsatz und Zeitabgleich mit einem GPS-Modul könnte in einem Nebenprojekt münden. Und wie das geht, kann man hier nachlesen: https://raspberry.tips/projekte/gps-tracking-mit-dem-raspberry-pi

Im nächsten Teil 5 geht es um die Einrichtung des Node-Red-Dashboards und weiterer Bausteine für die Sensoren.

 

(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 3)

Installation der Grundprogramme

In diesem Teil 3 wird dem Raspberry Pi nun weitere Software verpasst, die für mein Dafürhalten unerlässlich sind. Mit dem Rasperry Stretch Lite müssen auch keine Softwarepakete entfernt oder deaktiviert werden, die nur unnötig Ballast sind/waren: keine Wolfram-Engine, kein Libre-Office, kein grafischer Desktop oder Programmiertools. Aber einige kleine Helferlein braucht es dann doch:

MC – Der Midnight Commander

Bekannt aus den früheren Jahren der Computerentwicklung ist dieser Dateimanager auf der Konsole ungeschlagen. Selbst FTP-Verbindungen oder Zugriffe auf entfernte Systeme sind in diesem Programm integriert. Die Installation gelingt mit der Eingabe von

sudo apt install mc

Der Aufruf des Programms erfolgt mit

mc

Um auch Sudo-Rechte für das Dateisystem zu bekommen startet man das Programm mit 

sudo mc

Bei der Frage welcher Editor künftig benutzt werden soll, entscheide ich mich für mcedit. Aber hier kann jeder selbst entscheiden, was ihm am nächsten ist.

Mit F10 beendet man das Programm.

HTOP

HTOP ist ein erweitertes Werkzeug zur Überwachung der Tasks und Dienste, sowie die CPU und Speicherauslastung. Die Installation erfolgt mit

sudo apt install htop

Der Aufruf erfolgt mit

htop

oder

sudo htop

Mit F10 beendet man das Programm.

Node-Red

Für die programmierbare Visualisierung von Daten benutze ich das Programmpaket Node-Red. Es ist von IBM unter Java entwickelt und bietet in einer grafischen Verwaltungs- und Programmieroberfläche auf Webbasis eine Vielzahl von Knoten (Nodes), die im Baukastenprinzip untereinander verbunden werden können. Meine These: “Mit Node-Red bekommst Du den Kaffeegenuss im und über das Internet voll unter Kontrolle.” Die Programmierung dieser Flussdiagramme (Flows) erfolgt ausschließlich auf der Weboberfläche, sowie auch das Veröffentlichen auf der eigenen Webseite.

Beispiel eines Flows. By 1-ByteOwn work, CC BY-SA 4.0, Link

Für meine Experimente ist Node-Red genau das richtige Werkzeug, um meine Sensoren, Aktoren und alle Kontrollmechanismen über eine Oberfläche zu verwalten und zu betreiben.

Install und Upgrade

Die Installation nehme ich vor, wie im Internet beschrieben. Über diesen Link kommt man auf die Node-Red Organisations-Webseite: https://nodered.org/docs/hardware/raspberrypi

Auf der Konsole des Raspberry Pi startet man die Installation mit folgendem Kommando:

bash <(curl -sL https://raw.githubusercontent.com/node-red/raspbian-deb-package/master/resources/update-nodejs-and-nodered)

Die folgenden Fragen können mit y beantwortet werden. Dann startet die Installation des kompletten Node-Red-Paketes inklusive der Pi-spezifischen Nodes. Das dauert etwa 15 Minuten. Die aktuelle Version ist die 0.19.2.

Bei Upgrades kann immer wieder der obige Befehl benutzt werden.

 

Sobald fertig, starte ich Node-Red das erste Mal mit der Eingabe von

node-red-start

Im Standard wird der IP-Port 1880 für Node-Red benutzt. Über einen Internet Browser startet man nun in der Adresszeile http://<IP-Adresse des Raspberry Pi>:1880 die Entwicklungs-Oberfläche von Node-Red auf dem Raspberry Pi. Also in meinem Fall von meinem lokalen Firefox: http://192.168.80.80:1880.

 

Node-Red-Dienst starten / stoppen

Damit Node-Red bei jedem Neustart des Raspberry Pi startet, wird mit dem folgenden Befehl der Dienst von Node-Red aktiviert. Vorher beende ich das laufende Node-Red mit Strg-C (womit man im Linux so einige Programme abbrechen kann) und gebe dann den Befehl ein, so wie es auch schon in der Konsole als Information ausgegeben wurde:

sudo systemctl enable nodered.service

Stoppen bzw. Deaktivieren kann man den Dienst wieder mit

sudo systemctl disable nodered.service

Mit einem Neustart des Raspberry Pi überprüfe ich die gewünschte Funktion.

sudo reboot

und stelle nach ein paar Sekunden die volle Funktionalität im lokalen Browser fest.

Also ist erstmal alles gut und ich kann anfangen den ersten Sensor anzubinden

Weiter geht es mit “(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 4)”

(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 1)

Vorbereitung des Raspberry Pi zur Wetterstation

Bild vom raspberrypirev2

Von Philipp BohkEigenes Werk, CC BY-SA 3.0, Link

Hab noch einen etwas älteren Raspberry Pi B Rev2 und möchte diesen als Datenlogger für meine Aufzeichnungen von diversen Daten und Experimenten mit den Dingen des Internets IdD oder IoT (Internet of Things) nutzen. 

Ich entscheide mich für das Betriebssystem Raspbian Lite. Warum Lite? Weil diese Version vom Raspbian Betriebssystem ohne überflüssiges Zeugs, wie z.B. den graphischen Desktop und das alles, auskommt. Außerdem benötigt man für die NOOBS-Installation einen Monitor und eine Tastatur, was man sich in diesem Falle sparen kann. Das System startet -wie man so  schön sagt- headless. Dafür ist das Betriebssystem extrem jungfräulich und muss – besser: kann – von Grund auf aufgebaut und konfiguriert werden. Wie ich das gemacht habe, erkläre ich in den folgenden Abschnitten.

Vorbereitungen

Ich mache keinen Hehl daraus, dass ich mich privat immer mehr vom Windows-Betriebssystem distanziere. Linux ist mit seinen unzähligen Derivaten in der Anwendung davon oft nicht mehr zu unterscheiden. Außerdem bietet es ein essentielles Maß an Sicherheit und Hardwareunterstützung. Es ist eine Vielzahl von Amateurfunk-Programmen frei erhältlich. Auch eine Unterstützung von Windows-Software in einem Emulationsmodus (z.B. WINE) ist vorhanden. Hier muss man im Einzelnen aber prüfen, welche Soft- und Hardwarevoraussetzungen von Windows-Programmen notwendig sind. Und ich meine, es ist keine Schande für einen urigen Linuxer auch die graphischen Desktops (GUI) zu nutzen. Die Zeiten von ellenlangen und kryptischen Befehlszeilen sind längst vorbei. Wie man später aber sehen wird, sind für weitere Installationen von Treibern oder Software im Raspberry einige Konsolenbefehle unerlässlich. Wenn man weiß warum und wofür, dann ist das auch recht verständlich.

SD-Card-Reader/Writer (gibt es schon für unter 10 Euro an jeder Straßenecke, oder im PC)

  • Windows: Win32DiskImager oder Etcher, Putty
  • Linuxdd Befehl von der Konsole, Etcher oder USB-Abbildersteller (z.B. Linux Mint) und ssh Befehl von der Konsole

Das Betriebssystem flashen

Zum heutigen Zeitpunkt (August 2018) ist Raspbian Stretch Lite die aktuelle Version mit der Kernel Version 4.14. Zum Download des Betriebssystems kommt man hier.

Ich installiere bzw. flashe dieses Betriebssystem mit einem der oben genannten Programme  auf eine SD-Karte der Klasse 10 mit 8 GB. Kleinere Karten bis hinunter zu 2 GB tun es auch, sind aber kaum noch erhältlich. Anleitungen dazu gibt es genug im Internet.

SSH-Zugriff aktivieren

Bevor man die Karte zum Booten in den Raspberry Pi einlegt, ist es ratsam den SSH-Zugriff zu konfigurieren. Deshalb behalte ich die Karte im Slot und öffne sie in einem Datei-Explorer oder Dateimanager. In der Partition Boot erstellt man einfach eine Datei mit dem Namen ssh ohne Endung. Somit ist der SSH-Zugriff aktiviert. Im Übrigen wird damit auch bereits der SFTP-Zugang für Filetransfers gewährt.

Erster Start des Raspberry Pi

Jetzt kann man diese Karte in den Raspberry Pi einlegen, mit einem Netzwerkkabel ans Heimnetzwerk verbinden und einschalten. Warum nicht WLAN? Der RPi B hat keinen WLAN-Adapter. Das Betriebssystem ist für DHCP konfiguriert und sollte vom heimischen Netzwerk nun automatisch eine IP-Konfiguration erhalten. Diese ist über den DHCP-Server im Heimnetzwerk, meist der Internetrouter (z.B. Fritzbox), ausfindig zu machen und für den weiteren Zugang zum Gerät zu merken. Ich finde und merke mir hier hinter dem neuen Eintrag raspberrypi.local die IP-Adresse 192.168.80.80. Der Raspberry Pi ist damit bereits mit den Gegebenheiten des Netzwerkes versorgt (Subnetzmaske, Gateway, etc.). Wir ändern das später von versorgen lassen (dynamisch) in fest eingetragen (statisch).

In meinem Linux-Terminal verbinde ich mich mit dem Raspberry Pi. Im Standard-Zugriff ist der Benutzer pi mit dem Kennwort raspberry versehen. Natürlich sollte man dieses Kennwort unverzüglich ändern. Wie das geht erscheint nach dem Anmelden auch als Hinweis auf der Konsole. Also tu ich das!

Ach übrigens, für Neueinsteiger vielleicht interessant: Linux ist bei allen Tastatureingaben sehr pingelig mit der Groß- und Kleinschreibung. Also bitte immer darauf achten! Den Benutzer Pi oder PI gibt es nicht, sondern nur erstmal den Benutzer pi. Das gilt auch für Befehle und Pfadangaben.

dl8aap@heimpc ~ $ ssh pi@192.168.80.80
pi@192.168.80.80's password: raspberry (<- wird bei Eingabe nicht angezeigt)
Linux raspberrypi 4.14.62+ #1134 Tue Aug 14 16:58:07 BST 2018 armv6l
.
.
.
SSH is enabled and the default password for the 'pi' user has not been changed.
This is a security risk  please login as the 'pi' user and type 'passwd' to set
 a new passwd.

pi@raspberrypi:~ $ passwd
Ändern des Passworts für pi.
(aktuelles) UNIX-Passwort:
Geben Sie ein neues UNIX-Passwort ein:
Geben Sie das neue UNIX-Passwort erneut ein:
passwd: Passwort erfolgreich geändert
pi@raspberrypi:~ $

Somit ist die Erstverbindung mit dem Raspberry Pi erfolgreich eingerichtet und es geht weiter mit:

(M)eine kleine Wetterstation mit einem Raspberry Pi (Teil 2)