Easterhegg 2018 - EZ DIY IoT w/ ESP & Pi

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!