Dabei ist das gar nicht so einfach, wie es im ersten Moment klingt: LOGO! selbst ist eine exzellente Ministeuerung für alle Lebenslagen, aber Web Services im Internet kann sie beim besten Willen nicht ansprechen. Um das zu erreichen, benötigt LOGO! etwas Schützenhilfe von einem alten Bekannten – dem Raspberry Pi. Er ist ein vollwertiger Minicomputer mit einem Linux-Betriebssystem, der sich an alle möglichen Dienste im Internet andocken kann.
Talk to me
Wie stellen wir es nun an, Raspberry Pi mit LOGO! zu verbinden? Es gibt mehrere Möglichkeiten. Wir können zum einen einfach ein Signal über einen Pegelwandler direkt an einen Eingang von LOGO! führen. Sobald der Wetterbericht für die nächsten zwölf Stunden Regen meldet, wird ein Bit gesetzt und LOGO! bewässert den Garten nicht.
Eine weitere Variante zur Lösung wäre, dass man über Schieberegister die Regenwahrscheinlichkeit über die normalen Eingänge zu LOGO! übermittelt – was jedoch eine sehr aufwendige Programmierarbeit wäre, die wir uns sparen können. Aber es ist ja gar nicht nötig, LOGO! die Entscheidung zu überlassen, was bei einer bestimmten Regenwahrscheinlichkeit zu tun ist. Ein einfaches Bit zur richtigen Zeit würde vollkommen ausreichen, um unsere Gartenbewässerung ein ganzes Stück schlauer zu machen. Nicht, dass ich etwas gegen Kabel und Pegelwandler habe, aber man kann sich den ganzen Aufwand schlicht und ergreifend sparen. LOGO! hat zwar kein API (Application Programming Interface) im eigentlichen Sinne, aber sie kann mit unterschiedlichen Komponenten über das Netzwerk reden.
Das Protokoll macht keinen rechten Spaß, es ist dazu gedacht, dass sich die Steuerungen untereinander unterhalten. Dieses Manko hat die Entwicklergemeinde jedoch schon lange erkannt: Es gibt Projekte, die Web-Services-basierte APIs für LOGO! bereitstellen. Wir werden für unser Beispiel das API von LogoControl verwenden. Es ist schnell und einfach auf dem Raspberry Pi zu installieren.
Das Programm, das wir schreiben werden, wird auf der einen Seite das API von OpenWeatherMap auslesen und mithilfe des LogoControl-APIs ein Statusbit in LOGO! setzen. Dieses Statusbit verhindert das Bewässern für einen Tag. Das klingt ja alles sehr einfach, Sie werden sich aber wundern, wie viele Kleinigkeiten erledigt werden müssen, bis das Programm läuft. Also legen wir gleich mit den Vorbereitungen los.
Artikelserie
Teil 1: Gartenbewässerung mit LOGO! von Siemens
Teil 2: Reale Programme in einer realen LOGO!
Teil 3: Wetterdaten – aus dem Internet in LOGO!
Vorarbeiten an LOGO!
Damit LOGO! über das Netzwerk mit unserer LogoControl-Software kommunizieren kann, sind einige Vorarbeiten nötig. Auf dem Screen Extras | Ethernetverbindungen klicken wir mit der rechten Maustaste auf Ethernetverbindungen und fügen eine neue Serververbindung hinzu (Abb. 1). Nachdem wir die Verbindung hinzugefügt haben, machen wir einen Doppelklick auf der neuen Verbindung. Auf dem Screen, der nun zusehen ist, sind die Parameter, wie in Abbildung 2 zu sehen, einzugeben.
Abb. 1: Hinzufügen einer Serververbindung
Abb. 2: Setzen der Parameter, um mit der LogoControl-Software zu reden
LOGO! ist jetzt so weit vorbereitet, dass wir mit den nächsten Schritten fortfahren können.
Set-up von Raspberry Pi
Viele unter Ihnen werden jetzt sicher sagen: „den RasPi kenne ich, da brauch ich keine Installationsanleitung“. Gut, für alle anderen sind hier noch einmal die wichtigsten Schritte dargestellt, um einen Raspberry Pi zum Laufen zu bekommen.
Als Erstes laden wir uns die Light-Version von Raspbian herunter. Bei der Light-Version handelt es sich um eine vollständige Installation ohne Office und X-Server. Beides benötigen wir auch nicht, da der Raspberry Pi für uns als Server fungieren soll. Die folgenden Kommandozeilenbefehle zeigen Ihnen, wie man das ISO-Image bequem mit Ubuntu von der Raspberry-Hompage herunterladen und installieren kann. Windows-User müssen hier die unter Ihrem Betriebssystem üblichen Schritte gehen.
wget https://downloads.raspberrypi.org/raspbian_lite_latest unzip raspbian_lite_latest sudo dd if=2016-02-26-raspbian-jessie-lite.img of=/dev/sdd
Bei dd müssen Sie als Outputfile (of) natürlich das in Ihrem System vorhandene Gerät auswählen, das der SD-Karte entspricht. Das Datum des Images wird bei Ihnen vermutlich etwas neuer sein. Nachdem das Image vollständig geschrieben wurde, können Sie die SD-Karte in Ihren Raspberry-Pi-Typ-2 stecken und booten. Es würde natürlich auch mit einem Typ-1-Raspberry funktionieren, aber man muss der Fairness halber zugeben, dass der Typ-1-Raspberry wirklich erheblich langsamer arbeitet.
The Pros and Cons of Implementing Microservices as a Serverless Application
Nikhil Barthwal (Google)
Serverless Applications with GraphQL
Marcia Villalba (Rovio)
Serverless Operations: From Development to Production
Erwin van Eyk (Platform9)
Blockchain, Crypto-Währungen und -Plattformen (Part 1 + 2)
mit Stefan Tilkov (INNOQ)
Event Storming meets Reality
mit Elisabeth Engel (interfacewerk) und Marco Heimeshoff (Heimeshoff IT)
Nach dem ersten Booten loggen wir uns als User „pi“ mit dem Passwort „raspberry“ ein. Bei der Passworteingabe kommt erschwerend hinzu, dass die Tastatur beim ersten Start ein englisches Layout hat. Das heißt für uns sind Y und Z vertauscht. Danach starten wir mit sudo raspi-config das Konfigurationsprogramm für den Raspberry Pi. Dort aktivieren wir den SSH Daemon unter dem Menüpunkt 9, Advanced Options | A4 SSH, damit wir später bequem mit dem Befehl ssh pi@ remote auf dem Raspberry Pi arbeiten können.
Alle weiteren Einstellungen an der Raspberry-Pi-Konfiguration können Sie dann über die SSH-Verbindung von Ihrem Linux-PC aus vornehmen. Windows-User können hierzu PuTTY verwenden. Sie sollten allerdings nicht vergessen, das Filesystem auf der SD-Karte zu vergrößern; mehr freier Speicherplatz hat noch nie geschadet. Um unsere Installation auf den aktuellen Stand zu bringen, setzen wir folgende zwei Befehle ab:
sudo apt-get update sudo apt-get upgrade
Unser Raspberry Pi ist jetzt rudimentär aufgesetzt, wir können nun mit der Installation der LogoControl-Software beginnen.
Installation der LogoControl-Software
Die LogoControl-Software benötigt Mono mindestens in der Version 3.4. Mono ist eine quelloffene Implementierung des .NET Frameworks von Microsoft. Die aktuelle Version von Raspbian hat jedoch leider keine passende Mono-Version an Bord. Wir können aber eine funktionierende Version von der LogoControl-Hompage herunterladen. Nachdem wir diese installiert haben, müssen wir den Raspberry Pi rebooten:
wget http://www.frickelzeugs.de/mono_3.10-armhf.deb sudo dpkg -i mono_3.10-armhf.deb sudo reboot
Nun sind alle Vorbedingungen erfüllt und wir können mit der Installation von LogoControl starten. Auf der Downloadseite wählen wir die Version für den Raspberry Pi aus und laden sie herunter; danach wird sie auf den Raspberry Pi kopiert. Dort packen wir das Archiv aus, installieren es und rebooten den Raspberry Pi:
gunzip logocontrol-pi-4.2.0.tgz tar -xvf logocontrol-pi-4.2.0.tar cd LogoControl ./init.sh sudo reboot
Nach dem Neustart läuft auf den Raspi auf Port 8088 eine Weboberfläche, mit der man nach einigen Konfigurationsschritten auf LOGO! zugreifen kann (Abb. 3).
Abb. 3: Der Startscreen der LogoControl-Software
Unter dem Punkt „Konfiguration“ können wir die XML-Konfiguration unseres LogoControl-Servers sehen. Die passt momentan noch gar nicht für unseren Anwendungsfall.
Als Erstes müssen wir die IP-Adresse unserer realen LOGO! eintragen, was wir einfach im Webbrowser erledigen können. Danach passen wir die komplette Infrastrukturdefinition so an, dass sie auf unsere Bewässerungsanlage passt. Listing 1 zeigt uns, wie es am Ende aussehen sollte. Ein besonderes Augenmerk ist hier auf den „Merker 1“ zu werfen; ihn werden wir später verwenden, um die Bewässerung zu deaktivieren, wenn der Wetterbericht Regen vorhersagt. Die Adressen der LOGO! für die Ein-, Ausgänge und Merker können Sie online (unter dem Punkt „VM Adressen“) finden.
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<settings>
<logo ip="192.168.2.41" />
<httpWebservice port="8080" />
</settings>
<infrastructure>
<group name="Garten">
<group name="Ventile">
<device id="1" name="Ventil 1">
<attribute id="1" name="Status" address="1064.0" datatype="bit">
<valuetext value="0" text="aus" />
<valuetext value="1" text="an" />
</attribute>
</device>
<device id="2" name="Ventil 2">
<attribute id="1" name="Status" address="1064.1" datatype="bit">
<valuetext value="0" text="aus" />
<valuetext value="1" text="an" />
</attribute>
</device>
<device id="3" name="Ventil 3">
<attribute id="1" name="Status" address="1064.2" datatype="bit">
<valuetext value="0" text="aus" />
<valuetext value="1" text="an" />
</attribute>
</device>
<device id="4" name="Ventil 4">
<attribute id="1" name="Status" address="1064.3" datatype="bit">
<valuetext value="0" text="aus" />
<valuetext value="1" text="an" />
</attribute>
</device>
<device id="5" name="Merker 1">
<attribute id="1" name="Status" address="1104.0" datatype="bit">
<valuetext value="0" text="aus" />
<valuetext value="1" text="an" />
</attribute>
</device>
<device id="6" name="Temperatur">
<attribute id="1" name="Temperatur" address="1036" datatype="word"\\ gain="0.1" />
</device>
<device id="7" name="Bodenfeuchte">
<attribute id="1" name="Bodenfeuchte" address="1034" datatype="word"\\ gain="0.1" />
</device>
</group>
</group>
</infrastructure>
</configuration>
Sie werden sich jetzt zurecht fragen, warum wir den Aufwand treiben, nur um im Browser den Status unserer Bewässerungsanlage anzuzeigen. Die LogoControl-Software kann viel mehr, als nur ein schönes Webfrontend anzuzeigen: Die XML-Definition wird verwendet, um einen REST-basierenden Web Service aufzubauen, mit dem wir auf einfache Weise in die Steuerlogik der LOGO! eingreifen können. Unseren Merker können wir einfach mit folgendem Aufruf manipulieren:
http://192.168.2.3:8080/rest/devices/5/attributes/1/value?set=1
Als Werte für set können Sie 1 oder 0 setzen, das entspricht logisch true oder false. Eine komplette Übersicht aller vorhandenen Geräte mit ihren Attributen erhalten wir, wenn wir folgenden Aufruf absetzen:
http://192.168.2.3:8080/rest/devices
Der Vollständigkeit halber hier noch einmal die allgemeine Form der Aufrufe, um den Status eines Geräts abzufragen und ihn zu verändern.
/devices/{deviceId}/attributes/{attributeId}/value
/devices/{deviceId}/attributes/{attributeId}/value?set={newValue}
Wir können nun über einen einfachen Web Service mit LOGO! kommunizieren, und das theoretisch über das Internet. Bitte öffnen Sie nicht unbedacht Ihre Firewall, um Ihr Haus vom Handy aus zusteuern. Dieser Web Service funktioniert zwar, ist aber weder verschlüsselt noch hat er einen Authentifizierungsmechanismus. Das ist für lokale Netze ok, aber bitte nicht in Richtung Internet damit gehen. Der potenzielle Hacker könnte im schlimmsten Fall nur unseren Rasen vertrocknen lassen, aber das ist ja genau das, was wir mit diesem Projekt verhindern wollen …
Möchten Sie die Web-Services-Aufrufe dennoch über das Internet verwenden, schauen Sie bitte in die Dokumentation auf der Projekthomepage von LogoControl. Dort finden Sie die Informationen, die nötig sind, um den Web Service sicher aufzubauen.
Das LOGO!-Programm anpassen
Um das Programm aus dem zweiten Teil dieser Reihe so zu ändern, dass wir es über einen Web-Services-Aufruf beeinflussen können, ist nur eine kleine Änderung nötig. Wir verknüpfen die Ausgänge der Ventilsteuerung über ein logisches UND mit dem negierten Ausgang eines RS-Flipflops. Das Flipflop wird über den Merker gesetzt und mit der fallenden Flanke unserer Wochenzeitschaltuhr zurückgesetzt. Dieser Aufbau hat den Vorteil, dass unsere Steuerung auch weiter arbeitet, wenn der Raspberry abgestürzt ist: LOGO! wird ohne Wettervorhersage den Garten bewässern.
Es gibt in unserm Programm mehrere Stellen, an denen wir die UND-Verknüpfung mit unserem RS-Flipflop einbauen können; der Einfachheit halber habe ich sie parallel zum Partyschalter eingebaut. Abbildung 4 zeigt Ihnen das angepasste Programm.
Abb. 4: Das angepasste LOGO!-Programm
Das OpenWeatherMap-API
Um die Wettervorhersagen des API von OpenWeatherMap verwenden zu dürfen, ist eine Registrierung nötig, die auf der Website erfolgt. Nachdem wir alle auf der Seite geforderten Daten eingegeben haben, bekommen wir einen API-Key, mit dem wir uns beim Web Service von OpenWeatherMap authentifizieren können. Der Aufruf für die aktuellen Wetterdaten sieht wie folgt aus – die ID Ihres Standorts suchen Sie sich am besten über die Webseite heraus:
http://api.openweathermap.org/data/2.5/weather?\\id=2953770&APPID=&units=metric
Als Antwort bekommen wir ein JSON mit den aktuellen Daten; wir benötigen für unser Projekt aber die Vorhersage. Um sie zu bekommen, verwenden wir einen anderen Aufruf. Die Antwort ist erheblich komplexer, da sie die Daten für die nächsten fünf Tage (in Drei-Stunden-Schritten) im Voraus beinhaltet. Der Parameter id gibt den Ort an, für den wir Wetterdaten anfordern. Mit units=metric veranlassen wir den Web Service, uns die Temperaturen in Celsius zu übermitteln, der Standard ist hier Fahrenheit.
http://api.openweathermap.org/data/2.5/forecast?\\id=2953770&APPID=<IHR_API_KEY>&units=metric
Die Auswertung dieser Daten wird nun etwas kniffelig. In unserer Web-Services-Antwort finden wir zuerst einen Header mit allgemeinen Standortinformationen. Hinter dem Header bekommen wir eine Liste mit 36 Vorhersagen. Da wir uns auf die nächsten zwölf Stunden beschränken wollen, sind nur die ersten vier Vorhersagen für uns relevant.
Wir müssen uns für diese Listeneinträge den Parameter rain genauer ansehen. Gibt es keinen Wert für rain, wird es nicht regnen (soweit wir den Wetterfröschen trauen wollen). Finden wir nun Einträge für Regen in unserem Vorhersagezeitraum, können wir davon ausgehen, dass eine Wahrscheinlichkeit für die angegebene Regenmenge besteht. Wir benötigen am Ende des Tages nur einen Ja/Nein-Indikator, der uns sagt, ob bewässert werden soll oder nicht.
Es gibt unendlich viele Möglichkeiten, diesen Wert zu bilden. Um es aber für unser Beispielprogramm einfach zu machen, schlage ich vor, dass wir die Summe der vorhergesagten Niederschlagsmengen verwenden. Sobald diese einen bestimmten Grenzwert überschreitet, wird die Bewässerung ausgesetzt. Diesen Grenzwert können wir im ersten Wurf jedoch leider nur raten. Es wird sich im Laufe des Jahres zeigen, ob und wie wir diesen Wert noch anpassen müssen. Dasselbe gilt natürlich für die Bewässerungsdauer der einzelnen Bereiche in unserem Garten.
Den Algorithmus für unser Programm haben wir. Schauen wir uns als Nächstes die praktische Umsetzung an.
Vorhersage
Das Programm, um die Wettervorhersagen auszuwerten und das Steuerbit für LOGO! zu setzen, kann man in Prinzip in jeder beliebigen Programmiersprache schreiben. Durch die starke Verwendung von Web Services würde sich Java anbieten. Java ist auf dem Raspberry allerdings in der Verwendung etwas träge, und wenn man ehrlich ist, auch etwas oversized für unser Miniprogramm. Daher verwenden wir einfach das gute alte Perl. Mit ihm lassen sich auch schnell mal kleine Änderungen am Programm vornehmen, ohne gleich neu kompilieren zu müssen. Und es wird sicherlich noch einige Änderungen an der Vorhersagenauswertung geben … Doch genug der Vorrede – sehen wir uns das Programm (Listing 2) in Detail an.
Nachdem die Programmparameter in Variablen geladen wurden, wird der Aufruf für das OpenWeather-API vorbereitet. Der Aufruf selbst wird mittels wget erledigt. Als Antwort bekommen wir eine lange Zeile, die wir in einer temporären Datei speichern. Jetzt kommt der etwas gruselige Part (Freunde von regulären Ausdrücken werden mich jetzt steinigen), der die Niederschlagsmengen für die nächsten zwölf Stunden aus der Datei extrahiert und aufsummiert. Danach wird nur noch in Abhängigkeit vom Grenzwert für die Regenmenge das Statusbit in LOGO! gesetzt oder gelöscht.
Das Programm ist nur als Beispiel gedacht; Sie können sich hier natürlich richtig ausleben und schöne Bibliotheken verwenden, die die Web-Services-Aufrufe kapseln. Sinnvollerweise sollte man das Programm über einen Cronjob ausführen lassen, der zeitlich an das LOGO!-Programm angepasst werden müsste, also noch eine Menge Raum für eigene Ideen.
#!/usr/bin/perl
$appid=;
$location=2953770;
$tempfile='/tmp/weather.tmp';
$limit=0.3;
$command="/usr/bin/wget -q -O $tempfile http://api.openweathermap.org/data/2.5/forecast?id=$location\\\&APPID=$appid\\\&units=metric";
system($command);
$sumvolume=0;
open (FH,$tempfile);
while(){
@rain=split("\"rain\":{",$_);
for ($i=1;$i<=4;$i++){ $volume=$rain[$i]; $volume=~s/}.*//; $volume=~s/.*://; $sumvolume=$sumvolume+$volume; } } close (FH); if ($sumvolume > $limit){
$state=1;
} else {
$state=0;
}
$command="/usr/bin/wget http://192.168.2.5:8080/rest/devices/5/attributes/1/value?set=".$state." -O /dev/null -q ";
system($command);
Fazit
Bei diesem Projekt ist wieder einmal schön zu sehen, dass das Pareto-Prinzip stimmt. Der Aufwand, den wir in Teil 2 für die komplette funktionierende Bewässerungssteuerung treiben mussten, war geringer als die Arbeit, die wir uns für die Einbindung der Wettervorhersagedaten gemacht haben. Es sind auch zusätzliche Komponenten dazu gekommen, die allesamt natürlich auch zusätzliche Fehlerquellen sein können. Daher sollte man sich gut überlegen, wie weit man den technischen Aufwand bei seiner Gartenbewässerung treiben möchte.
Der Artikel zeigt viele Möglichkeiten, die natürlich nicht eins zu eins nachgebaut werden müssen. Es soll vielmehr an einem praktischen Beispiel gezeigt werden, dass viele interessante Projekte mit LOGO! einfach und schnell realisiert werden können. Nun bleibt mir nur noch Ihnen viel Spaß beim Experimentieren zu wünschen.
Entwickler Magazin
Dieser Artikel ist im Entwickler Magazin erschienen.
Natürlich können Sie das Entwickler Magazin über den entwickler.kiosk auch digital im Browser oder auf Ihren Android- und iOS-Devices lesen. In unserem Shop ist das Entwickler Magazin ferner im Abonnement oder als Einzelheft erhältlich.
Hinterlasse einen Kommentar
Hinterlasse den ersten Kommentar!