Das ESP8266-Praxisbuch (Leseprobe)

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 ●