Erik Bartmann
Der Bestseller-Autor Erik Bartmann hat sich ausführlich mit dem ESP8266 und dem NodeMCU beschäftigt. Heraus gekommen ist dabei Das ESP8266-Praxisbuch, in dem er die Leser Schritt für Schritt in die Arbeit mit diesen neuen, preiswerten Bauteilen einführt, mögliche technische Stolpersteine ausführlich behandelt und in zahlreichen Projekten die Praxistauglichkeit – angefangen bei einem selbst gebauten Webserver bis hin zu klugen Relay-Ansteuerung – belegt.
SHARE
Elektor-Verlag GmbH 52072 Aachen www.elektor.de
Mittlerweile existiert auch das Entwickler-Board NodeMCU, auf dem der ESP8266-Chip mit einem USB/Seriell-Adapter versehen wurde. Mit den integrierten Sockelleisten ist ein direkter Einsatz auf üblichen Breadboards möglich. Über den USB-Anschluss wird das Board mit Strom versorgt und kann über eine Software direkt angesprochen werden. Auch das NodeMCU-Board ist sehr preiswert und bereits für unter 5 Euro zu haben.
DESIGN
ISBN 978-3-89576-321-2
DAS ESP8266-PRAXISBUCH
●
Erik Bartmann ist Bestseller-Autor mit Büchern zu den Themen Arduino und Raspberry Pi. Er arbeitet als Software- bzw. Datenbankentwickler beim führenden ITInfrastrukturdienstleister in Europa. Mehr zu ihm unter www.erik-bartmann.de
Der ESP8266 ist ein programmierbares WLAN-Funkmodul mit zahlreichen Schnittstellen wie UART, I²C und SPI. Das Board ist sehr preiswert und bereits für unter 3 Euro verfügbar. Die UART-Schnittstelle sorgt dabei für eine einfache Integration in Mikrocontrollerprojekte. Das ESP8266-Modul kann hervorragend mit dem Arduino zusammenarbeiten und ermöglicht ihm über die serielle Schnittstelle den Zugang zum Netzwerk und Internet. Es existiert eine Implementierung des ESP8266Moduls in die Arduino-Entwicklungsumgebung. Aber auch als Standalone-Modul kann das ESP8266 eigenständig Programme abarbeiten und mit dem Internet kommunizieren, da es über einen eigenen Mikroprozessor und Speicher auf dem Board verfügt.
DAS ESP8266-PRAXISBUCH
DAS ESP8266-PRAXISBUCH
MIT NodeMCU UND ESPlorer
ERIK BARTMANN
MIT NodeMCU UND ESPlorer
Erik Bartmann LEARN
DESIGN
SHARE
LEARN
LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHAR ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● GN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHA ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ●
Das ESP8266-Praxisbuch
● Erik Bartmann
an Elektor Publication LEARN
ESP8266 DE 160912.indd 3
DESIGN
SHARE
04-10-1640 15:00
●
© 2016: Elektor Verlag GmbH, Aachen.
●
Alle Rechte vorbehalten.
1. Auflage 2016
Die in diesem Buch veröffentlichten Beiträge, insbesondere alle Aufsätze und Artikel sowie alle Entwürfe, Pläne, Zeichnungen und Illustrationen sind urheberrechtlich geschützt. Ihre auch auszugsweise Vervielfältigung und Verbreitung ist grundsätzlich nur mit vorheriger schriftlicher Zustimmung des Herausgebers gestattet. Die Informationen im vorliegenden Buch werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Die in diesem Buch erwähnten Soft- und Hardwarebezeichnungen können auch dann eingetragene Warenzeichen sein, wenn darauf nicht besonders hingewiesen wird. Sie gehören dem jeweiligen Warenzeicheninhaber und unterliegen gesetzlichen Bestimmungen. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autor können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für die Mitteilung eventueller Fehler sind Verlag und Autor dankbar. Umschlaggestaltung: Elektor, Aachen Lektorat: Volker Bombien, Köln Satz und Aufmachung: D-Vision, Julian van den Berg | Oss (NL) Druck: Media-Print Informationstechnologie GmbH, Paderborn Printed in Germany
●
ISBN 978-3-89576-321-2
Elektor-Verlag GmbH, Aachen www.elektor.de
Elektor ist Teil der Unternehmensgruppe Elektor International Media (EIM), der weltweit wichtigsten Quelle für technische Informationen und Elektronik-Produkte für Ingenieure und Elektronik-Entwickler und für Firmen, die diese Fachleute beschäftigen. Das internationale Team von Elektor entwickelt Tag für Tag hochwertige Inhalte für Entwickler und DIYElektroniker, die über verschiedene Medien (Magazine, Videos, digitale Medien sowie Social Media) in zahlreichen Sprachen verbreitet werden. www.elektor.com
LEARN
ESP8266 DE 160912.indd 4
DESIGN
SHARE
04-10-1640 15:00
Inhalt Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Das Internet der Dinge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Kapitel 1 • Das ESP8266-Modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Die Vorstellung des ESP8266 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Die Problematik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Der Spannungsteiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Der Level-Shifter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Der Selbstbau eines passenden Adapters für das Breadboard . . . . . . . . . . . . . . . . . . 25 Das ESP-01-Modul mit einer Firmware versehen . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 ESP8266-Firmware-Upload unter Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Das Firmware-Upload für MicroPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 Der Ausblick auf ein Arduino-Shield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 Details zu weiteren ESP8266-Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 Kapitel 2 • Das NodeMCU-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 Die Entwickler-Boards – NodeMCU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 ESP12E Devkit V2: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 ESP-12E NodeMCU V3: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 ESP-12 NodeMCU V1: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 ESP8266 Thing Dev . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 Olimex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 FlyFun Tech Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 ESP8266-Demo-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 ESP13 Arduino-Shield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Kapitel 3 • Der FTDI-Adapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Die serielle Schnittstelle über USB verfügbar machen . . . . . . . . . . . . . . . . . . . . . . . . 64 Ein FTDI-Adapter von Sparkfun . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Ein FTDI-Adapter von Adafruit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 Zwei FTDI-Adapter aus China . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 Zusätzliche Informationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Kapitel 4 • Eine kleine Geschichte der Elektronik . . . . . . . . . . . . . . . . . . . . . . . . . . 70 Die Elektronik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
●5
ESP8266 DE 160912.indd 5
04-10-1640 15:00
Das ESP8266-Praxisbuch Was ist Elektronik? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 Der Fluss der Elektronen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 Die elektrische Ladung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 Der elektrische Strom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Die elektrische Spannung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 Der Widerstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 Das Ohmsche Gesetz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 Der geschlossene Stromkreis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 Bauteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 Passive Bauelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 Aktive Bauelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 Der Festwiderstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Der veränderliche Widerstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 Der Trimmer und das Potentiometer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 Der lichtempfindliche Widerstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 Der temperaturempfindliche Widerstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 Der Kondensator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Die Diode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 Der Transistor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 Der integrierte Schaltkreis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 Die Leuchtdiode – LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Weitere interessante Bauteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Der Taster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Das Relais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Der Servomotor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Kapitel 5 • Elektronische Grundschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Basisinformationen zu Grundschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Mehrere Widerstände . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Die Reihenschaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Die Parallelschaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 Berechnung eines Vorwiderstands für eine LED . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
●6
ESP8266 DE 160912.indd 6
04-10-1640 15:00
Inhalt Berechnung von Widerstandswerten in verschiedenen Konstellationen . . . . . . . . . . . 113 Mehrere Kondensatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 Die Reihenschaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 Die Parallelschaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 Berechnung von Kondensatorwerten in verschiedenen Konstellationen . . . . . . . . . . . 116 Eine Transistoransteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 Die Freilaufdiode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 Kapitel 6 • Angesagtes Werkzeug und der Umgang damit . . . . . . . . . . . . . . . . . . 121 Was brauchen wir für das reibungsfreie Arbeiten? . . . . . . . . . . . . . . . . . . . . . . . . . 121 Die beiden meistgebrauchten Zangen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 Schraubendreher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 Das Multimeter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 Die Durchgangsprüfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Die Diodenmessung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 Die Widerstandsmessung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 Die Spannungsmessung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Die Strommessung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 Externe Spannungsquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Eine Lötstation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 Die Dritte Hand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 Eine Widerstandsbiegelehre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 Verschiedene Breadboards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 Die flexiblen Steckbrücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Das Oszilloskop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Kapitel 7 • Kabel, Strippen und Löten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Wir stellen Kabelverbindungen her . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Wir löten einen Widerstand ein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 Kapitel 8 • Das Beschaffen der Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Es dauert leider etwas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Schnell geht‘s bei Elektor – leider nur der ESP8266 . . . . . . . . . . . . . . . . . . . . . . . . 151 Bestellen bei Amazon.de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
●7
ESP8266 DE 160912.indd 7
04-10-1640 15:00
Das ESP8266-Praxisbuch Ebay liefert auch zügig . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Bestellen direkt in China . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 Zollbestimmungen beachten! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Elektronikkleinteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156 Kapitel 9 • Das ESP8266-Simpleboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 Wir bauen uns eine Developer-Platine für NodeMCU-Boards . . . . . . . . . . . . . . . . . . 158 www.exp-tech.de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 Kapitel 10 • Die Entwicklungsumgebung Esplorer . . . . . . . . . . . . . . . . . . . . . . . . 163 Die Entwicklungsumgebung Esplorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Das Startfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 Das Syntax-Highlighting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 Code-Vervollständigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Code-Snippets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Die Verbindungsaufnahme zum ESP8266 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 Schritte für das Erstellen und Uploaden eines Lua-Skriptes . . . . . . . . . . . . . . . . . . . 167 Das Formatieren des Dateisystems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Informationen über das Dateisystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 Die Anzeige der auf dem Dateisystem vorhandenen Skripte . . . . . . . . . . . . . . . . . . 170 Starten des Esplorers unter Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Kapitel 11 • Die Skriptsprache Lua . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Grundlegendes zu Lua . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Relationale Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Verknüpfungsoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Verzweigungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
●8
ESP8266 DE 160912.indd 8
04-10-1640 15:00
Inhalt Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Einzeilige Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Mehrzeilige Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Das Einbinden von Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 Hack 1: Hello World! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 Das "Hello-World!" des ESP8266 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 GPIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 Der Pinmode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 Das Ansteuern des gewünschten Pins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 Eine kleine Entwicklerplatine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 Der Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 Der Schaltungsaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 Die Programmierung unseres Skriptes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 Einen GPIO-Pin als Eingang programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Hack 2: Ausbau der Entwicklungsplatine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 Stufe 2 der Entwicklungsplatine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 Hack 3: Eine externe Spannungsversorgung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 Wir realisieren eine externe Spannungsversorgung . . . . . . . . . . . . . . . . . . . . . . . . 196 Der Spannungsregulator LD33 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 Eine weitere Variante der Spannungsregulierung . . . . . . . . . . . . . . . . . . . . . . . . . . 199 Hack 4: Der ESP8266 im Zusammenspiel mit dem Arduino . . . . . . . . . . . . . . . . . 202 Das ESP-01-Modul und der Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 Der Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 Die serielle Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 Der Arduino-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 Die Kommunikation über AT-Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 Die Abfrage der Firmware-Version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 Die Abfrage von WiFi-Hotspots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
●9
ESP8266 DE 160912.indd 9
04-10-1640 15:00
Das ESP8266-Praxisbuch Die Anpassung der Baudrate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Einen Reset ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Hack 5: Temperaturmessung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Wir messen die Temperatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Der Arduino-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 Hack 6: Ein ESP-01 Arduino-Shield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 Wir basteln uns ein Arduino-Shield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 Die Trägerplatine und Header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 Hier stimmt was nicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232 Weitere benötigte Bauteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 Der Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Die Arduino-Pins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Das fertige Shield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 Hack 7: Die Arduino-IDE und ESP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 Die Unterstützung des ESP-Moduls durch die Arduino-IDE . . . . . . . . . . . . . . . . . . . . 239 Die Einbindung der Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 Die Verkabelung des ESP-01-Moduls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 Der Arduino- bzw. ESP-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 Der Schaltungsaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 Hack 8: Der IO-Expander . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 Wir erweitern die vorhandene Schnittstelle des ESP-01 . . . . . . . . . . . . . . . . . . . . . . 244 Der I²C-Bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 Der Port-Expander MCP23017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 Die Adressierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 Die internen Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 Der Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 Der ESP-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 Ein eigenes IO-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 Hack 9: Der Servomotor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 Wir steuern einen Servomotor an . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 Der Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
● 10
ESP8266 DE 160912.indd 10
04-10-1640 15:00
Inhalt Der Schaltungsaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 Die Programmierung über einen ESP-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Die Steuerung über eine Android-App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 Die Programmierung des WiFi-Servers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 Eine galvanische Trennung zwischen ESP-Modul und Servo . . . . . . . . . . . . . . . . . . . 275 Hack 10: Das LCDisplay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 Wir zeigen Informationen auf einem LCDisplay an . . . . . . . . . . . . . . . . . . . . . . . . . 278 Die Installation der Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 Das LCDisplay-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 Hack 11: Der WiFi-Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 Ist unser WiFi verfügbar? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 Hack 12: Der Webserver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 Ein Webserver wird eingerichtet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 Vorbereitungen zur Programmierung unter Lua . . . . . . . . . . . . . . . . . . . . . . . . . . . 291 Grundlegende Informationen zum Webserver . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 Eine Quick&Dirty-Lösung für eine Webseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 Eine bessere Webseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 Eine interaktive Seite zur Steuerung der GPIO-Pins . . . . . . . . . . . . . . . . . . . . . . . . 298 Hack 13: Eine Smartphone App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 Wir programmieren eine Android-App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 Vorbereitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 Der GPIO-Manipulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 Der Upload der App auf das Smartphone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311 Hack 14: Die Puls-Weiten-Modulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 Die Ansteuerung mit einer Puls-Weiten-Modulation . . . . . . . . . . . . . . . . . . . . . . . . . 314 Die Ansteuerung mit Lua . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 Hack 15: PWM über Webserver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 Die Ansteuerung mit einer Puls-Weiten-Modulation über einen Webserver . . . . . . . . . 320 Vorbereitung des Webservers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 Implementierung der PWM-Funktionalität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 Hack 16: Relais-Ansteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
● 11
ESP8266 DE 160912.indd 11
04-10-1640 15:00
Das ESP8266-Praxisbuch Die Ansteuerung mehrerer Relais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 Der Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 Der Schaltungsaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 Der Arduino- bzw. ESP-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 Die Realisierung der Ansteuerung auf einem Relais-Board . . . . . . . . . . . . . . . . . . . . 343 Hack 17: Internet-Zeit anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Wir greifen die Zeit von einem Server ab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Der Lua-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Hack 18: MQTT-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350 Grundlagen zu MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350 Das Lua-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 Hack 19: MQTT erweitert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 Wir programmieren in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 Die Speicherung der Messwerte in eine Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . 369 Die Installation von paho-MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 Die Installation von SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 Ein paar nützliche Datenbankgrundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 Das Anlegen einer Datenbank und Tabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 Das Einfügen eines Datensatzes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 Den Inhalt einer Tabelle löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 Das Python-Skript speichert die Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 Hack 20: Analog/Digital-Wandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 Die analoge Welt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 Der Arduino- bzw. ESP-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 Der Anschluss eines externen Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 Der lichtempfindliche Widerstand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 Hack 21: Wir twittern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Wir bringen Twitter ins Spiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Der ESP-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396 Ein ESP-Alarmsystem mit Helligkeitssensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399 Ein ESP-Alarmsystem mit PIR-Motion-Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
● 12
ESP8266 DE 160912.indd 12
04-10-1640 15:00
Inhalt Hack 22: Der ESP-Robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 Wir bauen einen Roboter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 Wir steuern einen Motor an . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 Die H-Bridge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407 Der 5V-Spannungsregler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409 Der endgültige Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 Das Fahrgestell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412 Die Steuerplatine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413 Der ESP-Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415 Die Header-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418 Die Klassendefinitions-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419 Die Sketch-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421 Die Smartphone-App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424 Hack 23: Wir entwickeln ein Lua-Modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Die Ansteuerung des Port-Expanders MCP23017 über ein Lua-Modul . . . . . . . . . . . . 427 Die Erstellung eines Lua-Moduls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Das Port-Expander-Modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
● 13
ESP8266 DE 160912.indd 13
04-10-1640 15:00
Kapitel 1 • Das ESP8266-Modul
Kapitel 1 • Das ESP8266-Modul Die Vorstellung des ESP8266
Nun wird es aber Zeit, einen Blick auf das ESP8266-Modul zu werfen. Ich fange am besten mit der ersten Version ESP-01 an, denn die Anzahl der Pins ist recht übersichtlich und es besteht kein Grund zur Sorge, gleich am Anfang mit zu vielen Informationen überhäuft zu werden. Auf der folgenden Abbildung handelt es sich um eine recht kleine Platine mit den Maßen 1,4 cm x 2,4 cm. Auf ihr befinden sich zwei Chips, ein Quarz, zwei Leuchtdioden (Power und UART-Kommunikation) und ein paar Widerstände. Die glänzende Schlangenlinie ist die auf der Platine aufgedruckte Antenne zur Funkverbindung über WiFi.
Abbildung 1 Das ESP-01-Modul Auf der Unterseite gibt es eine zweireihige Stiftleiste mit 8 Pins, die zur Spannungsversorgung und Ansteuerung des Moduls dient. Wir sehen uns das gleich genauer an. Durch die Anordnung der Stiftleiste bzw. ihre Pinabstände ist es leider nicht so ohne Weiteres möglich, das Modul auf ein Breadboard aufzustecken, ohne Kurzschlüsse zwischen den Pins herzustellen. Es ist eine kleine Adapterplatine notwendig, die wir uns jedoch recht einfach selbst herstellen können. Dazu später mehr. Doch nun zu den erwähnenswerten Details des ESP8266: SoC – System on a chip Auf der Trägerplatine befindet sich ein SoC (System on a chip). Unter dieser Bezeichnung versteht man die Integration verschiedener Baugruppen bzw. Funktionen eines Systems auf einem einzigen integrierten Schaltkreis (IC). Der Baustein hat die Bezeichnung ESP8266EX und vereint die folgenden Funktionen in sich, wobei ich mich nur auf einige wenige wichtige beziehe: • ARM-Prozessor mit 32 Bit und 80MHz/160MHz Taktfrequenz • WiFi-Unterstützung durch 802.11 b/g/n Protokoll • TCP/IP Protokoll-Stack • SRAM-Speicher • Interfaces: SDIO 2.0, SPI, I²C, GPIO, UART Speicher Neben dem ESP8266EX befindet sich ein Speicherbaustein, der jedoch je nach Ausführung variieren kann. Es gibt Module, auf denen ein EEPROM vom Typ 25Q41BT verbaut ist. Andere können ein Flash-ROM besitzen. Genauere Details sind vom jeweiligen Hersteller zu beziehen und sollen uns nicht weiter interessieren. Dieser Speicher, der in verschiedene Bereiche unterteilt ist, wird genutzt, um dort Programme abzulegen. Eine Speicheraufteilung ist unter der folgenden Internetadresse zu finden:
● 19
ESP8266 DE 160912.indd 19
04-10-1640 15:00
Das ESP8266-Praxisbuch
Kapitel 2 • Das NodeMCU-Board Die Entwickler-Boards – NodeMCU
Wer sich über die sehr eingeschränkte Anzahl der zur freien Verfügung stehenden GPIOPins beim ESP-01-Modul ein wenig aufgeregt hat, dem kann geholfen werden. Es wurden zahlreiche unterschiedliche Entwickler-Boards hergestellt, die unter dem Namen NodeMCU angeboten werden und auf dem ESP-12-Modul fußen. Hinter dieser Bezeichnung verbergen sich einerseits eine Hardware, die ich gleich zeigen werde, und andererseits auch eine spezielle auf Lua basierende Firmware. Interessante Hinweise finden sich unter der Internetadresse: https://en.wikipedia.org/wiki/NodeMCU Auf der folgenden Abbildung habe ich einige dieser Gattung nebeneinander aufgereiht:
Abbildung 1 Eine kleine Sammlung von NodeMCU-Boards (Teil 1) Sie unterscheiden sich in Größe, Form und Farbe und besitzen neben verschiedenen Spezifikationen – bis auf das rechte Board von Olimex – allesamt eine Möglichkeit, direkt mit dem USB-Port eine Verbindung aufzunehmen. Das erspart uns das separate Verkabeln über einen speziellen FTDI-Adapter und ist eine elegante, komfortable Lösung, die die Kommunikation sehr vereinfacht. Board 1 bis 3 verfügen über einen kostengünstigen CH340-Chip, der in Konkurrenz zum üblichen FTDI-Chip steht, und lediglich das Sparkfun-Board besitzt noch einen FTDI-Chip. Zur Installation des Treibers unter Windows bzw. Mac OS X habe ich die Links weiter unten angegeben. Beim Betriebssystem Linux ist keine Installation erforderlich. Die Boards werden mit unterschiedlicher Firmware ausgeliefert, wobei einige eine AI-Thinker-Software und andere eine Lua-basierte NodeMCU-Software enthalten. Dem individuellen Neu-Flashen steht jedoch nichts im Wege. Die meisten Boards besitzen schon auf der kleinen Platine zwei Mikro-Taster, die für einen Reset und für das Flashen genutzt werden, und sind allesamt Breadboard-friendly. Es stehen 17 GPIO-Pins zur Verfügung und die, die mit einem Tilde-Zeichen (~) versehen sind – acht an der Zahl – besitzen PWM-Funktionalitäten. Hinsichtlich einer Analog/Digital-Wandlung ist lediglich ein Eingang (A0) mit einer
● 54
ESP8266 DE 160912.indd 54
04-10-1640 15:00
Das ESP8266-Praxisbuch
Kapitel 3 • Der FTDI-Adapter Die serielle Schnittstelle über USB verfügbar machen
Was ein FTDI-Adapter ist, haben wir schon im vorangegangenen Kapitel gesehen. Die Bezeichnung FTDI kommt übrigens von der Firmenbezeichnung Future Technology Devices International. Diese Firma hat die USB-RS232-Chips für den Zugriff auf serielle Ports über USB zur Verfügung gestellt. Unter der folgenden Internetadresse sind weitere Informationen zu erhalten: https://de.wikipedia.org/wiki/FTDI Wichtig ist hier ein Hinweis über den Umgang mit gefälschten Chips, die durch ein besonderes Treiber-Update ihre Funktion einstellen. Alles Weitere auf der genannten Internetseite. Mittlerweile gibt es eine schier unübersichtliche Vielfalt an unterschiedlichen FTDI-Adaptern, die auch mit unterschiedlichen Chips angeboten werden. Namhafte Hersteller wie z. B. Sparkfun oder Adafruit bieten hochwertige Module an, die stabil funktionieren und für Spannungen von 3,3V und 5V angeboten werden, wobei in vielen Fällen zwischen beiden Spannungen entweder durch einen Mikroschalter oder durch kleine Lötarbeiten umgeschaltet werden kann. Mehr dazu gleich. Natürlich sind auch recht günstige Adapterplatinen aus China zu bekommen, die nur einen Bruchteil dessen kosten, was für die von Sparkfun oder Adafruit zu berappen ist. Die Lieferzeiten betragen jedoch – und darüber sollte man sich im Klaren sein – meistens 2 bis 4 Wochen. Das stellt in meinen Augen kein allzu großes Problem dar, denn bei der Planung kann man dies berücksichtigen. Es kann jedoch hier und da zu Problemen kommen, denn die Spannungsversorgung ist nicht immer 100%ig stabil, so dass gerade der Upload der Firmware problembehaftet ist. Es kann also von Vorteil sein, sich mehr als nur ein Modul zu bestellen, um etwaigen Toleranzen zu begegnen, was sich natürlich wieder preislich bemerkbar macht. Ein Richtig bzw. Falsch bei der Entscheidung gibt es nicht, denn es gibt recht gute chinesische Firmen, die brauchbare FTDI-Adapter anbieten. Sehen wir uns jetzt ein paar FTDI-Adapter an. Hinsichtlich der erforderlichen Treiber werde ich dies in dem jeweiligen Hack erwähnen. Ein FTDI-Adapter von Sparkfun
Der FTDI-Adapter von Sparkfun ist in zwei Versionen für 3,3V und 5V zu bekommen. Es ist also wichtig, zu kontrollieren, welcher Adapter zu bestellen ist oder – falls schon vorhanden – welcher vorliegt. Das ist aber sehr leicht zu erkennen, denn auf der Platine selbst ist die verwendete Spannung aufgedruckt, wie das auf der folgenden Abbildung zu erkennen ist:
● 64
ESP8266 DE 160912.indd 64
04-10-1640 15:00
Das ESP8266-Praxisbuch
Kapitel 4 • Eine kleine Geschichte der Elektronik Die Elektronik
In diesem einleitenden Kapitel über die Elektronik werden ich einige Grundkenntnisse vermitteln und besprechen. Gerade wenn es darum geht, die späteren Hacks zu verstehen und umzusetzen, ist ein gewisses Maß an Verständnis der Materie schon sinnvoll. Es geht dabei nicht um ein blindes Auswendiglernen, so wie das meistens in der Schule auch heute noch praktiziert wird. In den verschiedenen Fächern werden bestimmte Themen gemäß Lehrplan – oder besser Leerplan – vorgegeben, die es dann zu rezitieren gilt, um genau das wiederzugeben, was vom Lehrer erwartet wird. Eigenständiges Denken bleibt meist auf der Strecke und ist auch nicht gewünscht. Ich werde es in diesem Buch anders machen. Die von mir gezeigten Hacks mit den Umsetzungen stellen lediglich Möglichkeiten dar, denn es gibt zu den von mir behandelten Bereichen zahllose Lösungen. Ich würde mich freuen, wenn Sie als Leser und Bastler das Ganze nicht so ernst und als ultimative Vorlage sehen. Experimentieren und finden Sie andere Wege und machen Sie es anders, eleganter und hoffentlich besser. Lassen Sie sich auch nicht durch Fehlschläge demotivieren und aus der Kurve schmeißen. Wie oft habe ich beim Experimentieren Bauteile in Rauch aufgehen lassen und stunden-, wenn nicht tagelang über Problemen gebrütet, bis ich endlich die Lösung finden konnte. Natürlich stellt dieses Kapitel kein Elektronik-Kompendium dar, und das soll es auch nicht sein. Wenn Sie schon Grundkenntnisse der Elektronik besitzen, können Sie dieses Kapitel mit ruhigem Gewissen übersprungen werden. Falls nicht, dann lohnt sich ein Blick – oder auch zwei – allemal. Doch legen wir los. Was werden wir besprechen: • Grundlagen der Elektronik • Was sind Strom, Spannung und Widerstand und wie hängen sie zusammen? • Das Ohmsche Gesetz • Der geschlossene Stromkreis • Was ist der Unterschied zwischen aktiven und passiven Bauteilen? • Grundlegende elektronische Bauteile Was ist Elektronik?
In unserer hochtechnisierten Zeit ist die Elektronik aus dem Leben nicht mehr wegzudenken. Sie ist für uns sowohl sichtbar als auch unsichtbar vorhanden. Sie kann sich offensichtlich in der Unterhaltungselektronik wie z. B. Fernsehgeräten, Bluray-Playern, Smartphones, MP3-Playern oder Spielekonsolen erkennbar sein, aber auch versteckt und im Hintergrund z. B. in Herzschrittmachern, Hörgeräten oder KFZ-Steuerungen ihre Dienste verrichten. Würden all diese elektronischen Geräte auf einmal ausfallen, hätte das dramatische Konsequenzen. Was kann man sich unter dem Begriff Elektronik vorstellen? Es hat irgendetwas mit Elektronen zu tun, denn daher kommt der Name. Bei Elektronen handelt es sich um elektrisch geladene Elementarteilchen, die sich in einem Leiter wie z. B. Kupferdraht bewegen und für
● 70
ESP8266 DE 160912.indd 70
04-10-1640 15:00
Das ESP8266-Praxisbuch
Kapitel 5 • Elektronische Grundschaltungen Basisinformationen zu Grundschaltungen
An dieser Stelle möchte ich ein paar grundlegende Informationen zu einfachen Themen liefern, die beim Verständnis komplexerer Schaltungen hilfreich sind. Im vorangegangenen Kapitel wurden einige wichtige Bauteile einzeln aufgezählt, doch es wird natürlich erst interessant, werden sie in einer Schaltung als Einheit arbeiten. Bevor wir jedoch beginnen, möchte ich ein paar Worte zu den Einheiten verlieren, denn mit ihnen kommen wir immer wieder in Berührung. Da wird mit Begriffen wie Kilo, Mega, Giga oder Milli, Mikro oder Nano hantiert. Was verbirgt sich dahinter? Nehmen wir einen Widerstand, der einen großen Wert vorweist und z. B. 1.000.000 Ohm besitzt. Diese Schreibweise ist etwas umständlich, denn die vielen Nullen stören irgendwie. So hat man sich ein System überlegt, das Ganze zu verkürzen. 1.000 Ohm entsprechen Kilo, 1.000.000 Ohm Mega, 1.000.000.000 Giga. Natürlich geht das auch in die andere Richtung für sehr kleine Werte. Am besten schauen wir uns die folgende Tabelle an, in der die gängigsten Einheiten mit ihren Werten zu finden sind und vom Größten zum Kleinsten gegangen wird: Einheit
Größe
Exponent
Giga (G)
1.000.000.000
109
Mega (M)
1.000.000
10⁶
Kilo (K)
1.000
103
Hundert
100
102
Zehn
10
101
Eins
1
100
Zehntel
0,1
10-1
Hundertstel
0,01
10-2
Milli (m)
0,001
10-3
Mikro (µ)
0,000001
10-6
Nano (n)
0,000000001
10-9
Piko (p)
0,000000000001
10-12
Die großen Werte kommen für Bauteile in der Regel bei Widerständen vor, die kleinen bei Kondensatoren. Mehrere Widerstände
Ein einzelner Widerstand arbeitet in einem Stromkreis als Strombegrenzer, um darüber die gewünschten Spannungen an den unterschiedlichsten Stellen einer Schaltung zu erreichen. Als Vorwiderstände für Leuchtdioden, als Basis-Vorwiderstände für Transistoren kommen sie zum Einsatz. In Reihe geschaltet arbeiten sie als Spannungsteiler oder kommen zur Arbeitspunkteinstellung bei Transistoren oder Operationsverstärkern zum Einsatz. Fangen wir mit den einfachsten Kombinationen an. Was passiert, wenn Widerstände in Reihe oder parallel verschaltet werden? Die Reihenschaltung
Fügt man zwei oder mehr Widerstände in Reihe zusammen, dann addieren sich die Widerstandswerte zu einem Gesamtwiderstand:
● 106
ESP8266 DE 160912.indd 106
04-10-1640 15:00
Kapitel 6 • Angesagtes Werkzeug und der Umgang damit
Kapitel 6 • Angesagtes Werkzeug und der Umgang damit Was brauchen wir für das reibungsfreie Arbeiten?
Es gibt für einen Handwerker eigentlich nichts Schlimmeres, als mit dem falschen Werkzeug zu arbeiten. Oder es fehlen die wichtigsten und grundlegendsten Hilfsmittel, die einem die Arbeit erleichtern sollen. Da ist Frust vorprogrammiert und es nützt wenig, hochmotiviert ans Werk zu gehen, denn das Ergebnis steht schon vorher fest: Daraus wird in den wenigsten Fällen etwas Gutes! Bei der Beschaffung von Equipment für einen angehenden Elektroniker spielt natürlich auch der Geldbeutel eine entscheidende Rolle, doch es lohnt sich, hier und da etwas zu investieren. Zu Beginn sind relativ teure Messgeräte wie z. B. ein Oszilloskop oder ein Logic-Analyzer nicht unbedingt erforderlich, sie können später nachgekauft werden. Die folgende Auflistung stellt in meinen Augen ein absolutes Must-Have dar und sollte bei keinem ernsthaft interessierten Bastler fehlen. Es ist auch nicht immer notwendig, neue Werkzeuge zu kaufen, und es lohnt ein Blick in Foren oder Plattformen für gebrauchtes Material. Da sind manchmal echte Schnäppchen zu finden. Die beiden meistgebrauchten Zangen
Manch einer besitzt ein Sortiment von 10 verschiedenen Zangen, doch ich habe im Laufe der Jahre feststellen müssen, dass ich meistens mit den beiden hier gezeigten Zangen ausgekommen bin:
Abbildung 1 Seitenschneider und Abisolierzange Es handelt sich um einen Seitenschneider (links) zum Durchtrennen von Kabeln oder ähnlichem Material, das einer Kürzung bedarf,und einer Abisolierzange für das Entfernen der Kabelummantelung. Hier ist darauf zu achten, dass der Schneideabstand ganz langsam auf den vorherrschenden Aderdurchmesser angepasst wird, denn ein zu geringer Abstand durchtrennt unweigerlich die Ader. Schraubendreher
Kleine Uhrmacherschraubendreher eignen sich hervorragend zum Festschrauben von Kabeln an Schraubklemmen, wie man das auf der folgenden Abbildung sieht:
● 121
ESP8266 DE 160912.indd 121
04-10-1640 15:00
Das ESP8266-Praxisbuch
Kapitel 7 • Kabel, Strippen und Löten Wir stellen Kabelverbindungen her
Wenn es um das Herstellen von Kabelverbindungen geht, ist einiges zu beachten. Der Umgang mit Kabeln birgt einige Gefahren in sich, wobei ich nicht Gefahren für Leib und Leben meine, sondern eher für den reibungsfreien Betrieb von Schaltungen. Es gibt die unterschiedlichsten Kabel für alle möglichen Einsatzgebiete:
Abbildung 1 Verschiedene Kabel in unterschiedlichen Farben Für unsere Hacks verwende ich keine starren Kabel, sondern sogenannte Litze, die aus sehr dünnen und feinen Einzeldrähten bestehen:
Abbildung 2 Litze Und genau diese Litze stellt bei unbedachter Handhabung eine Gefahr dar, denn die kleinen Drähte sind zeitweise sehr widerspenstig und aufgrund der geringen Größe auch nur schwer zu erkennen. Da kann es schon einmal dazu kommen, dass sich ein kleiner Draht aus dem Verbund der anderen gehorsamen Drähten löst und ein Eigenleben anstrebt. Und das führt nicht selten zu Kurzschlüssen. Auf der nächsten Abbildung zeige ich, wie man
● 142
ESP8266 DE 160912.indd 142
04-10-1640 15:01
Kapitel 8 • Das Beschaffen der Hardware
Kapitel 8 • Das Beschaffen der Hardware Es dauert leider etwas
Mit dem Erstarken der Maker-Bewegung ist auch die Infrastruktur angewachsen, die dafür sorgt, dass Bastler heute schnell und zuverlässig Elektronikbauteile nach Hause geschickt bekommen. Wie bequem ist es doch, an einen Elektronikversender am Mittwoch eine Bauteileliste zu schicken und pünktlich am Freitag die Sendung im Briefkasten vorzufinden. Längst schienen die Zeiten vorbei, in denen man bei seinem Elektronikhändler vor Ort nach drei Wochen Wartezeit endlich seine Bestellung abholen durfte, um danach einen anderen Händler aufzusuchen, um weitere Bauteile zu erstehen, die man für sein Bastelprojekt ebenfalls benötigte. Keine Warterei mehr, keine Teillieferungen mehr, alles ist rechtzeitig zum Wochenende da. Leider funktioniert diese tolle Logistik nur für Elektronikbauteile, die bereits ihren festen Platz in der Maker-Bewegung gefunden haben. Es ist heutzutage ein Leichtes, ein Arduino-Board oder einen Raspberry Pi zu bestellen, denn jeder Elektronikversender in Deutschland, Österreich oder der Schweiz hat diese Teile vorrätig. Bei Bauteilen wie dem ESP8266-Modul oder dem NodeMCU-Board sieht die Sache leider schon nicht mehr ganz so toll aus. Hier erntet man manchmal noch immer ein Schulterzucken beim Elektronikversender seiner Wahl, wenn man nach "diesem WLAN-Modul aus China" fragt. Dabei kennt das jeder: Wenn ich die gewünschten Bauteile nicht in einem recht kurzen Zeitraum erhalte, steigt die Gefahr exponentiell, dass mein Projekt niemals das Licht der Welt erblickt; übrig bleiben ein paar Bauteile, von denen man sich später nur ungern trennt, auch wenn man sie für nichts anderes gebrauchen kann. Die in diesem Buch verwendeten Bauteile wie das ESP8266 oder das NodeMCU sind noch nicht so bekannt, dass sie von jedem deutschsprachigen Elektronikversender auf Lager gehalten werden. Deswegen müssen Sie vorerst noch auf ausländische Versender ausweichen, was immer mit längeren Lieferzeiten und vielleicht auch ungewöhnlichen Bezahlverfahren verbunden ist. Dieses Kapitel liefert Informationen, wo und wie man dennoch zuverlässig an seine gewünschten Bauteile kommt – und das in einer erträglichen Zeit. Schnell geht‘s bei Elektor – leider nur der ESP8266
Bei Elektor (www.elektor.de) kann das ESP8266-Modul bestellt werden. Es ist etwas teuer als beispielsweise bei chinesischen Versendern, dafür erhält der Bastler seine Bestellung schon innerhalb weniger Werktage zugesandt. Und für Elektor-Mitglieder gibt es natürlich auch den Mitgliederrabatt:
● 151
ESP8266 DE 160912.indd 151
04-10-1640 15:01
Das ESP8266-Praxisbuch
Kapitel 9 • Das ESP8266-Simpleboard Wir bauen uns eine Developer-Platine für NodeMCU-Boards
Die kleine Entwicklerplatine für das ESP-01-Modul haben wir schon zusammengebaut. Nun wollen wir für zukünftige Hacks mit dem NodeMCU-Board eine größere Platine erstellen, die ein paar zusätzliche Möglichkeiten zum Experimentieren bietet. Es ist immer recht nervig, so einfache Bauteile wie z. B. Taster oder LEDs aus der Kramkiste zu holen, nur um Eingaben mit benötigten Pullup- bzw. Pulldown-Widerständen zu simulieren oder Statusinformationen mit passenden Vorwiderständen zur Anzeige zu bringen. Warum also nicht diese grundlegenden Dinge auf einer fertigen Platine zur Verfügung stellen und ein wenig den Arbeitsaufwand reduzieren, damit man sich dann auf das Wichtige konzentrieren kann? Auf der folgenden Abbildung sehen wir das ESP8266-Simpleboard mit seinen verschiedenen Komponenten:
Abbildung 1 Das ESP8266-Simpleboard Da es verschiedene NodeMCU-Boards gibt, die einen abweichenden Stiftleistenabstand vorweisen, habe ich hier Buchsenleisten mit ebenfalls unterschiedlichen Abständen aufgelötet, so dass beide Boards aufgesteckt werden können. Da es immer recht mühsam ist, sich über die Funktionen der einzelnen Pins zu informieren, sei es im Internet oder auf einer ausgedruckten Seite, habe ich das Pin-Layout entsprechend ausgedruckt und laminiert. Mit
● 158
ESP8266 DE 160912.indd 158
04-10-1640 15:01
Kapitel 10 • Die Entwicklungsumgebung Esplorer
Kapitel 10 • Die Entwicklungsumgebung Esplorer Die Entwicklungsumgebung Esplorer
Wenn es um die Programmierung in diversen Sprachen geht, ist es für die Entwickler meist sehr entscheidend, dass das sehr komfortabel und ohne viel Tippaufwand erfolgt. Natürlich gibt es auch nicht gerade wenige Linux-Puristen, die am liebsten ohne Unterlass auf der Kommandozeile kryptische Befehle einhacken und darüber ein hohes Maß an Befriedigung erlangen. Das hat durchaus seinen Reiz, denn die volle Kontrolle über das System ist nur auf diese Weise zu erlangen. Doch für Einsteiger bringt das ein recht großes Frustpotenzial mit sich, denn die Lernkurve ist steil und der Weg steinig. Es geht aber auch anders. Eine grafische Benutzeroberfläche mit geeigneten Bedienelementen macht das Programmieren einfacher und komfortabler. Ein derartiges Werkzeug wird Entwicklungsumgebung oder IDE (Integrated Development Environment) genannt und eine solche Entwicklungsumgebung möchte ich im Zusammenhang mit der Programmierung des ESP6266 jetzt vorstellen. Sie trägt den Namen Esplorer und ist mit vielen nützlichen Funktionen ausgestattet, um z. B. eine serielle Verbindung herzustellen, Skripte zu verwalten oder Code auf das ESP8266Modul hochzuladen. Die Software ist in Java programmiert und hat somit den Vorteil, dass sie Plattform-unabhängig läuft und unter Windows, Linux und Mac OS X arbeitet. Die Java-Laufzeitumgebung (Runtime Environment) ist auf der folgenden Internetseite zu bekommen: http://java.com/de/download/ Im Moment ist Java 8 aktuell und damit läuft Esplorer einwandfrei. Die Anwendung Esplorer ist auf einer russischen Internetseite zu finden und durch die kyrillische Schrift nicht einfach ausfindig zu machen, es sei denn, man ist dieser Sprache mächtig. Über die folgende Internetadresse sollte es jedoch kein allzu großes Problem sein, den richtigen Link zu erwischen: http://esp8266.ru/esplorer/#download Dort ist eine große blaue Schaltfläche mit dem Namen Download Now zu finden. Durch den Download wird eine ZIP-Datei heruntergeladen. Nach dem Entpacken durch ein geeignetes Programm wie z. B. 7Zip (http://www.7-zip.de/) liegt die folgende Struktur vor:
Abbildung 1 Die Ordner und Dateien von Esplorer Über die hier markierte Datei wird eine Batch-Datei aufgerufen, die Esplorer mittels Java startet. Wer sich für den Quellcode interessiert, sei auf die Möglichkeit hingewiesen, ihn
● 163
ESP8266 DE 160912.indd 163
04-10-1640 15:01
Das ESP8266-Praxisbuch
Kapitel 11 • Die Skriptsprache Lua
Grundlegendes zu Lua
Wie ich eingangs schon erwähnte, bietet die Firmware NodeMCU die Möglichkeit, die Skriptsprache Lua bei der Programmierung des ESP-8266 zu verwenden . Bevor ich näher auf Lua eingehe, möchte ich ein paar einleitende Worte darüber verlieren . Bei Lua handelt es sich um eine sogenannte Lightweight-Programmiersprache, die in C programmiert ist und primär als Bibliothek zur Integration in eigene Softwareprojekte konzipiert wurde . Sie zeichnet sich u . a . dadurch aus, dass ihr Skript-Interpreter eine sehr geringe Größe vorweist und aus diesem Grund sehr gut in Systeme mit kleinem Speicher eingebunden werden kann . Die Ausführungsgeschwindigkeit ist recht hoch und der Befehlssatz über definierte Schlüsselwörter überschaubar . Weitere Details sind unter den folgenden Internetadressen zu finden: https://de .wikipedia .org/wiki/Lua http://nodemcu .readthedocs .io/en/master/ http://www .eluaproject .net/ Die Firmware NodeMCU beinhaltet einen Lua-Interpreter, was dieses Feature so interessant für uns macht . Mit mehr oder weniger kurzen und überschaubaren Skripten können wir das ESP8266-Modul wunderbar programmieren, und deshalb liegt der Fokus in diesem Kapitel auf der Skriptsprache Lua . Ich werde mich auf das Notwendigste beschränken müssen und lediglich grundlegende Strukturen ansprechen, die wir für unsere Hacks benötigen . Sind zusätzlich Sprachelemente erforderlich, die hier nicht besprochen wurden, erfolgt eine detaillierte Erläuterung an entsprechender Stelle . Für tiefergehende Details verweise ich auf das Internet oder die einschlägige Fachliteratur .
● 174
ESP8266 DE 160912.indd 174
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 1: Hello World! Das "Hello-World!" des ESP8266
Das Standard-Programm für das Erlernen einer neuen Programmiersprache ist das "Hello-World!"-Programm. Es wird normalerweise innerhalb eines Fensters – sei es ein Terminal oder eine eigene grafische Oberfläche – ausgegeben. Mit dem ESP8266 ist das so eine Sache, denn es befindet sich kein Monitor oder dergleichen an dem Modul. Da wir aber über freie GPIO-Pins verfügen, ist es doch naheliegend, dort eine LED (Leuchtdiode) anzuschließen, und dafür nutzen wir GPIO2. Das ESP-01-Modul reicht also vollkommen für unser Vorhaben aus, eine LED rhythmisch blinken zu lassen. Bevor wir jedoch beginnen, sollten wir uns ein paar Gedanken zu den Möglichkeiten machen, die in der Welt der Mikrocontroller zur Verfügung stehen, um mit der Außenwelt zu kommunizieren bzw. Daten auszutauschen. GPIO
Ein Mikrocontroller besitzt eine Menge Anschlusspins, die die unterschiedlichsten Funktionen innehaben. Da gibt es z. B. die Spannungsversorgung, Reset- oder Interupteingänge, einen Eingang für den externen Takt usw. Um jedoch Daten auszutauschen, sind Ein- bzw. Ausgabeleitungen erforderlich, die unterschiedliche Aufgaben besitzen, wie z. B. digitale oder analoge Ein- bzw. Ausgänge. Diese Leitungen werden meistens mit GPIO bezeichnet. GPIO ist die Abkürzung für General Purpose Input/Output und besagt, dass ein derartiger Anschluss sowohl als Ein- wie auch als Ausgang arbeiten kann. Es ist also vor der Nutzung eines Anschlusses eine vorherige Konfiguration notwendig. Wir beziehen uns im Moment lediglich auf digitale Signale und lassen analoge erst einmal außen vor. Zu erwähnen ist noch die Möglichkeit, normalen GPIO-Pins Sonderfunktionen zukommen zu lassen und sie z. B. für den I²C- oder SPI-Bus zu konfigurieren. Später dazu mehr. Der Pinmode
Wie ich es gerade erwähnte, kann ein GPIO-Pin sowohl als Ein- wie auch als Ausgang arbeiten. Vor der eigentlichen Verwendung muss eine Entscheidung getroffen werden. In unserem Fall ist also eine Programmierung als Ausgang (Output) erforderlich. Das Ansteuern des gewünschten Pins
Da die ESP8266-Module über mehrere GPIO-Pins verfügen, müssen wir noch festlegen, welchen Pin es anzusprechen gilt. Beim ESP-01 ist das recht einfach, denn im Endeffekt verfügt er lediglich über zwei nutzbare Pins, wobei ich GPIO2 in die engere Wahl gezogen habe. Bei der Programmierung kann man jedoch GPIO2 direkt über den Index 2 ansprechen, denn es handelt sich hier lediglich um eine willkürliche Bezeichnung und nicht um eine programmtechnische Adressierung. Aus diesem Grund sehen wir uns das sogenannte Pin-Mapping an, also die Zuordnung der Pins zu den Pin-Bezeichnungen:
● 182
ESP8266 DE 160912.indd 182
04-10-1640 15:01
Hack 2: Ausbau der Entwicklungsplatine
Hack 2: Ausbau der Entwicklungsplatine Stufe 2 der Entwicklungsplatine
Die Entwicklungsplatine für unser ESP-01-Modul haben wir im vorherigen Hack schon in der ersten Ausbaustufe fertiggestellt. Nun fügen wir der Platine fünf weitere Bauteile hinzu. Es handelt sich um zwei Mikrotaster mit jeweils zwei Pullup-Widerständen und einem Kondensator. Wozu das Ganze aber? Nun, es geht primär um Vereinfachen des Flashens unseres ESP-01. Schauen wir uns dazu den Schaltplan an:
Abbildung 1 Die Erweiterung für das Entwicklungsboard Auf der folgenden Abbildung sehen wir die erforderlichen Bauteile:
Abbildung 2 Erforderliche Bauteile für eine Entwicklerplatine Stufe 2
● 193
ESP8266 DE 160912.indd 193
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 3: Eine externe Spannungsversorgung Wir realisieren eine externe Spannungsversorgung
Bisher wurde das ESP-01-Modul über den FTDI-Adapter mit Spannung versorgt und darüber auch programmiert. Doch wenn die Programmierung einmal abgeschlossen ist, das Modul eigenständig arbeitet und z. B. die Messdaten über WiFi versendet, ist es sinnvoll, eine separate Spannungsversorgung einzusetzen. Das Thema dieses Hacks ist also die Realisierung einer derartigen Spannungsversorgung. Es gibt dazu sicherlich sehr viele Ansätze, und ich werde zwei von ihnen hier vorstellen. Es sei an dieser Stelle noch einmal darauf hingewiesen, dass die 3,3V-Spannungsversorgung z. B. eines Arduino Uno hinsichtlich der zu liefernden Leistung nicht ausreichend und aus diesem Grund nicht ratsam ist. Der Spannungsregulator LD33
Mithilfe des Spannungsregulators LD33 können wir uns eine kleine Schaltung aufbauen, um darüber das ESP-01-Modul zu versorgen:
Abbildung 1 Schaltplan Wir benötigen zur Umsetzung die folgenden Bauteile:
● 196
ESP8266 DE 160912.indd 196
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 4: Der ESP8266 im Zusammenspiel mit dem Arduino Das ESP-01-Modul und der Arduino
Im folgenden Hack wollen wir das ESP-01-Modul mit einem Arduino Uno verbinden, um darüber eine Kommunikation herzustellen. Im ersten Hack haben wir die Firmware NodeMCU verwendet und das Modul eigenständig arbeiten lassen. Das war möglich, da die Firmware es erlaubt, Skripte auf dem Board bzw. im Speicher abzulegen und sie aufzurufen bzw. zu starten. Das Modul arbeitet auf diese Weise autark und unabhängig von weiteren Komponenten. Jetzt wollen wir die AT-basierte Firmware nutzen, was es jedoch erforderlich macht, eine Steuerungsinstanz bereitzustellen, die entsprechende Befehle an das ESP-01-Modul versendet. Ein Arduino-Uno-Board kann diese Aufgabe wunderbar übernehmen, und bei einer Programmierung über einen Sketch – so werden die Programme im Arduino-Umfeld genannt – können komplexe Abläufe programmiert werden. Die Kommunikation erfolgt natürlich wieder über die serielle Schnittstelle des ESP-01-Moduls. Ich habe mich Arduino-seitig für eine softwarebasierende Realisierung mithilfe einer entsprechenden Bibliothek entschieden. Darüber ist es möglich, freie digitale Pins des Arduino-Boards als serielle Schnittstelle zu definieren. Nähere Hinweise zu dieser Bibliothek sind unter der folgenden Internetadresse zu finden: https://www.arduino.cc/en/Reference/SoftwareSerial Schauen wir uns zu Beginn den Workflow an. In einem Terminal-Fenster werden AT-Befehle eingegeben, die vom Arduino über die serielle Verbindung zum ESP-01 übertragen werden, um dort die unterschiedlichsten Reaktionen hervorzurufen:
Abbildung 1 Vom AT-Kommando bis zur einer Aktion am ESP-Modul
● 202
ESP8266 DE 160912.indd 202
04-10-1640 15:01
Hack 5: Temperaturmessung
Hack 5: Temperaturmessung Wir messen die Temperatur
Wie ich im vorangegangenen Hack schon androhte, kommen jetzt die gelernten Grundlagen zum Tragen bzw. zur Anwendung. In diesem Hack wollen wir die Temperatur über ein spezielles Bauteil messen und später an einen Server im Internet versenden, der es uns ermöglicht, Messwerte grafisch darzustellen. Um das zu realisieren, sind einige neue und sehr interessante Aspekte des ESP-01 zu besprechen. Doch gehen wir schrittweise vor und beginnen mit der Aufnahme der Temperatur über einen speziellen Temperatursensor. Auf dem Markt sind die unterschiedlichsten Temperatursensoren zu finden und der jetzt vorgestellte Hack ist nur als Anregung für vielleicht noch komplexere und ausgeklügeltere Schaltungen zu sehen. Die verwendeten bzw. vorgestellten AT-Kommandos sind auf der folgenden Internetadresse detailliert beschrieben und ausführlich erklärt: https://github.com/espressif/ESP8266_AT/wiki Das ESP-01-Modul und das Internet Beginnen wollen wir jedoch nicht mit dem Temperatursensor, sondern mit der Einbindung des ESP-01-Moduls in das heimische Netzwerk und später dann natürlich ins Internet. Über den AT-Befehl: AT+CWMODE=3
haben wir den WiFi-Modus festgelegt. Die folgenden Modi sind möglich: AT-Kommando
Erklärung
AT+CWMODE=1
STA: Stationsmodus, der es erlaubt, das ESP--Modul zu einem Accesspoint (AP) Verbindung aufzunehmen
AT+CWMODE=2
AP: Accesspoint-Modus, der das ESP--Moduls als Accesspoint arbeiten lässt, zu dem andere Geräte Verbindung aufnehmen können
AT+CWMODE=3
BOTH: Kombiniert Modus 1 und 2 miteinander
AT+CWMODE?
Abfrage des aktivierten Wifi-Modus
Im zweiten Schritt haben wir uns die zur Verfügung stehenden WiFi-Hotspots mit dem folgenden AT-Befehl anzeigen lassen: AT+CWLAP
Sehen wir uns ein paar Resultate aus der Liste genauer an: +CWLAP:(3,"FRITZ!Powerline 540E",-81,"24:65:11:xx:xx:xx",1) +CWLAP:(0,"EasyBox-01A460",-90,"9c:80:df:xx:xx:xx",1) +CWLAP:(4,"EasyBox-481754",-83,"84:9c:a6:xx:xx:xx",4) +CWLAP:(4,"EriksHotspot",-50,"9c:c7:a6:xx:xx:xx",1)
● 209
ESP8266 DE 160912.indd 209
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 6: Ein ESP-01 Arduino-Shield Wir basteln uns ein Arduino-Shield
Der Aufbau einer Schaltung mit fliegender Verdrahtung auf einem Breadboard ist natürlich keine Dauerlösung und nur für das Testen bzw. Prototyping sehr gut geeignet. Möchte man eine entwickelte und funktionierende Schaltung später funktional in Betrieb nehmen, ist eine Realisierung über eine geeignete Platine in Erwägung zu ziehen. Im Umfeld des Arduino sind Erweiterungsplatinen sehr oft anzutreffen, die dessen Funktionalität elegant erweitern. Derartige Platinen werden Shields genannt und finden ihren Platz oben auf dem Arduino-Board. Das ist deshalb möglich, weil das Arduino-Board über sogenannte Header zu erweitern ist. Auf der folgenden Abbildung sehen wir den Arduino Uno mit seinen Headern:
Abbildung 1 Das Arduino-Board mit seinen Headern Ein Header ist schlicht gesagt eine einfache Buchsenreihe, in die entweder Steckverbinder oder Steckleisten eingefügt werden können. Schauen wir uns doch einmal das fertige ESP01-Shield an, das es zu bauen gilt:
● 230
ESP8266 DE 160912.indd 230
04-10-1640 15:01
Hack 7: Die Arduino-IDE und ESP
Hack 7: Die Arduino-IDE und ESP Die Unterstützung des ESP-Moduls durch die Arduino-IDE
Wir haben zwar in unserem letzten Hack die Arduino-IDE – sprich die Entwicklungsumgebung – für die Programmierung des ESP-01-Moduls verwendet, doch lediglich zum Versand bestimmter AT-Kommandos. Im Endeffekt wurden keine speziellen ESP-Befehle abgesetzt, die die Arduino-IDE in Form von C++-Befehlen zur Verfügung stellt. Das wollen wir jetzt ändern, denn es gibt eine Möglichkeit, eine eigens für das ESP-Modul programmierte Bibliothek einzubinden, um dann Arduino- bzw. C++-Befehle abzusetzen. Die Einbindung der Bibliothek
Bekanntlich führen viele Wege nach Rom und es gibt zahlreiche Lösungen, die erforderliche Bibliothek in die Arduino-IDE zu integrieren. Es gibt eigens dafür präparierte Entwicklungsumgebungen, die parallel zu einer bestehenden Arduino-Entwicklungsumgebung installiert und verwendet werden können. Zu finden unter der Internetadresse: https://github.com/esp8266/arduino Ich beschreibe hier den einfachsten Weg, der ab der Arduino-Version 1.6.5 und natürlich höher möglich ist. Unter dem Menüpunkt Datei|Voreinstellungen muss der hier rot umrandete Pfad eingetragen werden:
Im nächsten Schritt wird unter dem Menüpunkt Werkzeuge|Boards|Boardverwalter der gleichnamige Boardverwalter aufgerufen. Nun muss der Eintrag ESP8266 gesucht und über die Installieren-Schaltfläche die Bibliothek installiert werden:
Über den Fortschrittsbalken kann die Installation verfolgt werden, und er gibt eine Rückmeldung über den laufenden Installationsprozess:
Falls eine neuere Version verfügbar sein sollte, gibt die Arduino-IDE eine entsprechende Meldung aus, und sie kann wie gerade beschrieben dann installiert werden. Wenn wir jetzt einen Blick in die zur Verfügung stehenden Boards über den Menüpunkt Werkzeuge|Board werfen, stellen wir fest, dass dort mehrere ESP-Boards zur Auswahl angeboten werden:
● 239
ESP8266 DE 160912.indd 239
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 8: Der IO-Expander Wir erweitern die vorhandene Schnittstelle des ESP-01
Wie ich am Ende des letzten Hacks schon sagte, wollen wir das ESP-01-Modul so erweitern, dass es über 16 Ein- bzw. Ausgänge verfügt. Wie man vermuten wird, ist das nicht so ohne Weiteres möglich. Wir müssen noch ein wenig in die Trickkiste greifen. Auf der folgenden Abbildung habe ich noch einmal das Pin-Layout des ESP-01-Moduls abgebildet:
Abbildung 1 Das Pin-Layout des ESP-01-Moduls Nun, mit 16 weiteren Pins ist das etwas schwierig, denn zaubern kann ich nicht. Die Lösung liegt in einem Bus-System, das sich I²C nennt. Ein Bus-System wird für den Datenaustausch zwischen zwei oder mehreren Kommunikationsteilnehmern über einen gemeinsamen Übertragungsweg verwendet. Es gibt unzählige verschiedene Bus-Systeme, die mit einer unterschiedlichen Anzahl von Leitungen arbeiten. Der I²C-Bus
Der I²C ist ein sehr verbreitetes System und fällt in die Kategorie TWI, was Two-WireInterface bedeutet, und mit zwei Leitungen auf kurze Distanz. Zur Kommunikationen sind einer oder mehrere sogenannte Master im Einsatz, die zu einem oder mehreren Slaves Verbindung aufnehmen. Um eine korrekte Zustellung der Daten zu gewährleisten, sind im Kommunikationsverbund Master/Slave eindeutige Adressen erforderlich. Schauen wir uns ein derartiges Bus-System auf der Basis von I²C einmal an:
● 244
ESP8266 DE 160912.indd 244
04-10-1640 15:01
Hack 9: Der Servomotor
Hack 9: Der Servomotor Wir steuern einen Servomotor an
Ein Servomotor kann z. B. zur Steuerung von Modellflugzeugen oder auch Modellschiffen verwendet werden. Ein Servomotor – oder auch kurz Servo genannt – besitzt im Inneren einen kleinen Gleichstrommotor und verfügt zur Ansteuerung über 3 Anschlüsse. Zwei dienen der Spannungsversorgung, wobei der dritte zur eigentlichen Positionsansteuerung verwendet wird. Um eine bestimmte Position anfahren zu können, kommt die schon im Elektronik-Kapitel erwähnte Puls-Weiten-Modulation (PWM) zum Einsatz. Normale Servos haben einen Aktionsradius von 0 bis 180 Grad. Für kleine Roboterfahrzeuge werden auch modifizierte Module verwendet, die sich von 0 bis 360 Grad – also einen Vollkreis – drehen können und über den Begriff continuous rotation zu finden sind. In diesem Hack steuern wir einen kleinen Servo vom Typ SG92R an, der mit einer Versorgungsspannung zwischen 3V und 6V DC betrieben werden kann.
Abbildung 1 Ein Servomotor vom Typ SG92R Nähere Hinweise zum verwendeten Servo sind unter der folgenden Internetadresse zu finden: http://www.towerpro.com.tw/product/sg92r-7/ Um die Spannungsversorgung für das ESP-Modul nicht noch weiter zu belasten, habe ich mich entschieden, eine externe Spannungsversorgung über das MB102 Breadboard 3.3V/5V Power Supply Modul zu realisieren. Natürlich kann auch jede andere Spannungsquelle, die den erforderlichen Bereich abdeckt, Verwendung finden. Sehen wir uns den Schaltplan genauer an. Der Schaltplan
Die Verdrahtung ist nicht weiter kompliziert und sollte uns in Grundzügen schon bekannt vorkommen:
● 259
ESP8266 DE 160912.indd 259
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 10: Das LCDisplay Wir zeigen Informationen auf einem LCDisplay an
Nun haben wir schon einiges über den I²C-Bus kennengelernt. Es gibt viele verschiedene Geräte bzw. Bauteile, die über einen derartigen Bus verfügen. Da gibt es z. B. Temperatursensoren, Analog/Digital-Wandler, Speicherbausteine und LCDisplays. Bleiben wir einmal bei den LCDisplays und lenken unsere Aufmerksamkeit in diesem Hack auf eines dieser Anzeigeelemente, das in der Lage ist, die unterschiedlichsten Informationen in Form von Text wie auch als Grafik darzustellen. Auf der folgenden Abbildung sehen wir ein derartiges Display, und schon an den wenigen Pins zur Ansteuerung bzw. Stromversorgung – vier an der Zahl – ist zu sehen, dass es sich um Bus-System handelt:
Abbildung 1 Ein I²C-LCDisplay Das hier gezeigte LCDisplay ist von der Firma Seeed-Studio, es hat eine Auflösung von 96x96 Pixeln mit 16 Graustufen und ist aus der Grove-Serie des Herstellers. Nähere Informationen sind unter der folgenden Internetadresse zu finden: http://www.seeedstudio.com/wiki/Grove_-_OLED_Display_1.12" Die benötigte Bibliothek zur Ansteuerung findet sich auf der Internetseite: http://www.seeedstudio.com/wiki/File:LCD_Display9696_Library.zip In diesem Hack werden wir uns ein spezielles Display-Board bauen, das sowohl das ESP01-Modul als auch das LCDisplay aufnimmt, also eine kleine kompakte Einheit zur Anzeige diverser Informationen. Die Installation der Bibliothek
Schauen wir uns zu Beginn die notwendige Installation der Bibliothek an, denn sie muss in die Arduino-IDE integriert werden. Nach dem Herunterladen der ZIP-Datei liegt sie im entsprechenden Downloadverzeichnis vor.
● 278
ESP8266 DE 160912.indd 278
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 11: Der WiFi-Scanner Ist unser WiFi verfügbar?
Aufbauend auf dem letzten Hack wollen wir jetzt unser ESP-01-Modul so programmieren, dass nach dem WiFi des eigenen Routers gescannt wird und eine entsprechende Meldung auf dem LCDisplay erscheint. Wie ist das machbar? Die ESP-Bibliothek stellt eine derartige Funktionalität durch die WiFi-Klasse zur Verfügung. Welche Elemente werden daraus benötigt? Zu Beginn müssen wird den WiFi-Mode setzen. Das haben wir schon in einem vorangegangenen Hack kennengelernt. In unserem Fall reicht der Station-Mode aus, der über die folgende Zeile mithilfe der mode-Methode gesetzt wird: WiFi.mode(WIFI_STA);
Nun geht es daran, die zur Verfügung stehenden WiFi-Netzwerke zu finden bzw. zu scannen. Die scanNetworks-Methode ermittelt alle zur Verfügung stehenden Netzwerke und speichert sie ab. Als Rückgabewert dieser Methode wird ein numerischer Wert zur Verfügung gestellt, der Aufschluss über die Anzahl der erkannten Netzwerke gibt: n = WiFi.scanNetworks();
Über eine geeignete Schleife kann nun über die einzelnen Netzwerke iteriert werden, wobei wir die SSID-Methode zur Auswahl der Wlan-Geräte mit einem Index auf die erkannten Netzwerke verwenden, um darüber jedes einzelne Netzwerk anzusteuern. WiFi.SSID(i);
Die WiFi-Klasse stellt noch weitere interessante Methoden zur Verfügung, die in diversen Beispielen zu finden und durch die Installation der ESP-Bibliothek vorhanden sind. Schauen wir uns jetzt aber den Sketch-Code an, der die WiFi-Netzwerke nach dem eigenen Netzwerk – in meinem Fall EriksHotspot – durchsucht und bei Auffinden eine Boolesche Variable setzt, die später ausgewertet wird, um darüber entsprechende Meldungen auf dem LCDisplay erscheinen zu lassen: #include <Wire.h>
// Einbinden der I²C-Bibliothek
#include <SeeedGrayOLED.h> // Einbinden der LCDisplay-Bibliothek #include "ESP8266WiFi.h"
// Einbinden der ESP-WiFi-Bibliothek
boolean HomeWiFi = false; // Home-WiFi gefunden? void setup() { Wire.begin(2, 0);
// GPIO2 (SDA), GPIO0 (DCL)
Wire.setClock(1000);
// I²C-Bus-Geschwindigkeit auf 1 KHz
delay(100);
// Kurze Pause
SeeedGrayOled.init(); // Initialisierung OLED Display SeeedGrayOled.clearDisplay();
// Display löschen
● 286
ESP8266 DE 160912.indd 286
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 12: Der Webserver Ein Webserver wird eingerichtet
Hinsichtlich der Entwicklung von Software haben wir bisher recht wenig mit Lua gemacht. Das wollen wir in diesem Hack ändern. Jetzt geht es darum, einen Webserver zu programmieren, der über einen Webbrowser zu erreichen ist. Ich verwende das erste Mal das sogenannte NodeMCU-Board, das über eine Menge Pins verfügt und natürlich viel mehr Möglichkeiten der Nutzung zur Verfügung stellt. Für diesen Hack verwende ich das NodeMCU-Board von Seeed-Studio, das sich offiziell NodeMCU v2-Lua based ESP8266 Development Kit nennt. Was für ein Name!
Abbildung 1 Das NodeMCU-Board von Seeed-Studio Wenn wir das Board das erste Mal mit unserem Rechner verbinden, so wird er mit allergrößter Wahrscheinlichkeit keinen passenden Treiber finden. Das ist nicht weiter schlimm, denn unter der folgenden Internetadresse http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx ist der Treiber für verschiedene Betriebssysteme erhältlich. Nach erfolgreicher Installation bauen wir eine Verbindung über den schon verwendeten Esplorer auf, wobei natürlich der richtige COM-Port mit der Baudrate 9600 eingestellt werden muss. Zu Beginn wird die folgende Meldung ausgegeben:
Dieser Hinweis zeigt uns, dass die Kommunikation erfolgreich verlaufen ist, und über die Eingabe
und abschließendes Senden, wird das Skript gelöscht. Nun müssen wir einen Reset über
● 290
ESP8266 DE 160912.indd 290
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 13: Eine Smartphone App Wir programmieren eine Android-App
Natürlich ist es möglich – wir haben es im letzten Hack gesehen –, die GPIO-Pins des ESP-Moduls über einen Webbrowser anzusteuern. Es gibt noch eine weitere Möglichkeit, den Webserver auf dem Modul anzusteuern. Möglich ist das durch eine speziell programmierte App, was ich am Beispiel des Android-Betriebssystems vorstellen möchte. Normalerweise ist die Lernkurve zum Erstellen einer derartigen App recht hoch, denn die Programmierung ist keineswegs trivial, und wer sich mit der Programmiersprache Java ein wenig auskennt, hat dabei auf jeden Fall bessere Karten. Doch ich möchte einen anderen Weg beschreiten, der gerade für Einsteiger eine wunderbare Gelegenheit bietet, sich der Thematik App-Entwicklung unter Android sanft zu nähern, ohne dass der Frustfaktor unweigerlich zuschlägt und jegliches Bemühen zum Ziel zu gelangen zunichtemacht. Die Lösung liegt in einer Entwicklungsumgebung, die nach einem besonderen Prinzip aufgebaut ist. Beim Programmieren kommt man ohne die Eingabe von Code aus, es sind lediglich ein paar Zusatzinformationen z. B. in Form von Metadaten erforderlich. Wie soll das funktionieren? Nun, es werden nach einem Baukastenprinzip fertige Ausführungsblöcke zur Verfügung gestellt, derer man sich aus einem Vorrat bedienen kann. Es können dabei nur die Blöcke zusammengefügt werden, die auch eine logische Struktur ergeben. Alles Unsinnige wird abgelehnt und dadurch werden mögliche Fehler minimiert. Schauen wir uns dazu einmal ein sehr einfaches Beispiel an. In unserer sehr einfachen App haben wir eine Schaltfläche und ein Label zur Anzeige von Textinformationen. Nun möchten wir mit der Programmierung erreichen, dass beim Auswählen der Schaltfläche ein bestimmter Text in dem Label angezeigt wird. Das Ganze schaut natürlich sehr simpel aus und soll lediglich als Vorgeschmack für das dienen, was wir später machen möchten:
Abbildung 1 Die erste App Die hier gezeigte Ansicht ist der Blick auf den sogenannten Screen, der das Benutzerinter-
● 302
ESP8266 DE 160912.indd 302
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 14: Die Puls-Weiten-Modulation Die Ansteuerung mit einer Puls-Weiten-Modulation
Wenn es darum geht, in der Welt der Digitaltechnik z. B. eine LED mit unterschiedlicher Helligkeit anzusteuern, dann geht das nicht so ohne Weiteres. Entweder liegt an einem Verbraucher – sei es eine LED, ein Motor oder Ähnliches – ein HIGH-Pegel, dann ist er aktiv, oder ein LOW-Pegel, was inaktiv bedeutet. Dazwischen gibt es nichts. Natürlich werden in der Elektronik sogenannte Digital/Analog-Wandler verwendet, die anhand einer Binärkombination ein analoges Signal generieren, doch eine derartige Schaltung ist bei Mikrocontrollern eher selten anzutreffen. Nun gib es aber noch eine andere Variante, um z. B. eine LED in unterschiedlicher Helligkeit leuchten zu lassen. Angenommen, wir steuern eine LED über ein Rechtecksignal in einer bestimmten Frequenz an, wobei die Frequenz jedoch so hoch ist, dass die Trägheit unseres Auges diesen stetigen An-Aus-Phasen nicht folgen kann und ein durchgehendes Leuchten wahrgenommen wird. Sehen wir uns dazu die folgende Abbildung an, in der ein Rechtecksignal zu sehen ist, das eine gewisse Impulsdauer t1 und eine Periodendauer T vorweist:
Abbildung 1 Puls-Weiten-Modulation mit 50 % Das Verhältnis von Impulsdauer und Periodendauerwird (manchmal auch) genannt:
Damit die Lampe nun dunkler leuchtet, reicht es nicht aus, die An- bzw. Aus-Phase zu verringern. Bei einer Puls-Weiten-Modulation – kurz genannt – bleibt die Periodendauer gleich und nur die Impulsdauer unterliegt einer Änderung. Sehen wir uns das folgende Impulsdiagramm an:
● 314
ESP8266 DE 160912.indd 314
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 15: PWM über Webserver Die Ansteuerung mit einer Puls-Weiten-Modulation über einen Webserver
Die Installation eines Webservers haben wir schon in einem vorangegangenen Hack gesehen, wobei dafür die Programmiersprache Lua verwendet wurde. Nun wollen wir die ganze Sache einmal mit der Arduino-IDE unter die Lupe nehmen und die Programmierung mit C++ durchführen. Wir sehen uns die Umsetzung Schrittchen für Schrittchen an, so dass der Aufbau bzw. die Struktur sehr schnell zu erkennen ist. Das Ziel in diesem Hack ist die PWM-Ansteuerung einer sogenannten RGB-LED über einen Webbrowser durch die Übergabe der drei Werte für die Grundfarben Rot, Grün und Blau, um darüber die Farbe bzw. Helligkeit zu regeln. Auf der folgenden Abbildung ist eine derartige LED zu sehen, die mit 4 Anschlüssen versehen ist:
Abbildung 1 RGB-LED Wie die Ansteuerung zu erfolgen hat, werden wir zu gegebener Zeit natürlich noch sehen. Es werden die folgenden Bauteile benötigt:
Abbildung 2 Die benötigten Bauteile Vorbereitung des Webservers
Zuerst wollen wir das Grundgerüst eines Webservers programmieren und vom Router eine IP-Adresse abrufen. Wird dieser Vorgang erfolgreich abgeschlossen, gibt es eine entsprechende Nachricht im Serial-Monitor. Es sind dazu zwei Header-Dateien erforderlich, die einerseits zur WiFi-Verbindung und andererseits für den Webserver verwendet werden. #include <ESP8266WiFi.h> #include <ESP8266WebServer.h>
Im nächsten Schritt definieren wir einige Variablen, die SSID, Passwort und Port-Adresse aufnehmen:
● 320
ESP8266 DE 160912.indd 320
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 16: Relais-Ansteuerung Die Ansteuerung mehrerer Relais
In der Elektronik hat man es meist mit Spannungen von 3,3V bis 5V zu tun, die zur Ansteuerung von Bauteilen verwendet werden. Wenn es aber darum geht, Verbraucher wie z. B. eine Kaffeemaschine, einen Toaster oder eine Waschmaschine zu betreiben, sind Spannungen von 240V erforderlich, die so ohne Weiteres nicht von der Mikroelektronik bereitgestellt werden. Damit das aber trotzdem möglich ist, werden zwei oder mehr voneinander getrennte Stromkreise benötigt. Zum einen haben wir den Steuerkreis und zum anderen den Lastkreis.
Abbildung 1 Der Steuer- bzw. Lastkreis Die Steuer-Lastkreis-Kombination arbeitet ähnlich wie ein Verstärker, wo mit geringem Aufwand bzw. Steuerspannungen große Lasten geschaltet werden können. Zur Realisierung gibt es natürlich die unterschiedlichsten Ansätze und da wir für unseren Hack lediglich die Zustände An bzw. Aus schalten möchten, eignet sich dafür ein sogenanntes Relais. Eine mögliche und recht einfache Schaltung ist die Ansteuerung einer Lampe:
Abbildung 2 Die Ansteuerung einer Lampe über ein Relais
● 332
ESP8266 DE 160912.indd 332
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 17: Internet-Zeit anzeigen Wir greifen die Zeit von einem Server ab
Natürlich liefert unser Computer zumeist die korrekte Zeit, doch es gibt im Internet auch sogenannte Zeit-Server, auf die man mit dem NTP (Network-Time-Protocol) zugreifen kann, um dort die aktuelle Zeit über die Angabe der Zeitzone zu ermitteln und abzurufen. Das bedeutet einiges an Aufwand und wir wollen es in diesem Hack etwas einfacher gestalten. Es ist möglich, einen GET-Request an einen geeigneten Server im Internet zu versenden und die Antwort entsprechend auszuwerten. Somit ist es für unser ESP-Modul sehr einfach, mittels WiFi die Zeit abzurufen und z. B. auf einem LCDisplay dazustellen. Wir haben jetzt schon einige Hacks mit der Arduino-IDE, also in der Programmiersprache C++ umgesetzt, so dass es nun an der Zeit ist, wieder einmal Lua ins Spiel zu bringen. Ja, auch mit Lua ist es möglich, über den I²C-Bus ein angeschlossenes LCDisplay anzusteuern, und wir nehmen das, was wir schon beim Simpleboard verwendet hatten. Wir erinnern uns: Es handelt sich um ein Farbdisplay mit einer Auflösung von 128 x 64 Pixel. Starten wir aber zunächst mit der Versendung eines GET-Requests an einen Server bzw. URL, die sich www.timeapi.org nennt. Bei der zusätzlichen Angabe der von uns gewünschten Zeitzone – auch Timezone genannt – wird sie bei der Ausgabe der Informationen berücksichtigt. In unseren Breiten ist das Kürzel CET, was für Central European Time steht, zu verwenden. Bei der GET-Methode handelt es sich um eine der ältesten Möglichkeiten, Daten von einem Server abzurufen. Ein Client, z. B. in Form eines Webbrowsers, versendet über HTTP (Hypertext Transfer Protocol) eine GET-Abfrage (Request), um eine Datei bzw. URL abzufragen. Wie könnte eine derartige Abfrage ausschauen? Hierzu ein kleines Beispiel: GET /index.php HTTP/1.1 Host: www.erik-bartmann.de User-Agent: Mozilla/4.0 Accept: */*
Es wird versucht, die Datei index.php zu erreichen, die sich hinter der URL www.erik-bartmann.de verbirgt. Der User-Agent im HTTP beinhaltet Versionsinformationen bzw. Kommentare zum verwendeten Client. Im Accept wird definiert, welche Medien-Typen in der Antwort erlaubt sind. Die Angabe von */* besagt, dass jegliche Typen erlaubt sind. Werden wir jetzt konkret und sehen uns einen GET-Request auf die schon erwähnte URL www. timeapi.org an: GET /CET/now HTTP/1.1 Host: www.timeapi.org User-Agent: Mozilla/4.0 Accept: */*
Der Lua-Code
Kommen wir zum Lua-Code, der eine derartige Abfrage an den genannten Server versendet und schauen, was uns als Antwort geliefert wird:
● 344
ESP8266 DE 160912.indd 344
04-10-1640 15:01
Das ESP8266-Praxisbuch
Hack 18: MQTT-Grundlagen Grundlagen zu MQTT
Bis vor einiger Zeit hatte ich selbst noch nie etwas von MQTT gehört und ich konnte mir nichts darunter vorstellen. Geht es Ihnen ähnlich, dann sind Sie in bester Gesellschaft. Wofür steht MQTT und was bedeuten diese vier Buchstaben? MQTT steht für Message Queue Telemetry Transport und stellt ein Nachrichtenprotokoll (Publishing & Subscribe) dar, das für eine sogenannte Maschine-zu-Maschine(M2M)- Kommunikation geschaffen wurde. Gerade wenn es darum geht, Informationen in Netzen geringer Bandbreite und hoher Latenzen (Reaktionszeiten) zur Steuerung z. B. an Aktoren zu versenden oder von Sensoren Daten abzurufen, ist dieses Nachrichtenprotokoll einen Blick wert. Es wurde schon 1999 von der Firma IBM zur Satellitenkommunikation entwickelt und ist seit 2013 auch als Protokoll für das Internet der Ding (IoT) standardisiert. Zur Übertragung im Netz sind die Ports 1883 und 8883 offiziell reserviert. Die offizielle Internetseite ist unter der folgenden Adresse zu finden: http://mqtt.org/ In einem Netzwerk sind immer Server, die Informationen liefern, und Clients, die Informationen anfordern, vorhanden. Bei MQTT läuft die Sache ähnlich ab, nur hier ist die Namensgebung etwas anders, was aber im Endeffekt auf dasselbe hinausläuft. Es gibt eine Datenquelle, die als Publisher bezeichnet wird, und einen Datenempfänger, der als Subscriber arbeitet. Zwischen diesen beiden Instanzen ist jemand, der als Server arbeitet und die Daten zur Verfügung stellt und als Vermittler in Erscheinung tritt. Er wird Broker genannt. Auf der folgenden Abbildung ist das etwas übersichtlicher dargestellt:
Abbildung 1 MQTT-Kommunikation Damit wir in die ganze Kommunikation eine gewisse Ordnung bekommen, erfolgt der Datenaustausch über sogenannte Topics, wobei die Struktur an den Seitenaufbau eines Web-
● 350
ESP8266 DE 160912.indd 350
04-10-1640 15:01
Hack 18: MQTT-Grundlagen
Hack 19: MQTT erweitert Wir programmieren in C++
Nach dieser kurzen Einführung in die Thematik MQTT im letzten Hack möchte ich jetzt zur Programmierung in C++ über die Arduino-IDE wechseln. In meinen Augen ist das etwas professioneller, obwohl ich die Fähigkeiten von Lua keineswegs in Abrede stellen möchte. Auch in diesem Hack ist der Einsatz des Raspberry Pi wieder erforderlich, wobei – wie schon erwähnt – natürlich auch ein anderer MQTT-Server genutzt werden kann. Bevor wir mit der Programmierung starten, ist es erforderlich, zusätzliche Bibliotheken herunterzuladen und zu installieren. Zum einen benötigen wir die Bibliothek zur Kommunikation mit dem MQTT-Server, die unter der folgenden Internetadresse zu bekommen ist und sich PubSubClient nennt: https://github.com/knolleary/pubsubclient/releases/ Nach der Installation liegen einige recht interessante Beispiele vor, die man sich einmal anschauen sollte. Sie sind unter dem Menüpunkt Datei|Beispiele|PubSubClient zu finden. Zum anderen wollen wir Temperaturmessungen mit dem Sensor DS18B20 vornehmen. Es handelt sich dabei um einen recht genauen Sensor, der mit einer Spannung zwischen 3V und 5,5V betrieben werden kann und der einen Temperaturbereich von -55°C bis +125°C abdeckt. Auf der folgenden Abbildung sehen wir die Pinbelegung:
Die sogenannte One-Wire-Technik (Ein-Draht-Bus) gestattet es, neben der Spannungsversorgung die Daten über eine einzige Leitung zu übertragen, wobei eine Konfiguration möglich ist, dass mehrere Sensoren an den Bus angeschlossen werden können. Wie aber kann dann zwischen den einzelnen Sensorwerten unterschieden werden? Ganz einfach, denn jeder Sensor besitzt eine eindeutige 64-Bit-Hardware-Adresse, die in einem internen ROM gespeichert ist. Um One Wire zu nutzen, muss die entsprechende Bibliothek installiert werden, die unter der folgenden Internetadresse zu finden ist: https://github.com/PaulStoffregen/OneWire Es handelt sich um eine modifizierte Bibliothek, die zusätzlich zum Arduino auch für ein ESP-Modul kompiliert werden kann. Haben Sie die normale erwischt, erhalten Sie bei der
● 359
ESP8266 DE 160912.indd 359
04-10-1640 15:01
Hack 19: MQTT erweitert
Hack 20: Analog/Digital-Wandlung Die analoge Welt
Bei so viel Digitaltechnik wird es Zeit, sich auch einmal der analogen Welt zu widmen. Zwar haben wir schon im Hack über die Temperaturmessung einiges über analoge Werte erfahren, doch in diesem Hack geht es um einen speziellen Baustein, der analoge Werte in digitale wandelt. Dieser Baustein wird über den I²C-Bus angesteuert und nennt sich PCF8591. Er ist als einzelnes IC zu bekommen, jedoch finde ich die Variante über eine kleine und schon fertig aufgebaute Schaltung auf einer Mini-Platine viel interessanter, und der Preis von unter 3 € ist wirklich unschlagbar. Auf der folgenden Abbildung sehen wir ein derartiges Modul:
Abbildung 1 Der A/D -bzw. D/A-Wandler PCF8591 In der Abbildungsbeschriftung habe ich die Abkürzungen A/D- bzw. D/A-Wandler verwendet, was für die schon erwähnte Analog/Digital-Wandlung steht und für 4 separate Kanäle erfolgen kann. Doch auch die Gegenrichtung ist möglich, und es kann auf einem Kanal eine Digital/Analog-Wandlung durchgeführt werden. Wer jedoch die Schaltung nur mit dem PCF8591 aufbauen möchte, für den ist sicherlich die Pinbelegung des ICs wichtig:
Abbildung 2 Die Pinbelegung des A/D-Wandlers PCF8591 Hier einige Eckdaten zum PCF8591:
● 383
ESP8266 DE 160912.indd 383
04-10-1640 15:01
Hack 20: Analog/Digital-Wandlung
Hack 21: Wir twittern Wir bringen Twitter ins Spiel
Wie schon im vorangegangenen Hack versprochen, wollen wir jetzt Twitter – ein Mikroblogging-Dienst – ins Spiel bringen. Wenn ein bestimmtes Ereignis eintritt, soll eine Nachricht, die Tweet genannt wird, versandt werden. Um den Hack umzusetzen, ist also ein Twitter-Account erforderlich. Falls nicht schon vorhanden, ist die Erstellung eines Accounts unter der folgenden Internetadresse schnell erledigt: https://twitter.com/signup Wir sollten uns beim Twittern nicht auf ein bestimmtes Ereignis versteifen, denn das spielt im Endeffekt keine Rolle. Der Kreativität sind hier keine Grenzen gesetzt und jeder kann für sich entscheiden, wie er das System für das Twittern am besten umsetzt. Im Hack über die Temperaturmessung sind wir das erste Mal mit ThingSpeak https://thingspeak.com/ in Berührung gekommen. Dieser Dienst kann noch viel mehr. Klicken Sie doch einfach einmal auf die Schaltfläche Apps:
Darunter befinden sich zahlreiche Anwendungen bzw. Dienste, die man nutzen kann. Unter der Kategorie Actions ist die App ThingTweet zu finden, und das ist genau die, die für uns brauchbar ist.
Nach der Auswahl bekommen wir die folgenden Informationen geliefert:
● 395
ESP8266 DE 160912.indd 395
04-10-1640 15:02
Das ESP8266-Praxisbuch
Hack 22: Der ESP-Robot Wir bauen einen Roboter
Über die Steuerung via WiFi haben wir schon einiges gelernt. In diesem Hack ist es unser Ziel, ein Roboterfahrzeug zu konstruieren, das mittels einer App gesteuert werden kann. Doch lassen wir es langsam angehen und beginnen mit den Grundlagen zur Ansteuerung eines einzigen Motors. Dass ein Motor für den Antrieb eines größeren Fahrzeuges mit einer höheren Spannung als 3,3V betrieben werden muss, sollte klar sein. Erinnern wir uns an den Transistor mit seinen Eigenschaften, als Verstärker in Erscheinung zu treten. Doch es gibt noch einen weiteren Aspekt, der nicht außer Acht gelassen werden darf. Ein Motor besitzt im Inneren eine Spule, die ein Verhalten an den Tag legt, das schon besprochen wurde. Beim Abschalten der Versorgungsspannung zur Spule kommt es zu erhöhten Spannungswerten, die einen Transistor überlasten bzw. zerstören, und aus diesem Grund wird eine Freilaufdiode verwendet. Schauen wir uns eine Motoransteuerung genauer an. Ein Motor kann über einen einfachen Schalter an- bzw. abgeschaltet werden:
Abbildung 1 Die Ansteuerung eines Motors Es ist zu sehen, dass der Motor fest verdrahtet ist und nur zwei Zustände annehmen kann. Er dreht sich oder er dreht sich nicht, und das nur in eine festgelegte Richtung, denn das entgegengesetzte Drehen würde nur über das Umpolen der Spannungsquelle bzw. des Motors zu realisieren sein, ein wenig praktikables Unterfangen. Wir steuern einen Motor an
Für einen ersten Test zur Ansteuerung eines Motors sind die folgenden Bauteile erforderlich:
● 404
ESP8266 DE 160912.indd 404
04-10-1640 15:02
Hack 22: Der ESP-Robot
Hack 23: Wir entwickeln ein Lua-Modul Die Ansteuerung des Port-Expanders MCP23017 über ein Lua-Modul
Eine Bibliothek wird immer dann entwickelt, wenn es darum geht, die eigentliche Low-Level-Ansteuerung vor dem Anwender zu verbergen und ihn nur mit einer recht einfach zu handhabenden Schnittstelle bekanntzumachen, die sich auf das Wesentliche konzentriert. In diesem Hack möchte ich zeigen, wie man ein Lua-Modul programmiert, das ähnlich wie eine Bibliothek in ein späteres Lua-Projekt eingebunden werden kann. Die Ansteuerung über den I²C-Bus bleibt dem Anwender dadurch verborgen und er kann sein Augenmerk auf die Umsetzung seines Projektes richten. Dieser Hack soll einen kleinen Vorgeschmack auf die Erstellung eigener Module anhand des schon angesprochenen Port-Expander-Beispiels geben; Sie werden sicherlich viele eigene Ideen zu anderen Themen haben. Als Grundlage zur Programmierung werden wir wieder unser MCP23017-I/O-Board bemühen, das ich schon im IOExpander-Hack genutzt habe. Dort können Sie noch einmal nachschauen, wenn es um die genauen Adressen zur Ansteuerung des MCP23017-Bausteins geht. Doch beginnen wir mit einer einfachen Programmierung eines Lua-Moduls. Die Erstellung eines Lua-Moduls
Die Systembibliothek gestattet es, eigene Module zu erstellen bzw. zu laden. Ein Modul wird in einer tabellenähnlichen Struktur verwaltet. Unter package.loaded[Modul-name] ist dann das spätere Modul zu finden bzw. repräsentiert. Das kleine Modul, das ich zur Einführung erstellen möchte, besitzt lediglich Funktionen zum Addieren bzw. Multiplizieren zweier Zahlen und liefert das Ergebnis an den Aufrufer zurück. Erstellen wir also das Modul mit dem Namen test_mod und leiten es mit dem Code in Zeile 1 ein:
Abbildung 1 Das Test-Modul Über die letzte Zeile 13 wird das Modul mit einer return-Anweisung und dem Modulnamen abgeschlossen. Zwischen den Zeilen 1 und 13 befinden sich die beiden Benutzerfunktionen Add und Mult mit ihren entsprechenden Rechenoperationen. Nach der Abspeicherung z. B. unter dem Namen test_mod.lua kann dieses Modul jetzt über ein weiteres Skript angespro-
● 427
ESP8266 DE 160912.indd 427
04-10-1640 15:02
Das ESP8266-Praxisbuch Broker 350
Index
Build-Prozess 40 Bus-System 244
Symbols 25Q41BT 19 250VAC 335
C C++ 359 Callback-Funktion 189
A AC 74 Adafruit 64 Adapterplatine 26 AI-Thinker Aktive Bauelemente
44, 203 79
Alarmsystem 399 Alibaba 154 Ali Express Alternating Current
154 74
Amazon 152 Ampere 87 Analog/Digital-Wandler 162 Analog/Digital-Wandlung 383 Android Android Studio
263, 302 262
Anode 93 LED
186
Anschlussbeinchen 149 Antenne 19 API Key
213
App 302 App Inventor
263, 304
Arbeitsstromkreis 100 Arduino Serial Monitor
51, 202, 230 204
Arduino-IDE 239 Arduino Stackable Header
232
AT-Befehl 206 AT-Firmware
34
344
CET 344 CH340 57 China 154 Code-Snippet 165 Comma separated values
228
COM-Port 36 Conrad 157 Custom-Build 39 D Darlington-Transistor 405 Dateisystem 170 Datenbank 372 Datenbankgrundlagen 372 Datenbanksysteme 373 Datenflussrichtung 248 Datenübertragung 21 DC 74 Design-Fehler Arduino
232
Flachzange
233
DHT11 217 DHT22 217 Digilent 137 Digital/Analog-Wandlung 383 Diode
92, 125
Diodenmessung 125 Dip-Switch 62 Direct Current
74
Display 159
B Backslash 221 Baudrate 21 Biegeklotz
Central European Time
133, 147
Bit-Manipulation 339 Boardverwalter 239 Bohrungen 159
DNE 409 Draht 142 Dritte Hand DS18B20
132 217, 367
Durchgangsprüfung 124 Dynamic Host Configuration Protocol
211
Bootstrap 300 Breadboard
25, 133, 200
● 436
ESP8266 DE 160912.indd 436
04-10-1640 15:02
Index
E
FTDI-Programmer 27
Ebay 153
Funktionen 180
EEBoard 137
Future Technology Devices International
64
EEPROM 19 Ein-Draht-Bus 359
G
Einheiten 106
galvanische Trennung
Elektor 151
Gateway
Elektrolyt-Kondensator
88, 194
275 211, 295
General Purpose Input/Output (GPIO)
182
Elektronen 70
Gesamtspannung 23
Elektronik 70
Gesamtwiderstand 23
Elektronikkleinteile 156
Github 164
else-Zweig 176
Gleichstrom 74
ELV 157
Google Play
Endlosschleife 226
GPIO
263
Entwicklerplatine 158
Grundschaltungen 106
Entwicklungsumgebung 163
Gtronics.NET 136
29, 55, 182
Ereignis 303 ESP-01 19
H
ESP-12-Modul 54
Hayes 206
ESP13-Arduino-Shield 63
H-Bridge 407
ESP8266-Demo-Board 62
Header 230
ESP8266EX 19
Heap 31
ESP8266Flasher
Heißleiter 85
27, 36
ESP8266-Simpleboard 158
Helligkeitssensor 399
60
HTML 293
33
Hyperlink 297
ESP8266 Thing Dev ESP Flash Download Tool Esplorer
30, 163
ESP-Robot 415
I
ESPTool 45
I²C 244
Exp-Tech 157
IDE 163 if-Anweisung 176
F
Integer-Version 41
Festwiderstand 80
Integrated Circuit
100
Field Programmable Gate Array
integrierter Schaltkreis
100
100
Firmware-Upload 27 Flashen
Interpreter 33
27, 193
Intervall 188
Flash-ROM 19
IO-Board 256
Flash-Taster 194
IODIRA 248
Floatingpoint 40
IODIRB 248
FlyFun Tech
62
I/O-Expander 162
Fotodiode 276
iOS 263
FPGA 100
IP-Adresse 210
Freilaufdiode
96, 118, 406
iPhone 263
Fritzing 186
Isolierband 147
FS Info FTDI-Adapter
170 64, 282
● 437
ESP8266 DE 160912.indd 437
04-10-1640 15:02
Das ESP8266-Praxisbuch
J
Lua
Java 163
Lua-Modul 427
32, 165, 174, 187, 290
Jumper-Wire 140 M K
MAC-Adresse 210
Kabel 142
Magnetfeld 119
Kabelverbindungen 142
Makeblock 412
Kaltwiderstand 85
Massepotenzial 334
Kanalnummer 210
Master 244
Kathode 93
MB102-Breadboard 201
Fritzing 186
MCP23017
LED 186
Message Queue Telemetry Transport
Keramikkondensator 197
Messgerät 124
Kernel-Meldungen 44
MicroPython 32
Klemme 127
Micro-USB-Anschluss 410
Kommentare 179
Mignon-Zelle 130
Kondensator
88, 114, 193, 197
Mikrotaster 193
Kontrollstrukturen 178
Minicom 47
Konvertierung 327
Module 181
162, 246, 333, 427 350
Motor 404 L
MQTT
L293NDE 408
MQTT-Broker 351
L7805CV 409
MQTT-Server 362
Ladung 71
Multimeter
350, 359
123, 126
Ladungsunterschied 73 Lastkreis 332
N
Lauflicht 253
Net IO
LCDisplay 278
Netzmaske 211
LD33V 52
Netzwerknamen 210
LDR
83, 392
nil 175
LED
101, 182
NodeMCU
263
27, 54, 290
Leitfähigkeit 76
Non-OS SDK
Leuchtdiode
101, 182
Normalbetrieb-Modus 28
Level-Shifter 24
Notepad++ 280
Light Depending Resistor
NTC
Light Emitting Diode
83
34
85, 217
101
Linux 42
O
Linux-Mint 48
objektorientierte Programmierung
Litze 142
Ohmsche Gesetz
LM35 217
Ohm (Ω)
Lochrasterplatine 231
Olimex
415 77 76 54, 61
Lolin 58
One-Wire-Technik 359
Löten 144
Operatoren 177
Lötkolbenspitze 144
Optokoppler
275, 343
Lötstation 131
Oszilloskop
141, 317
Lötzinn 148
● 438
ESP8266 DE 160912.indd 438
04-10-1640 15:02
Index
P
Relais-Modul 333
paho-mqtt 370
rendern 324
Parallelschaltung
Resistor 76
Passive Bauelemente
108, 115 79
Roboter 404
Passwort 210
RST-Eingang 30
Patch-Kabel 140
RX (Empfangsleitung)
PC817 PCF8591
20
276, 343 162, 383, 399
S
PCF8592 389
Schaltfläche 302
Pfad 324
Schleifen 178
Ping 211
Schleifer 388
Pin-Layout-Schablone 162
Schraubendreher 121
Pin-Mapping 182
Schrumpfschlauch 146
Pinmode 182
SCL 245
PIR-Motion-Sensor 401
Screen 302
Pollin Electronic
157
SDA 245
246, 427
Sekunde 87
Port-Expander
Potentiometer 387
Selbstinduktion 119
Potenzialunterschied 73
Serial Monitor
Powerrails 200
Servo 259
204
print 176
Servo.h 261
Protoshield 136
Servo-Methoden 261
PTC 85
Servomotor
Publisher 350
SG92R 259
Pulldown-Widerstand 277
Shield
Pullup-Widerstand 56
Shift-Operator <<
Pullup-Widerstände 30
Signalstärke 210
Puls-Weiten-Modulation (PWM)
104, 259 51, 230 338
259, 314
Simpleboard 158
Punktrasterplatine 231
Sketch 202
PWM 314
Skriptsprache 174
PWM-Ansteuerung 320
Slave 244
Python 165
Slider 266
370
SoC 19
Python 2
Spalte 375 Q
Spannung
QR-Code 304
Spannungsmessung 127
Quarz 20
Spannungspegel 251
71, 73
Spannungsregler 409 R
Spannungsregulator 196
R4 277
Spannungsteiler
23, 388
Raspberry Pi
Spannungsversorgung
21, 182
42, 172, 351
Raspbian 172
Sparkfun
Register 248
Speicherbaustein 19
60, 64
Reichelt 157
Spule 404
Reihenschaltung
106, 114
Spulenspannung 119
99, 103
SQLite 371
Relais
● 439
ESP8266 DE 160912.indd 439
04-10-1640 15:02
Das ESP8266-Praxisbuch
SSD1306 159
UART 20
SSID (Service Set Identifier)
210
Übertragungsgeschwindigkeit 21
Stackable Header
283
Universal Asynchronous Receiver Transmitter 20
Steckbrett 133
Upload-Modus 28
Steckbrücken 140
User Interface
303
Steckverbinder 230 Steuerkreis 332
V
Steuer-Lastkreis-Kombination 332
Variablen 175
Steuerstromkreis 99
Verdrillen 143
String 221
Verschlüsselungsmodus 210
Strom 71
Verzweigungen 178
Stromkreis 77
Völkner 157
Strommessung 128
Vorwiderstände 111
Stromstärke 72 Subscribe 354
W
Subscriber 350
Wagenrücklauf 206
Syntax-Highlighting 164
Webserver
System on a chip
Wechselstrom 74
19
Widerstand T
290, 320 71, 75, 106
Widerstandsbiegelehre 132
Tabelle 374
Widerstandskette 107
Taster 102
Widerstandsmessung 126
Tastgrad 314
WiFi-Mode 286
TCP-Verbindung 220
WiFi-Modus 209
Teilspannung 23
Wire-Bibliothek 249
Teilwiderstand 23 Temperatursensor 209
Z
ThingSpeak
213, 395
Zangen 121
338
Z-Dioden 96
Tilde-Zeichen ~
Timezone 344
Zeichenkette 221
TO-92-Gehäuse 217
Zeilenvorschub 206
Tooltip 171
Zeit 344
96, 118
Zoll 155
Transmission 250
Zollbestimmungen 155
Transistor
Trenz-Elektronik 137 Trimmer 82 Trojan, Walter
362
tty 44 ttyUSB0 49 Tunneldioden 96 Tweet 395 Twitter 395 Two-Wire-Interface 244 TX (Sendeleitung)
20
U
● 440
ESP8266 DE 160912.indd 440
04-10-1640 15:02
Erik Bartmann
Der Bestseller-Autor Erik Bartmann hat sich ausführlich mit dem ESP8266 und dem NodeMCU beschäftigt. Heraus gekommen ist dabei Das ESP8266-Praxisbuch, in dem er die Leser Schritt für Schritt in die Arbeit mit diesen neuen, preiswerten Bauteilen einführt, mögliche technische Stolpersteine ausführlich behandelt und in zahlreichen Projekten die Praxistauglichkeit – angefangen bei einem selbst gebauten Webserver bis hin zu klugen Relay-Ansteuerung – belegt.
SHARE
Elektor-Verlag GmbH 52072 Aachen www.elektor.de
Mittlerweile existiert auch das Entwickler-Board NodeMCU, auf dem der ESP8266-Chip mit einem USB/Seriell-Adapter versehen wurde. Mit den integrierten Sockelleisten ist ein direkter Einsatz auf üblichen Breadboards möglich. Über den USB-Anschluss wird das Board mit Strom versorgt und kann über eine Software direkt angesprochen werden. Auch das NodeMCU-Board ist sehr preiswert und bereits für unter 5 Euro zu haben.
DESIGN
ISBN 978-3-89576-321-2
DAS ESP8266-PRAXISBUCH
●
Erik Bartmann ist Bestseller-Autor mit Büchern zu den Themen Arduino und Raspberry Pi. Er arbeitet als Software- bzw. Datenbankentwickler beim führenden ITInfrastrukturdienstleister in Europa. Mehr zu ihm unter www.erik-bartmann.de
Der ESP8266 ist ein programmierbares WLAN-Funkmodul mit zahlreichen Schnittstellen wie UART, I²C und SPI. Das Board ist sehr preiswert und bereits für unter 3 Euro verfügbar. Die UART-Schnittstelle sorgt dabei für eine einfache Integration in Mikrocontrollerprojekte. Das ESP8266-Modul kann hervorragend mit dem Arduino zusammenarbeiten und ermöglicht ihm über die serielle Schnittstelle den Zugang zum Netzwerk und Internet. Es existiert eine Implementierung des ESP8266Moduls in die Arduino-Entwicklungsumgebung. Aber auch als Standalone-Modul kann das ESP8266 eigenständig Programme abarbeiten und mit dem Internet kommunizieren, da es über einen eigenen Mikroprozessor und Speicher auf dem Board verfügt.
DAS ESP8266-PRAXISBUCH
DAS ESP8266-PRAXISBUCH
MIT NodeMCU UND ESPlorer
ERIK BARTMANN
MIT NodeMCU UND ESPlorer
Erik Bartmann LEARN
DESIGN
SHARE
LEARN
LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHAR ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● GN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHA ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ●