< Return to Video

Easterhegg 2018 - EZ DIY IoT w/ ESP & Pi

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

more » « less
Video Language:
German
Duration:
42:39

German subtitles

Revisions