-
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. Mach mit und hilf uns!