*EH2018 Vorspannmusik*
Jochen Krapf: Okay, hallo zusammen!
Ich bin der Jochen. Ich will heute was erzählen, wie es der Titel schon sagt,
über „Easy Do-It-Yourself Internet-of-Things“,
Sachen mit dem ESP und mal einen kurzen Überblick noch in der Version mit dem
[Raspberry] Pi. So, was wollen wir heute machen?
Also eigentlich ein theoretischer Workshop, wenn man so will. Ich will hier
ein IoT-Gerät bauen, hier als Vortrag, mit dem ich ein paar Sachen
messen will. Als Raumtemperatur, relative Feuchte, und auch ein Bewegungssensor.
Ich will auch die Helligkeit noch ein bisschen schätzen, nicht messen.
Es ist keine genaue Messung, sondern nur, ob es hell oder dunkel im Raum ist.
Noch Tür- oder Fensterkontakte. Und das Ganze soll dann mit MQTT ‒ das ist
ein standardisiertes Protokoll, was bei vielen IoT-Geräten verwendet wird
mittlerweile ‒ soll an irgendeinen Server geschickt werden. Das Ganze
als kleines, einfaches Teil. Und vielleicht noch einen Ausblick,
was man sonst noch so alles mit dem IoT-Gerät machen könnte.
Man kann natürlich auch die Funksteckdosen steuern. Man kann
die Infrarot-Fernbedienung ersetzen durch ein IoT-Gerät, und damit einen Fernseher
quasi fernsteuern. Man kann irgendwelche Taster abfragen, um dann z.B. Lichtschalter
durch ein IoT-Gerät zu ersetzen. Man kann LED-Strips steuern, sowohl die RGB-Strips
als auch WS2812, das sind die einzelsteuerbaren RGB-Sachen, oder
auch Relais, um eine Lampe ein- und auszuschalten. Statusanzeigen über LCD
sind natürlich auch möglich. Und auch weitere Sensoren, wie z.B. Feinstaub,
Stickoxide, organische Gase und so was kann man natürlich auch anschließen.
Da soll mal das grobe Ziel sein, was wir machen wollen. Und bei der Umsetzung
habe ich natürlich auch ein paar Anforderungen. Soll natürlich Open Source
sein. Ist ja hier klar, eigentlich. Möglichst wenig Programmierkenntnisse
und auch wenig Löterfahrung, damit man das einfach und schnell machen kann.
Ich weiß, dass hier auch viele Leute sind, die sehr gute Programmierer sind,
aber hier geht’s eher darum, dass so die breite Masse auch mal schnell
ein IoT-Gerät bauen kann, ohne viel Aufwand. Ich will natürlich
Standardmodule verwenden, die natürlich auch nichts kosten dürfen.
Mit ‘Standardmodule’ meine ich Sachen, die ich überall bei Ebay und sonstigen
Portalen bekomme, für wenig Geld, die oft auch als Arduino-Zusatzmodule
ausgewiesen werden.
Was nimmt man dafür? Man braucht irgendeinen Prozessor.
Das, was am häufigsten verwendet wird, mittlerweile, ist der sogenannte ESP8266.
„-12“ ist dann noch die spezielle Bauform. Und sieht dann entsprechend so aus.
Das ist ein 32 bit-Prozessor mit genügend Megahertz,
um auch ein bisschen Webserver und sowas zu machen.
Hat 4 MB Flash für [das] Programm und auch eine Flash-Disk,
um auch Dateien abzulegen. Mit 20kB RAM kommt man nicht so weit,
aber es reicht, auch für Webserver- Anwendungen. Auf jeden Fall
wesentlich mehr als man beim Arduino, zum Beispiel, hätte.
Der große Vorteil: er hat ein Wi-Fi mit eingebaut. Man sieht ja die Antenne.
Also die interne Antenne, um dann mit 2,4GHz dann gegen den lokalen Access Point
dann Daten zu werfen. Der große Vorteil ist, dass das Ganze über die Arduino-IDE
programmierfähig ist. Und mehr als 90% der Libraries von Arduino auch
mit diesem Prozessor verwendet werden können. Man kann natürlich auch andere
Sachen, wie atom-Umgebung mit platform.io zur Programmierung verwenden.
[Da] gehe ich jetzt nicht näher [darauf] ein, nur… wer damit etwas machen will.
Das Modul hat 2mm Raster, ist damit für Hobbyisten natürlich nicht so gut geeignet.
Mit Anlöten, oder Breadboard-Anwendung. Deshalb gibt es ein paar andere Sachen,
es gibt Hersteller, die dann genau dieses Modul auf Platinen setzen, die dann wieder
mit 2,54mm-Raster arbeiten ‒ dann also Breadboard-fähig ‒ und dann auch schon
USB-Seriell-Wandler mit auf der Platine haben. Um dann gleich an den Rechner
anstecken zu können. Und auch einen Spannungswandler, um dann mit 5V
zu arbeiten. Der Chip selber braucht 3,3V. Auf der linken Seite ist die sogenannte
Node-MCU. Die man nicht nur mit LUA verwenden kann, sondern auch
neu flashen, und dann eben seinen C-Code darauf ausführen kann.
Rechts sieht man das im Prinzip elektronisch Gleiche, nur auf einer
anderen Platine. Das ist der WeMos D1, davon gibt es auch eine Pro-Variante
mit steckbarer Antenne. Hat das gleiche drauf, und den USB-Seriell-Wandler
auf der Unterseite. Deshalb ist die Platine kleiner und kompakter.
Die werde ich jetzt hier für meine Vorführung auch verwenden.
Man hat an dem Prozessor 9 I/O-Pins,
die man frei verwenden kann.
Und damit kann man dann die meisten Sachen auch abdecken. Man hat auch
I2C-Bus, man hat SPI, man hat einen AD-Wandler-Kanal. Fast alle Pins
sind als GPIO verwendbar, um dann alles mögliche zu schalten
und eben einzulesen.
Zu den Sensoren: ich habe ja gesagt, Hauptaufgabe ist Temperatur-
und Feuchtemessung. Dafür gibt es den DHT22, als einen von vielen Sensoren,
nur als Beispiel. Es gibt Infrarot- Bewegungsmelder ‒ kann ich gleich
noch mal live vorführen. Und es gibt auch Standard-LDR’s, die man hier
verwenden kann, um eine Helligkeit abzuschätzen.
Jetzt brauche ich die Kamera!
Nö, ich muss mal kurz…
Halt! Nein… So.
Jetzt! Das ist nochmal der ESP. Hier ist die Rückseite
mit dem USB-Seriell-Wandler. Hier ist die Vorderseite
mit dem ESP, und eben der Antenne auf der Vorderseite für WLAN.
Sensoren ‒ habe ich einmal hier den DHT22,
der hier einfach mit drei Pins am ESP angeschlossen wird, da kommen wir
gleich noch dazu. Ich habe noch den Infrarot-Melder, der sieht dann so aus.
Noch Schärfe…
Und auf der Rückseite ist eben die Elektronik, mit drei Anschlüssen,…
Sieht man’s gut?
So, jetzt.
…der einfach nur ein Signal ausgibt, wenn sich jemand im Raum bewegt hat.
Ansonsten braucht er einfach 5 Volt, und das war’s dann. Zu den Kosten:
der Bewegungsmelder kostet vielleicht 3..4 Euro, wenn man es
in Deutschland kauft. Der Temperatursensor auch 3..4..5 Euro. Es gibt natürlich
noch weitere Module. Es gibt noch jede Menge solche Module ‒ jetzt nur
als Beispiel ‒ die einfach schon
freundlicherweise auf ein Board gelötet sind, und
einfach mit ein paar Steckkontakten an den Prozessor entweder angelötet bzw.
mit Steckkabeln angeschlossen werden kann.
Dann wollten wir ja noch die Helligkeit detektieren. Da gibt es
einen sogenannten LDR ‒ einen lichtempfindlichen Widerstand.
Kostet vielleicht einen Euro, oder weniger, wenn man einen Zehnerpack nimmt.
Dann eventuell noch eine Leuchtdiode als Statusanzeige.
Zu der Verkabelung: ist auch relativ einfach.
Für den Temperatursensor brauche ich hier nur noch einen Widerstand
als sogenannten Pullup, um die Datenleitungen gegen die 3,3 V zu ziehen.
Das heißt, ich brauche einfach nur drei Kabel am Prozessor anlöten,
und habe das Ding schon konnektiert.
Eins daneben, in der Mitte, ist der Bewegungsmelder. Der braucht 5 Volt,
gibt ein 3,3 Volt TTL-Signal raus. Und den kann ich auch einfach am Prozessor,
an einem fast beliebigen Pin anschließen.
Wenn ich die Helligkeit messen will, kann ich den LDR oben rechts einfach so
anschließen, weil, es sind schon Widerstände als Spannungsteiler
aufgelötet. Und damit brauche ich keine weiteren, externen Komponenten.
Wenn ich einen Türschalter habe will, brauche ich natürlich noch einen Pullup,
unten rechts, der mir das Ganze auf 3 Volt zieht. Und der Schalter, ich sage mal,
einen Reed-Schalter, z.B., um einen Fensterkontakt abzufragen, der
gegen Masse schaltet. Optional noch eine LED, die am Fenster anzeigt, ob es
geöffnet ist. Und auch die LED ‒ einfach mit einem Vorwiderstand anschließen.
Wenn ich weitere Sachen anschließen will, nur so mal als Überblick,
alles was einen I2C-Bus hat, einfach mit den zwei Leitungen ‒ also ‘Daten’
und ‘Clock’ ‒ am Prozessor anschließen, und das war’s. Ich brauche nichts weiteres.
Auch jetzt so ‘Neopixel’ ‒ einfach mit einem Pin anschließen, natürlich
die 5 Volt aus einem starken Netzteil noch beziehen, und dann kann ich
das Ganze betreiben. Auch einen LED-Strip kann ich einfach mit einem Schalttransistor
dann mit PWM auch die Helligkeit steuern. Und man sieht, dass sich die ganze Hardware
eigentlich sehr in Grenzen hält. Und damit auch für Hobbyisten: einfach nur Kabel
an Sensor und Prozessor anschließen, und schon sollte alles funktionieren.
Dann brauche ich natürlich noch ein Netzteil. Da kann man natürlich solche
schönen China-Handyladenetzteile nehmen. Wenn man den USB-Stecker
nicht kaufen will, kann man, wie hier zu sehen, auch einfach aus einem Stück
Lochrasterplatine sich selber schnell einen Stecker bauen, funktioniert wunderbar.
Gehäuse. Da ist man natürlich komplett frei, was man machen will.
Man kann irgendwas nehmen, was eh da ist, eine Haushaltsbox, so eine Verteilerdose,
vielleicht eine Zigarrenkiste oder sonstwas. Wenn man im Hackerspace
oder Fablab einen 3D-Drucker hat, kann man sich natürlich da auch
was beliebiges drucken. Ich nehme natürlich sehr gern den Laser-Cutter,
um damit Gehäuse zu bauen. Und das kann ich dann auch vorführen.
Muss nur schnell noch umbauen. Aus dem Laser-Cutter
würde dann z.B. sowas rausfallen.
Also ein sehr luftiges Gehäuse, dass man dann wirklich
die Raumtemperatur messen kann und nicht die Eigentemperatur
des Prozessors. Und wenn man das Ganze dann entsprechend bestückt,
dann würde das so aussehen. Da habe ich den Bewegungsmelder, ich habe meine
Status-Leuchtdiode. Hier habe ich meinen Temperatur- und Feuchtigkeitssensor.
Hier vorne habe ich den LDR. Hier habe ich noch die Buchsen für die Fensterkontakte,
zwei Stück. Und hier gleich mit eingearbeitet, das USB-Netzteil,
um das Ding einfach in die nächste Steckdose zu stecken und dann
keine weiteren Kabel mehr zu ziehen. Wer keine Steckdose hat, kann
natürlich dann auch so eine Variante nehmen. Das ist das gleiche,
vielleicht muss ich es… naja… ein bisschen anders halten, naja,
man sieht es schlecht. Hier innen drin sieht man den Prozessor.
So. Hier sieht man den Prozessor, und die USB-Buchse nach außen zugänglich,
dass man einfach mit einem Micro-USB- Kabel drauf verbinden kann.
Ansonsten auch wieder hier oben den lichtempfindlichen Widerstand,
die Kontakte für die Fenster, Temperatur und Feuchtigkeit. Und nach vorne
den Passiv-Infrarot-Bewegungsmelder, mit Diode. Und auf der Rückseite
noch ein paar Löcher, um das ganze mit Schrauben an die Wand zu dübeln.
Man kann sich natürlich nicht nur solche Gehäuse nehmen, oder bauen.
Man kann natürlich auch andere Sachen machen. Einfach mal als Ausblick, was man
alles verwenden kann. Man kann auch bestehende Sachen nehmen.
Z. B. hier so einen schönen, alten Schalter, die man teilweise noch findet.
Wo man dann hier… schalten kann.
Und auf der Unterseite ist natürlich der ESP eingelassen.
Das ganze gibt es natürlich auch…
so, vielleicht, wenn noch jemand die alten Schalter hier kennt,
diese Bakelit-Schalter. Da wurde natürlich das Schaltelement entfernt und durch
einen Encoder ersetzt. Wenn man mal dreht, hat man natürlich dann
einen Encoder und kann damit auch einen Dimmer z. B. damit realisieren.
Was man auch noch hat, es gibt auch solche Module,
mit Touch-Zahlenfeldern. Dann einfach ein paar Platten oben und unten drauf,
und unten entsprechend wieder der ESP eingelassen. Als letztes noch
so eine schöne, alte, mechanische Klingel. Mit ‒ irgendwo ein Stift? ‒
mit DC/DC-Wandler, um von den 12 Volt auf die 5 Volt zu kommen, die der ESP braucht.
Einen Schalttransistor, um die Spulen entsprechend zu treiben.
Noch Stabilisierung über einen Kondensator und hier der ESP.
Und ich kann es auch mal umdrehen. So.
Und damit sind Sachen möglich, z. B. als Notification Device, um zu sagen,
dass eine Mail da ist, oder, bei uns im Fablab haben wir das ganze dann
mit zwei Läutwerken, um…
…um die Uhrzeit zu schlagen, in Binär natürlich,
mit ‘High’ und ‘Low’, also zwei verschiedenen Klingeltönen.
Und das ist eben alles dann als Gehäuse möglich.
Ach ja, doch, eins habe ich noch!
Auch so ein Schalter, so ein schöner, alter Bakelit-Schalter,
und dann einfach unten den ESP, einfach eingeklebt.
Ohne das Schalterelement jetzt auszutauschen, sondern original zu lassen.
Jetzt brauchen wir natürlich noch Software für das Ganze. Da gibt es jetzt zwei…
…Versionen, sage ich mal. Man kann sich natürlich die Einzel-Libraries von Github
holen. Für den DHT gibt es eine Library, für den
‒ was hatten wir noch alles? ‒ für irgendwelche anderen
I2C-Devices, für alles Mögliche gibt es Librarys, auch Webserver gibt es
mittlerweile ziemlich viele für den ESP. Wir wollen das ganze ja
an einen Server schicken, mit MQTT, auch dafür gibt es eine Library.
Das kann man sich alles herunterladen, kann das ganze irgendwie versuchen,
zusammenzumergen, dann irgendwo in der Arduino-IDE was zusammenzubasteln,
wo das ganze dann verbindet. Und dann ist man tagelang beschäftigt, bei Google
und Stackoverflow zu schauen, warum es nicht funktioniert, oder wie es dann
richtig funktioniert. Das ist so die Programmierervariante.
Aber ich habe ja gesagt, wir wollen das ganze für Leute auch machen, die jetzt
keine oder wenig Programmiererfahrung haben. Deshalb eben Version 2.
Ich nehme einfach eine fertige Software mit dem Namen ESPEasy.
Hier zu finden auf Github bzw. das Wiki dazu, einfach bei Google oder der
entsprechenden Suchmaschine „ESPEasy Wiki“ eingeben, dann kommt ihr auf die
entsprechende Seite. So, was macht jetzt die Software?
Jetzt muss ich erstmal meine Testumgebung nochmal ein bisschen erklären.
Ich habe hier ‒ da kann man ja nochmal kurz die Kamera ‒ ich habe hier
nochmal das, was ich schon gezeigt habe, jetzt mit Kabel dran. Ich habe hier unten
meinen ESP eingebaut.
Und er hängt… USB jetzt nur als Stromverbindung.
Und ich habe hier einen Banana Pi als Server und Access Point stehen.
Access Point heißt, ich habe jetzt schon eine Verbindung hergestellt zwischen
dem ESP und dem Access Point. Mein Rechner ist jetzt auch auf dem gleichen Access Point.
Und damit kann ich jetzt die Webseite von dem ESP mir anschauen.
Auf dem Banana Pi ist auch noch der MQTT Broker installiert, wo ich dann später
nochmal darauf zurückkommen will.
So.
Hier oben sieht man die IP-Adresse, d. h. ich bin jetzt direkt auf dem ESP,
der jetzt mit dieser Adresse angemeldet ist. Vielleicht muss ich noch einen Schritt
zurückgehen. Beim ersten Mal flashen mit diesem ESPEasy geht der ESP in den
Access Point Mode. Ich kann mich dann mit Handy oder Laptop darauf verbinden,
kann dann die SSID und Passwort entsprechend eintippen. Dann wird
neu gebootet, und dann ist er bereit, und ich kann dann im hausinternen Netz,
wie jetzt, einfach darauf zugreifen. Wenn ich draufgehe, habe ich erstmal
eine Übersichtsseite, mit allgemeinen Info-Daten.
Ich habe eine Karteikarte mit der Konfiguration. Wie jetzt hier,
das ist mein Access Point, mit dem entsprechenden Passwort.
Ich kann auch noch einen zweiten Access Point eintragen, als Fallback.
Ich kann natürlich auch feste Adressen vergeben, wenn ich keinen DHCP
haben will. Und ich kann auch
den Zugriff über ein Passwort schützen, wenn ich Angst habe, dass über mein
hausinternes Netz jemand dranrumspielt.
Das braucht man im Heimnetz üblicherweise nicht.
Das ist die Grundkonfiguration, um erstmal die Kommunikation herzustellen,
nach außen. Es gibt eine Hardwareseite, wo ich noch sagen kann,
wo mein I2C-Bus liegt, auf welchen Pins. Ich kann noch die Status-LED,
die hier öfter mal blau blinkt, noch sagen, auf welchem Pin die liegt,
um dann auch eben ‘Rückkopplungen’ über Verbindungen und
Datenpakete noch zu erhalten. Das wichtigste ist eigentlich dieser Reiter,
„Devices“. Hier geht es um die ganzen Sensoren, die ich angeschlossen habe
oder anschließen kann. Ich habe jetzt hier drei Sensoren aktiviert.
Die drei, die ich vorhin schon vorgestellt habe.
Ich fange jetzt einfach mal mit dem einfachsten an.
Der Passiv-Infrarotmelder gibt ja einfach nur ein Signal aus,
wenn sich jemand bewegt hat. Das heißt, ich brauche einfach nur
einen Schaltereingang. Nennt sich dann,
hier, „Switch“.
Okay, ich fange nochmal andersrum an, ich nehme erstmal einen neuen.
Ich nehme einen… hier.
Wenn ich noch nichts eingetragen habe, habe ich hier eine Auswahl,
mit Sensoren, die ich hierfür verwenden kann. Sind irgendwie,
glaube ich, so 60 Stück, oder so, oder 65 mittlerweile.
Das sind lauter Plug-Ins, die werden ständig erweitert, von irgendwelchen
Usern, die freundlicherweise eben die Plug-Ins zur Verfügung stellen.
Und damit kann ich eben so ziemlich alles, was es an Sensor-Platinen zu kaufen gibt,
auch einbinden. Wenn ich das dann mal ausgewählt habe,
dann habe ich es hier eingetragen, und kann es editieren.
Also hier habe ich einen ‘Switch’ ausgewählt.
Kann ich jetzt nicht mehr ändern, dann müsste ich es eben
rausschmeißen. Ich kann dem Device einen Namen geben. Das ist dann interessant,
wenn ich mehrere Devices vom gleichen Typ habe. Und es ist auch
interessant für das, was ich an MQTT schicke, weil das Teil des Namens ist,
des Topics ist, was bei MQTT dann verwendet wird.
Ich kann dann jetzt beim ‘Schalter’ noch sagen, ob ich einen Pull-Up haben will,
ob ich eine invertierte Logik haben will, welchen Pin ich haben will.
Da habe ich natürlich die ganze Auswahl an I/O-Pins, die eben nicht mit I2C
oder anderen festen Sachen dann belegt sind.
Ich kann sagen „normaler Switch“ oder auch „dimmer mode“ oder so.
Können wir später mal darauf eingehen.
Und das ‘delay’ ‒ komme ich beim anderen Sensor nochmal drauf. Dieser Schalter,
wenn „delay=0“ eingestellt ist, würde jetzt immer bei einer Änderung
ein Datenpaket an MQTT schicken.
Und ich kann der Variablen, die geschickt wird, auch noch einen Namen geben.
Das ist vielleicht besser zu sehen bei dem nächsten Sensor.
Das ist nämlich dieser Temperatur- und Feuchtesensor,
DHT-11 oder auch -22, je nachdem, was man verwenden will.
Hier kann ich wieder einen Namen vergeben. Ich kann sagen, er ist auf ‘diesem’ Pin.
Dann wird ja… von dem Plug-In werden mehrere Sachen unterstützt.
Da kann ich auswählen, welche.
Und ich kann jetzt noch sagen, er soll alle 10 Sekunden gesampled werden,
und der Temperaturwert eben übermittelt werden. Ich habe hier
eben zwei Kanäle, Temperatur und Feuchtigkeit, und kann irgendeinen
Namen vergeben, entsprechend für MQTT oder andere Heim-Automatisierungssysteme,
an die ich das ganze dann schicken will.
Noch der letzte, der lichtempfindliche Widerstand, mit dem ich ja die Helligkeit
abschätzen will. Hängt einfach auf einem Analogkanal. Okay ‒ auf DEM einen
Analogkanal. Ich kann noch sagen „Oversampling“, um dann eben Rauschen
rauszubekommen. Ich könnte auch noch das ganze kalibrieren, wenn ich wollte,
dass ich eben einen unteren und oberen Punkt definiere, und dazwischen
wird eben linear interpoliert. Und auch der soll jetzt alle 10 Sekunden
gesampled werden. Dann habe ich hier noch eine Einstellung, „dieser Wert soll
an Controller 1 geschickt werden“. Zu den Controllern komme ich jetzt gleich.
Und auch hier habe ich wieder einen Namen festgelegt.
Und so kann ich halt bis zu 12 Devices konfigurieren, und einfach durch Klicken
in der Web-Oberfläche dann zuweisen auf die Pins, auf die Eigenschaften,
einige Sachen eben auch skalieren.
Hier bei ‘Analog’ zum Beispiel könnte ich auch eine Formel eintippen,
oder eine einfache Formel, wo ich dann sage, ich multipliziere oder addiere
noch einen Wert dazu. Bei der Temperatur kann es sein, dass sie immer
ein Grad zu hoch oder zu tief misst, dann könnte ich hier einfach „-1“ reinschreiben.
Oder halt dann auf andere Werte skalieren.
Ich kann auch noch festlegen, wieviele Dezimalstellen an den Controller
übermittelt werden sollen. So, jetzt zu den Controllern.
Hier habe ich schon mal zwei eingetragen, auch hier wieder das gleiche
Plug-In-Prinzip. Ich habe die Auswahl von etlichen
Controllern. Also verschiedene MQTT-Varianten, die aber alle
recht ähnlich sind. Ich kann auch http-Requests abschicken, weil, an viele
Server oder auch Datenbanken kann man einfach ein GET-Request hinschicken,
und die übernehmen so die Daten.
Da können wir jetzt mal rein.
Bleiben wir mal gleich bei dem GET-Request.
Ich kann hier eine IP-Adresse sagen, wo das ganze hingeschickt werden soll,
über welchen Port. Wenn notwendig, auch, über Login.
Ich kann hier dann auch sagen, GET oder POST, oder was auch immer.
Und kann das auch hier entsprechend zusammenbauen.
Damit habe ich auch die Möglichkeit, einer InfluxDB-Datenbank z.B.
die Daten direkt hinzuschicken.
Ich will aber jetzt hier an einen MQTT-Server das ganze schicken.
Nicht ‘Server’, sondern ‘Broker’ in dem Fall.
Das ist mein Banana Pi, die Adresse, wo der Broker läuft. Der Standard-Port
ist eben die 1883. Wenn notwendig, auch mit Login.
Und das ist eine Variable, wie er das Topic für den MQTT-String
zusammenbaut. Ich habe den Systemnamen, das wäre jetzt hier
„Test-IoT“. „Task-Name“ wäre quasi der Sensor. Und „value-Name“
wäre eben z.B. Temperatur- oder Feuchtigkeit. Und damit habe ich
alles konfiguriert, was ich brauche. Und damit sollte eigentlich schon
alles funktionieren.
So, jetzt habe ich hier auf meinem Rechner
ein kleines Python-Skript, was jetzt einfach zu dem Broker eine Verbindung aufbaut
und einfach mitliest, was eben an den Broker geschickt wird. Und man sieht,
dass jetzt alle 10 Sekunden Temperatur, Feuchtigkeit und Helligkeit
geschickt wird. Und wenn ich hier mich irgendwie bewege, dann wird auch noch
ein „anyone here“ vom Infrarotsensor
eben mitgeschickt. D.h. man sieht, es funktioniert auch schon.
So, ohne dass man jetzt großartig was programmieren oder einstellen muss.
Einfach nur zusammenklicken, und das war’s.
Ich habe natürlich noch ein bisschen mehr
Möglichkeiten. Ich habe auch noch „Rules“.
Das sind dann sehr einfache Regeln, die ich noch hinterlegen kann.
Z.B. wenn der Infrarotsensor mit dem Kanal „Anyone here“ triggert, also,
sprich, wenn ich hier mich bewege und gleichzeitig der LDR einen Wert
kleiner 200, das war jetzt empirisch ermittelt, d.h. einfach, hier im Raum
wäre es dunkel. Dann soll er einfach auf einem GPIO-Pin eben den Status
von „Anyone here“ ausgeben. Das wäre jetzt die einfachste Variante von dem,
was man als Bewegungsmelder mit Lampe kennt. Kann man hier einfach als Rule
hinterlegen. Es geht noch ein bisschen komplizierter, aber jetzt bitte
keine Wunder erwarten. Also aufwändigere Sachen würde man dann auf der Serverseite
machen, hinter dem MQTT-Broker. Aber auch hier können wir als Standalone-Lösung
schon einen einfachen Bewegungsmelder, der eine Lampe schaltet, realisieren.
Es gibt natürlich auch noch jede Menge Zusatz-Tools. Um z.B. I2C-Bus zu scannen,
um herauszufinden, auf welcher Adresse jetzt mein Sensor läuft, weil, das ist
nicht immer klar bei den einfachen Modulen. Ich kann meine Settings
noch wohin speichern, ich kann neue Firmware over-se-air auch updaten.
Ich kann auch hier noch
einige Zusatzsachen einstellen, aber das würde jetzt zu weit gehen.
Auch… irgendwo war es doch… ich sehe es gerade nicht…
NTP-Server kann ich einstellen, z.B. wie ich gesagt habe, für den Stundenschlag
würde aus NTP die Zeit beziehen, und dann natürlich sekundengenau schlagen.
Pause
So. Dann wieder zurück zu meinen Folien. Damit hätten wir im Prinzip
eigentlich ein fertiges Gerät, was man einfach nur noch an die Wand schrauben
muss. Und es würde das ganze an den MQTT-Broker schicken und ich könnte dann
einen Server wie FHEM oder sowas hintendran setzen, der die Daten
entgegennimmt, und auch Hausautomatisierung machen, hier
aus der Temperatur oder Feuchtigkeit dann die Heizung entsprechend ein-/ausschalten,
irgendwelche Lichter ein-/ausschalten, oder Warnung geben, wenn noch ein Fenster
offen ist. Das ganze beruht jetzt auf dem ESP, dem alten, kleinen ESP, muss ich
dazu sagen. Die ESP32-Variante ist gerade noch im Programmieren,
ist noch nicht so richtig einsatzfähig. Wer als Beta-Version damit spielen will,
kann die gerne mal probieren. Aber das ist jetzt… bezieht sich nur auf den
kleinen ESP. Es gibt ein zweites Projekt.
Mit dem Namen EzPiC.
Jetzt hier rechts oben zu sehen. Die Grundphilosophie
ist die gleiche. D.h. ich will eine Web-Oberfläche, wo ich alles schnell
einstellen kann. Ich will mich nicht lange mit Programmierung und sowas aufhalten.
Und warum das Projekt angefangen wurde ist, ich will erstmal das ganze auf dem Pi
zum Laufen bringen. Das war der ursprüngliche Gedanke, wurde dann
erweitert. Ich will es auch noch auf einem ESP32, also der nächstgrößere ESP
mit mehr Speicher, mehr Geschwindigkeit und noch ein paar Features mehr,
auch mehr Pins. Und als Zusatzding für die Entwickler, dass die
das ganze erstmal, wenn es nicht um die reine Hardware geht, auch mal
auf dem PC testen können. Also ohne dauernd irgendwas zu programmieren
und, ja, geht nicht, und man muss jetzt mit LED-Blinken quasi debuggen,
sondern ich kann dann in einer richtigen Umgebung, z.B. atom-Umgebung,
bzw. Visual Studio Code, dann kann ich einfach rein-debuggen
und schonmal alles ausprobieren.
Das ESPEasy-Projekt ist in C und C++ geschrieben.
Das EzPiC-Projekt ist angedacht mit Python
und wurde jetzt noch erweitert mit microPython, also ein Hybrid
aus beiden Welten. Und das klappt auch schon recht gut. D.h. man kann
mit dem gleichen Source-Code-Stand sowohl microPython auf einer ESP32
fahren, als auch mit Normal-Python, also 3.4 oder höher.
Auf dem PC oder auf dem Raspberry Pi.
Der Webserver bei dem ESPEasy-Projekt ist selbergeschrieben.
Bei dem neuen Projekt wird versucht, einen fertigen Webserver, den es
als lauffähiges Projekt gibt, mit einzubinden. Das ist der ‘MicroWebSrv’.
Findet man auf Github.
Das neue Projekt ist noch in einer frühen Phase, ich dachte, dass man vielleicht
schon für den Easter-Hegg dann schon mehr zeigen kann. Aber ist noch in einer
sehr, sehr Alpha-Version. Der Grund, warum auch das neue Projekt… auf dem ESP
habe ich natürlich sehr begrenzte Ressourcen, was jetzt RAM betrifft,
was Flash betrifft, was Geschwindigkeit betrifft, auch die Pins sind sehr limitiert.
Und wenn ich in einer anderen Umgebung bin, dann kann ich mich halt
freier bewegen, und mich dann entsprechend austoben.
Ohne jetzt auf die Details einzugehen, da gibt es schon entsprechende
Konzepte. Es ist alles Plugin-basiert, dass man dann auch sagen kann,
ich habe für andere Prozessoren auch andere Module, die dann spezielle Hardware
noch unterstützen, die auf dem Prozessor möglich sind. Und was ich schon zeigen kann,
ist, eine kleine Demo, das läuft jetzt auf meinem PC, ich habe es jetzt
technisch nicht mehr geschafft, auf die Schnelle den Banana Pi dazu zu bringen.
Ich habe hier meine Web Page, ich bin jetzt quasi in dem Webserver, der quasi
in Python läuft. Ich habe hier auch schon
Devices, mit entsprechend einer Device-Liste, wo ich
Devices dazuhängen kann,
wo ich auch Devices editieren kann.
Man sieht, das sieht alles ähnlich aus wie bei dem ESPEasy-Projekt,
nur hier da mehr Ressourcen verfügbar sind, mit Bootstrap
als Oberflächen-Tool. Und
halt hier die ersten Schritte ‒ Plugin-System läuft.
Und da wäre es schön, wenn sich auch noch Entwickler dafür finden würden,
um das ein bisschen voranzubringen, um eben auch ESP32 und Raspberry Pi
noch zu unterstützen.
So, im Prinzip bin ich jetzt durch.
Wenn jetzt Fragen sind, dann bitte…
…meldet euch, Fragen zum ESPEasy-Projekt, Fragen zum
EzPiC-Projekt. Ich muss nur das Mikro weiterleiten.
Frage: Wie machst du das mit der Konfiguration der Temperatursensoren
und so? Legst du ein Thermometer daneben? Oder?
Jochen: Die Temperatursensoren, wie der DHT12, oder, was auch gern verwendet wird,
der BME218 z.B., die sind ab Werk kalibriert. Es kann halt sein, dass er
1..2 Grad oder so mal danebenliegt. Aber eigentlich kommen die Daten schon
richtig in °C, und die Feuchtigkeit schon in Prozent, d.h. da braucht man
nichts kalibrieren. Für andere Sachen, die man am Analogport anschließen will,
gibt es eben da auch Min- und Max-Eingabe,
wo man dann einfach mal die Werte…
also, sprich, man hat eine obere und eine untere Temperatur,
man schaut sich den AD-Wandler-Wert an, schreibt sich den auf,
trägt den im Edit-Feld entsprechend ein und kann dann sagen,
der obere Wert soll „das“ sein, der untere Wert soll „die“ Temperatur sein
und hat das damit kalibriert.
Sonst noch Fragen?
Könnt ihr mal durchgeben, bitte?
Frage: Hast du auch schon mal versucht, das ganze ohne Strom,
also mit Batterie zu realisieren?
Jochen: Der ESP braucht, wenn er WLAN machen will, 100 bis 200 mA.
Und damit ist eine Batterie natürlich sehr schnell leer.
Es gibt auch einen Modus, wo ich ihn in Deep-Schlaf versetzen kann,
und alle paar Sekunden aufwecken kann. Und…
…ich muss da jetzt mal hier wieder zurück auf den…
Damit kann ich natürlich Messungen machen, dass ich sage, alle Stunde wacht er
einmal auf, misst, schickt das ganze an ‒ hier unten, ‘Sleep Time’ ‒
schickt das ganze an den Server und legt sich wieder schlafen.
Damit kann man dann… wir haben es mal ausgerechnet, wenn ich alle Stunde messe,
könnte ich mit AA-Batteriezellen ein halbes/dreiviertel Jahr überbrücken.
Aber ich habe halt dann nicht kontinuierlich Werte, sondern nur
im Stundenraster.
Frage: Noch eine Frage ‒ wie weit geht denn das Wi-Fi? Das ist nur so eine kurze,
aufgedruckte Antenne. Das hat doch nicht viel Reichweite?
Jochen: Ich sage mal, halbsoweit wie ein Laptop, so mal als Faustregel.
Es gibt natürlich auch den WeMos D1 Pro, das ist das Board,
das hat noch einen Stecker drauf, da kann ich eine externe…
Da geht es ein bisschen weiter. Aber man darf halt jetzt keine…
nicht so eine gute Qualität wie jetzt eben Handy bzw. PC erwarten.
So, sonst noch Fragen?
Keine? Dann… danke für die Aufmerksamkeit!
*Beifall*
*Abspannmusik*
*Untertitel erstellt von c3subtitles.de im Jahr 2018*