Das ESP32-Praxisbuch (Leseprobe) by Elektor

ISBN 978-3-89576-333-5

Elektor-Verlag GmbH 52072 Aachen www.elektor.de

Der ESP32 verfügt über einen 240-MHz-Zweikern-Mikroprozessor mit einer Performanz von 600 DMIPS. Neben 520 KByte SRAM befinden sich 16 MByte Flashspeicher an Board. Zur Kommunikation mit der Außenwelt enthält das System-on-a-Chip die 802.11-b/g/n-WiFi-Komponente HT40 und BluetoothFunktionalität. Als Sensoren bietet der ESP32 einen Hall-Sensor, eine zehnfache, kapazitive Touch-Schnittstelle, einen analogen Verstärker für niedrige Signale und einen 32-kHz-Kristallquartz. Der Bestseller-Autor Erik Bartmann hat sich ausführlich mit dem neuen ESP32 beschäftigt. Heraus gekommen ist dabei Das ESP32-Praxisbuch,, in dem er die Leser Schritt für Schritt in die Arbeit mit diesem preiswerten WiFi-Mikrocontroller einführt. Das im Buch vorgestellte ESP32-Pico-Discovery-Board kann leicht nachgebaut werden oder auch als Kit bei Elektor unter der Bestellnummer 179006-71 bestellt werden.

DAS ESP32-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

Die WiFi-Module der chinesischen Firma Espressif haben schon längst die Maker-Community erobert, bieten sie doch zu einem konkurrenzlosen Preis MCU- und WiFi-Funktionalität. Mit einfachen Mitteln lässt sich ein Arduino mit einem ESP-Modul um WiFi erweitern. Die globale Bastler-Gemeinde ersetzte schon bald die integrierte Firmware mit eigener Firmware, sodass Entwickler ESP-Boards wie Arduino-Boards programmieren können. Der neue ESP32 geht einen Schritt weiter und ist in jeder Beziehung leistungsfähiger als der ESP8266. Zudem besitzt er nun Bluetooth-Funktionalität.

DAS ESP32-PRAXISBUCH

Erik Bartmann

PROGRAMMIEREN MIT DER ARDUINO-IDE

ERIK BARTMANN

DAS ESP32-PRAXISBUCH

DESIGN SHARE

PROGRAMMIEREN MIT DER ARDUINO-IDE

Erik Bartmann

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 ● SHARE ● LEARN ● DESIGN ● SHARE RN ● 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 ● SIGN ● 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 ● SHARE RN ● 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 ●

ESP32_Cover.indd All Pages

31/05/2018 08:14

Das ESP32-Praxisbuch Programmieren mit der Arduino-IDE

â&#x2014;? Erik Bartmann

LEARN DESIGN SHARE

Das ESP32 Praxisbuch DE 180509.indd 3

30-05-18 21:56

●

1. Auflage 2018

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. Lektorat: Volker Bombien, Bonn Umschlaggestaltung: Elektor, Aachen Satz und Aufmachung: D-Vision, Julian van den Berg | Oss (NL) Druck: Media-Print Informationstechnologie GmbH, Paderborn Printed in Germany

●

ISBN 978-3-895763-33-5

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 DIY-Elektroniker, die über verschiedene Medien (Magazine, Videos, digitale Medien sowie Social Media) in zahlreichen Sprachen verbreitet werden. www.elektor.de

LEARN DESIGN SHARE

Das ESP32 Praxisbuch DE 180509.indd 4

30-05-18 21:56

Inhalt Foreword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Einleitung • Das ESP32-Pico-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Grundlagen zum ESP32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Das ESP32-Pico-Discovery-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Ein weiteres ESP32-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Das ESP32-Wrover-KIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Downloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Installation • Der Arduino-Core für ESP32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Vorbereitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Mögliche Updates einspielen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Die Installation unter Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Hack 1 • Input/Output-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Wie kann man mit dem ESP32 kommunizieren? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Ein GPIO als Eingang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Die allgemeine Arduino-Programmstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 Die Arduino-Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Ein GPIO als Ausgang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Die Berechnung eines Vorwiderstands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 Der Farb-Code der Widerstände . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 Die I²C-Unterstützung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 Hack 2 • Temperaturmessung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Wir messen Umwelteinflüsse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Der DHT11-Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Blynk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Die Blynk-App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Hack 3 • Wir spielen mit Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Was ist Bluetooth? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Wie schaut den Workflow aus? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Die Android-App-Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 Deklaration von Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

●5

Das ESP32 Praxisbuch DE 180509.indd 5

30-05-18 21:56

Das ESP32-Praxisbuch BLE-Scannen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 App-Inventor-Projekt laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 Auf Helligkeitsänderungen reagieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 Ein LDR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 Hack 4 • Abruf von Wetterdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 Was ist OpenWeatherMap? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 Was ist das JSON-Format? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 Ein elektonisches Wetterhäuschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Der Aufbau des Wetterhäuschens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Servo mit externer Spannungsversorgung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Hack 5 • Port-Erweiterung und Roulette-Spiel . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 IO-Expansion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Der Port-Expander MCP23017 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Ein Roulette-Spiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Der MCP23017 liest Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 Hack 6 • Timer-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 Unterbrechungen per Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 Hack 7 • Ein externer Interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Unterbrechungen von außen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Ich wurde geprellt! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 Hack 8 • Ein Reaktionsspiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Wie schnell bist du? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Was soll erreicht werden? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Hack 9 • Puls-Weiten-Modulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Die Helligkeitssteuerung einer LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 PWM-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Auf- und Abblenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 Hack 10 • Digital-Analog-Wandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Bits in Spannung wandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Die Widerstandsleiter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 Der Schaltungsaufbau des R2R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

●6

Das ESP32 Praxisbuch DE 180509.indd 6

30-05-18 21:56

Inhalt Hack 11 • Sehr geräuschvoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 Wir erzeugen Töne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 Eine Sirene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 Hack 12 • Ein Keypad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Wir basteln uns ein Eingabefeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Vorbereitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Ein kleines Musikinstrument . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 Hack 13 • Der Motor und Touch-Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 Es kommt Bewegung ins Spiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 Der Transistor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Die Diode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Die H-Brücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 Der Motortreiber L293DNE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 Nicht immer volle Pulle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 Hack 14 • Der ESPTrak – Teil 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 Wir basteln uns ein Roboterfahrzeug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 Die Folientastatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 Das Fahrgestell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198 Die externe Spannungsversorgung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 Die beiden Platinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 Hack 15 • Der ESPTrak – Teil 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Die Programmierung des ESPTrak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Die Header-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Die Klassen-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Die Hauptdatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 Die Programmierung der ESPTrak-Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 Hack 16 • Ein Webserver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 Wir erstellen uns einen Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 Ein Web-Frontend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 Hack 17 • Ein Webserver steuert Relais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 Relais-Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 Das Web-Frontend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

●7

Das ESP32 Praxisbuch DE 180509.indd 7

30-05-18 21:56

Das ESP32-Praxisbuch Das Web-Frontend absichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 Hack 18 • Der Zugriff auf den Webserver von außen . . . . . . . . . . . . . . . . . . . . . . 237 Netzwerkzugriff von überall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 Hack 19 • MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 Was ist MQTT? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 Die Installation von MQTT unter Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 Die Installation von MQTT unter Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 Hack 20 • MQTT konkret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 Messwerteversand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 Mehrere Temperatursensoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256 Hack 21 • MQTT und die Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 Wir speichern unsere Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 Die Installation von paho-MQTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 Die Installation von SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Ein paar nützliche Datenbankgrundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Das Anlegen einer Datenbank und Tabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 Das Hinzufügen eines Datensatzes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 Das Anzeigen von Tabelleninhalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 Den Inhalt einer Tabelle löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 Das Python-Skript speichert die Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 Hack 22 • Der Hall-Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 Der Hall-Effekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 Hack 23 • Der Schrittmotor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 Ein ganz besonderer Motor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 Der Motortreiber A4988 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 Die A4988-Pins im Detail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 Hack 24 • Eine Zeichenmaschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 Wir werden kreativ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 Hack 25 • Die Siebensegmentanzeige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 Wir steuern einzelne Segmente an . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 Wir verbessern den ESP32-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

●8

Das ESP32 Praxisbuch DE 180509.indd 8

30-05-18 21:56

Hack 26 • Die Programmiersprache MicroPython . . . . . . . . . . . . . . . . . . . . . . . . . 295 Ein Blick über den Tellerrand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 Wir Testen MicroPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 Das Blinken einer LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 Die uPyCraft IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 Einen Taster abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 Skript nach Booten ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 Hack 27 • Der Ultraschall-Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 Wir messen Entfernungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 Der Ultraschall-Sensor HC-SR04 im Detail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 Der Spannungsteiler von 5V auf 3,3V . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306 Die Interaktion mit Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 Hack 28 • Deep Sleep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 Wir gehen schlafen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 Der ESP32-Code für ewiges Schlafen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 Zurück ins Leben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Wir retten Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 Aufwachen durch externes Signal ext0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 Aufwachen durch externes Signal ext1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

●9

Das ESP32 Praxisbuch DE 180509.indd 9

30-05-18 21:56

Das ESP32-Praxisbuch

Foreword When I learned that Erik Bartmann was writing another book about our new ESP32 chip, I was very happy. Espressif is also about the democratization of technology; we believe that cheap open source technology could be a way to create new solutions for problems, such as global warming and pollution in the future; and to have Erik to write a book on ESP32 is a great addition to ESP32 ecosystem. I remembered 2016 when Erik wrote the first maker book about our ESP8266 chip; at that time I held the full coloured book in my hands and although I didn't understand a word of German, the structure of the book immediately made me realize that it was both a textbook on basic electronics and a great introduction to the Wi-Fi module. I was very happy and honoured to learn that it was gratefully accepted by the Makers' community in Germany. The new ESP32 chip brings significant enhancements to the Maker world. Bluetooth functionality is becoming increasingly important in IoT applications. I am convinced that the ESP modules -- along with Arduino and Raspberry Pi -- have become another important technical platform for the global Maker community. I thank Erik for recognizing the potential of our microcontrollers so early on and help introduce them up to the Makers world. In Summer 2018 Teo Swee Ann, Founder and CEO of Espressif Systems

â&#x2014;? 10

Das ESP32 Praxisbuch DE 180509.indd 10

30-05-18 21:56

Einleitung • Das ESP32-Pico-Board

Einleitung • Das ESP32-Pico-Board Grundlagen zum ESP32 Das Internet der Dinge – im Speziellen IoT-Anwendungen – sind heute der Standard und auch in der DIY-Welt spielen sie mehr und mehr eine führende Rolle. Was früher über Client-Server- Architekturen abgewickelt wurde, bei denen eine zentrale Instanz mit Intelligenz die anfallenden Daten verarbeitete und quasi in alleiniger Regie zur Verfügung stellte, schaut heute im IoT-Umfeld etwas anders aus. Es werden anwendungsspezifische bzw. physikalische Bus-Systeme auf eine andere Ebene gehoben, so dass sie für offene Netzwerkschnittstellen wie LAN, WLAN oder Bluetooth zur Verfügung stehen. Auf diese Weise können IoT-Plattformen selbstständig Daten über angeschlossene Sensoren und Aktoren sammeln, sie verarbeiten und über die genannten offenen Netzwerkschnittstellen zur Verfügung stellen. Diese Dezentralisierung erlaubt es, ein mehr oder weniger flächendeckendes Netzwerk mit benötigten Daten zur etablieren, das allen Anforderungen der heutigen Zeit genügt. Und da kommt unser ESP32-Modul ins Spiel, das ebenfalls über diese genannten Technologien verfügt. Beim ESP32 handelt es sich um einen Mikrocontroller, der von der Firma Espressif entwickelt wurde, die in China beheimatet ist. Dieser Chip stellt eine logische Weiterentwicklung des ESP8266 dar. Mehr SRAM-Speicher, höhere CPU-Geschwindigkeit, Bluetooth-Kommunikation, mehr Schnittstellen-Pins (GPIOs), Touch-Sensorik, A/D- bzw. D/A-Wandlung sind nur einige der Highlights des ESP32. Auf der folgenden Abbildung ist ein Entwickler-Board zu sehen, das über diesen ESP32-Chip verfügt.

Abbildung 1: Das ESP32-Pico-Board V4 Es handelt sich um das ESP32-Pico-Board V4. Werfen wir einmal einen Blick auf das Board und sehen uns an, über welche Komponenten die kleine Platine verfügt. Die folgende Abbildung ist mit den Beschriftungen der wichtigsten Bauteile versehen, die uns im Moment interessieren.

● 11

Das ESP32 Praxisbuch DE 180509.indd 11

30-05-18 21:56

Hack 1 • Input/Output-Grundlagen

Hack 1 • Input/Output-Grundlagen Wie kann man mit dem ESP32 kommunizieren? Das ESP32-Pico-Board besitzt ja zahlreiche Pins, die zur Kommunikation bzw. zum Datenaustausch genutzt werden können. Wir wollen in diesem Hack das Basiswissen zur Programmierung des ESP32-Pico-Boards erlangen. Die Pins, die für den Datenaustausch genutzt werden, nennen werden GPIO – kurz auch IO – genannt. Diese vier Buchstaben stehen für General Purpose Input Output. Es handelt sich dabei um eine elektrische Verbindung zum Mikrokontroller, dessen Verhalten zu Projektbeginn noch nicht bestimmt ist. Ein einzelner Pin kann also als Eingang, als Ausgang fungieren oder anderweitige Funktionen übernehmen, wie z. B. als Bus bei I2C oder SPI. Erst durch die spätere Programmierung wird derartigen Pins eine spezielle Aufgabe bzw. ein Zweck zugewiesen. Sehen wir uns das im Detail an. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich: Bauteile 1 x Widerstand 10 KΩ (braun/schwarz/orange) 1 x Widerstand 330 Ω (orange/orange/braun) 2 x Widerstand 4,7 KΩ (gelb/lila/rot) 1 x LED (rot)

1x LC-Display (I2C-Version)

1 x Mikrotaster

Tabelle 1 Erforderliche Bauteile Ein GPIO als Eingang Wir wollen einen GPIO-Pin als Eingang nutzen, was bedeutet, dass er von außen auf Signale in irgendeiner Weise reagieren soll. Die einfachste Art, einen Eingang zu nutzen, besteht im Anschluss eines Tasters oder Schalters. Wir nutzen dazu sogenannte Mikrotaster.

● 31

Das ESP32 Praxisbuch DE 180509.indd 31

30-05-18 21:56

Hack 2 • Temperaturmessung

Hack 2 • Temperaturmessung Wir messen Umwelteinflüsse Wenn es darum geht, Temperatur und Luftfeuchtigkeit gleichermaßen zu ermitteln, sind die Sensoren vom Typ DHT in die engere Wahl zu ziehen. Wir wollen in diesem Hack die genannten Werte ermitteln und verarbeiten. Der Sensor, den wir verwenden, ist vom Typ DHT11. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich: Bauteile 1 x Temperatur- und Feuchtigkeitssensor DHT11

3 x Widerstand 4,7KΩ 1x LC-Display (I2C-Version)

Tabelle 1 Erforderliche Bauteile Der DHT11-Sensor Bevor wir loslegen können, ist natürlich die Pin-Belegung des DHT11 erforderlich, die auf der folgenden Abbildung zu sehen ist.

Abbildung 56: Der Sensor DHT11

● 55

Das ESP32 Praxisbuch DE 180509.indd 55

30-05-18 21:56

Hack 3 • Wir spielen mit Bluetooth

Hack 3 • Wir spielen mit Bluetooth Was ist Bluetooth? Der konventionelle Datenaustausch erfolgt über Kabel und ist mit zunehmender Distanz zwischen einem Sensor und dem Computer nicht praktikabel. Der bessere Weg besteht in der Nutzung der Funkübertragung wie z. B. WLAN oder Bluetooth. Bleiben wir in diesem Hack bei Bluetooth. Es handelt sich dabei um eine drahtlose Kommunikation, die im gleichen Frequenzband wie WLAN von 2,4GHz stattfindet. Es kann also ggf. zu Störungen durch Überlagerungen kommen. Wir wollen in diesem Hack das ESP32-Pico-Board dazu verwenden, einen analogen Messwert zu erfassen und per Bluetooth an ein Android-Smartphone bzw.-Tablet zu versenden. Es gilt also, zwei voneinander getrennte Instanzen zu entwickeln und zu programmieren. Die Messwertaufnahme erfolgt natürlich wieder über die Arduino-Entwicklungsumgebung, wobei die Programmierung der App über den App-Inventor erfolgt. Wir sehen das alles gleich im Detail. Es kommt jedoch nicht das traditionelle Bluetooth zur Anwendung, sondern das sogenannte BLE (Bluetooth Low Eneregy), was eine Funktechnik darstellt, mit der sich Geräte in einer Entfernung von unter 10 Metern vernetzen lassen. Im Vergleich zum "normalen" Bluetooth zeichnet sich BLE Smart mit einem deutlich geringeren Stromverbrauch und geringeren Kosten aus. Technisch gesehen ist BLE nicht rückwärtskompatibel, sodass neuere Bluetooth-Geräte zusätzlich den sogenannten LE-Protokollstapel unterstützen müssen, um sich erfolgreich verbinden zu können. BLE ist zudem nicht dafür gedacht, ununterbrochen große Mengen Daten zu verarbeiten. Das ESP32-Pico-Board als "Server" benachrichtigt über ein sogenanntes "Notify" bei Bedarf das Smartphone bzw. das Tablett, die Daten bereitzustellen. Es ist bei Smartphones bzw. Tabletts darauf zu achten, dass sie Bluetooth 4.0 unterstützen.

Wie schaut den Workflow aus? Schauen wir uns zu Beginn der Workflow – also den Weg der Daten vom Sender (Sensor) zum Empfänger (Android-App) – genauer an.

Abbildung 71: Der Weg der Daten Von links nach rechts werden die Messwerte vom Potentiometer aufgenommen, zu einem analogen Eingang des ESP32-Pico-Boards geleitet, dort verarbeitet und auf die offene Netzwerkebene von Bluetooth gehoben, über die Antenne versendet, vom Smartphone

● 69

Das ESP32 Praxisbuch DE 180509.indd 69

30-05-18 21:56

Das ESP32-Praxisbuch

Hack 4 • Abruf von Wetterdaten Was ist OpenWeatherMap? Bei OpenWeatherMap handelt es sich um einen Online-Dienst, der über eine frei verfügbare Programmierschnittstelle (API) Wetterdaten, Wettervorhersagen und historische Wetterdaten bereitstellt.

Die Internetadresse dieses Dienstes lautet: https://openweathermap.org/ Da unser ESP32 über WLAN-Funktionalität verfügt, ist es ein Leichtes, damit über den heimischen Router ins Internet zu gelangen. Bevor wir jedoch diesen Dienst nutzen können, ist eine Registrierung erforderlich, denn für das Abrufen der Wetterdaten braucht man einen sogenannten API-Key, der an den jeweiligen Account gebunden ist. Er sollte nicht an Dritte weitergegeben und nur für private Zwecke genutzt werden. Was haben wir in diesem Hack vor? Nun, wir werden aktuelle Temperaturwerte herunterladen und sie dann später zur Statusanzeige dafür verwenden, ob man in kurzen Hosen oder im Schneeanzug das Haus verlassen sollte. Früher hat man sich zur Wettervorhersage auf das Wetterhäuschen verlassen und geschaut, welche Figur auf dem Eingang kam.

Heute nutzen wir die moderne Technik und sehen, was wir damit so anstellen können. Nach der Registrierung ist unter dem Reiter API keys der erforderliche Key zu finden.

Abbildung 82: Der OpenWeatherMap-API-Key

● 84

Das ESP32 Praxisbuch DE 180509.indd 84

30-05-18 21:56

Das ESP32-Praxisbuch

Hack 5 • Port-Erweiterung und Roulette-Spiel IO-Expansion Das ESP32-Pico-Board besitzt von Hause aus schon einige GPIO-Pins, deren Anzahl in den meisten Fällen zur Umsetzung von eigenen Projekten sicherlich ausreicht. Dennoch gibt es einen sehr interessanten Ansatz, die vorhandenen Pins mit einem Baustein zu erweitern, und das in sehr großer Zahl. Die Steuerung erfolgt über den schon angesprochenen I2CBus. Der Baustein, der als IO-Expander bezeichnet wird, trägt die Bezeichnung MCP23017. Die Ansteuerung bzw. die Konfiguration ist dabei sehr einfach und ist schnell erledigt. Es gibt schon fertige Libraries, die die Unterstützung nochmals um einiges einfacher gestalten, doch aus Verständnisgründen möchte ich quasi den Weg zu Fuß beschreiben. Der Port-Expander MCP23017 Auf der folgenden Abbildung sehen wir den Port-Expander MCP23017 mit seinen vielen Pins.

Abbildung 102: Der Port-Expander MCP23017 Da wir schon einige Erfahrungen mit dem I2C-Bus gemacht haben, stellt die Verwendung dieses Bausteins keine große Hürde dar. Wie man auf der folgenden Abbildung sehen kann, hat der MCP23017 eine Menge Anschlussbeinchen, denn er verfügt über zwei Ports (A und B) mit jeweils 8 Bits. Sehen wir uns dazu einmal die Pin-Belegung an.

Abbildung 103: Die Pin-Belegung des Port-Expanders MCP23017 Dieser Baustein passt wunderbar auf unser kleines Breadboard und ist schnell verkabelt. Doch zuvor müssen wir uns noch über einige kleine Details unterhalten. Lassen wir uns

● 104

Das ESP32 Praxisbuch DE 180509.indd 104

30-05-18 21:56

Hack 6 • Timer-Grundlagen

Hack 6 • Timer-Grundlagen Unterbrechungen per Programm Die meisten Mikrocontroller verfügen über interne Zähler, die je nach Konfiguration einen bestimmten Wertebereich durchlaufen. Sie werden auch Timer genannt und können für die unterschiedlichsten Aufgaben verwendet werden. Auf den ersten Blick ist diese Funktionalität nichts Besonderes, denn in einem Programm kommen sicherlich des Öfteren Schleifen zum Einsatz, die eine ähnliche Funktionalität vorweisen. Doch diese Schleifenzähler sind meistens Teil eines Hauptprogramms und blockieren bei ihrem Durchlauf andere Ausführungen, da sie eine lineare Vorgehensweise haben und nicht darauf ausgelegt sind, auf mögliche Ereignisse zu reagieren. Wenn ein Timer jedoch konfiguriert und aktiviert wird, findet seine Ausführung quasi im Hintergrund statt, und er kann eine Unterbrechung – einen sogenannten Interrupt – auslösen, wenn ein bestimmter Umstand eintrifft. Stellen wir uns ein Autorennen vor, das über mehrere Runden, sagen wir 80, zu fahren ist. Erreicht ein Wagen die Start/Ziel-Markierung, wird der Rundenzähler erhöht. Da so ein Rennen jedoch sehr lange dauern kann und ich sehr gefräßig bin, nehme ich mir vor, dass ich bei jeder 20. Runde zur Imbissbude laufe und mir eine Currywurst kaufe. Das Ereignis löst bei mir einen Interrupt aus und veranlasst mich, etwas anderes zu tun, als auf das Rennen zu achten. Werden wir konkret und übertragen dieses Szenario auf die ESP32-Timer-Programmierung. Unser ESP32 besitzt intern zwei Hardware-Timer-Gruppen.

Jede dieser Gruppen verfügt über zwei 64-Bit Hardware-Timer mit 16-Bit-Prescalern, die herauf- und herunterzählen können. Ein Prescaler ist ein Vorteiler, der den eigentlichen Takt herunterteilen kann. Darüber kann der auszulösende Interrupt konfiguriert und angepasst werden. Die folgende Abbildung wird den Vorgang eines Timers mit auslösenden Interrupts sicherlich verdeutlichen.

Abbildung 119: Ein Timer wird hochgezählt Der besseren Übersicht wegen habe ich die Datenbreite des Registers auf 4 Bits gekürzt, was einem Wertebereich von 0 bis 15 entspricht. Wenn der letzte darstellbare Wert – der

● 119

Das ESP32 Praxisbuch DE 180509.indd 119

30-05-18 21:56

Hack 7 • Ein externer Interrupt

Hack 7 • Ein externer Interrupt Unterbrechungen von außen Im letzten Hack haben wir uns mit internen Zählern, den Timern, befasst, die beim Erreichen durch von uns definierten Zuständen einen Interrupt auslösten, wodurch eine Funktion aufgerufen wurde. Diese Interrupt-Funktion hat dann im Hintergrund ohne einen direkten Aufruf der loop-Funktion bestimmte Aktionen ausgeführt. Kommen wir jetzt zu einem Thema, das sich ebenfalls mit Interrupts befasst, die jedoch von außen angestoßen werden. Sie werden als externe Interrupts bezeichnet. Machen wir uns zunächst wieder ein paar grundlegende Gedanken. Wenn es darum geht, einen oder mehrere Eingänge an einem Mikrocontroller abzufragen, kann man das in der regulären und linearen Programmierung durchaus einplanen und umsetzen. Angenommen, wir wollen innerhalb unserer loop-Funktion folgende Schritte abarbeiten: • eine LED ansteuern • einen Servo bewegen • einen Taster abfragen Auf der folgenden Abbildung zeige ich diese drei Schritte auf.

Abbildung 128: Das kontinuierliche Abarbeiten von Arbeitsschritten Wir können uns das zeitlich gesehen vereinfacht so vorstellen: Auf einer Zeitskala werden nacheinander die Zeitschlitze 1, 2 und 3 kontinuierlich angefahren und abgearbeitet. An Zeitschlitz 1 wird die LED angesteuert. An Zeitschlitz 2 wird der Servo bewegt und erst an Zeitschlitz 3 fragen wir den Status des Tasters ab. Beim ersten Durchlauf der loop-Funktion drücken wir innerhalb von Zeitschlitz 2 den Taster, was dazu führt, dass diese Aktion vom Programm nicht registriert wird. Erst beim zweiten Durchlauf der loop-Funktion habe ich den Taster zum rechten Zeitpunkt der Abfrage in Zeitschlitz 3 gedrückt, und das Programm kann entsprechend darauf reagieren. Die folgende Abbildung zeigt diesen Sachverhalt.

● 127

Das ESP32 Praxisbuch DE 180509.indd 127

30-05-18 21:57

Hack 8 • Ein Reaktionsspiel

Hack 8 • Ein Reaktionsspiel Wie schnell bist du? Es ist an der Zeit, die Themen verschiedener Hacks miteinander zu verknüpfen, und das machen wir am besten mit einem Reaktionsspiel. Bei unserem Spiel geht es darum, auf ein optisches Signal zu reagieren – und das so schnell wie möglich. Wir nutzen dazu eine kleine Ampelsteuerung, bei der die Phasen Rot, Gelb und Grün angezeigt werden. Wir haben es also mit der Ansteuerung von LEDs zu tun, die nach einem bestimmten Schema aufleuchten. Die Reaktion des Spielers erfolgt durch einen Tastendruck, der unmittelbar vom Programm registriert werden muss. Es bietet sich deshalb an, einen externen Interrupt auszulösen und ihn dann zu verarbeiten. Das haben wir im letzten Hack schon kennengelernt. Natürlich sollte die Reaktionszeit zur Anzeige gebracht werden, was mit einer Anzeige im Serial-Monitor möglich ist, doch ich finde eine Darstellung über das LC-Display viel besser. Das hat u. a. den Vorteil, dass das Spiel ohne einen angeschlossenen Computer ausgeführt werden kann. Dieses Thema haben wir ebenfalls schon in einem Hack abgehandelt, somit stehen uns alle Grundlagen zur Verfügung, ein Reaktionsspiel umzusetzen. Was soll erreicht werden? Mit dem geplanten Spiel soll es möglich sein, die Reaktionszeit des Spielers zu ermitteln. Es werden dabei – ähnlich wie bei einer Ampel im Straßenverkehr – die Phasen Rot, Rot/ Gelb und Grün zur Anzeige gebracht. Erst beim Erreichen der Grünphase soll ein Taster gedrückt werden, wodurch dann die Reaktionszeit zwischen dem Erreichen von Grün und dem Tastendruck ermittelt wird. Erfolgt ein vorzeitiger Tastendruck vor dem Erreichen der Grünphase, soll das mit einer entsprechenden Meldung angezeigt werden. Die Anzeige der Meldungen soll in einem LC-Display erfolgen. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich: Bauteile 1x LC-Display (I2C-Version)

2 x Widerstand 4,7KΩ (gelb/lila/rot) 3 x Widerstand 330Ω (orange/orange/braun) 1 x Widerstand 10KΩ (braun/schwarz/orange)

● 135

Das ESP32 Praxisbuch DE 180509.indd 135

30-05-18 21:57

Hack 9 • Puls-Weiten-Modulation

Hack 9 • Puls-Weiten-Modulation Die Helligkeitssteuerung einer LED Wir hatten das Thema PWM, also Puls-Weiten-Modulation schon im Hack mit den Wetterdaten kurz angerissen. Dort haben wie PWM zur Ansteuerung des Servo-Motors genutzt. Nun wollen wir das gleiche Prinzip auf die Ansteuerung einer LED verwenden und darüber die Helligkeit zu steuern. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich: Bauteile 10 x Widerstand 330Ω (orange/orange/braun) 10 x LED (rot)

1 x Potentiometer 10KΩ

Tabelle 1 Erforderliche Bauteile PWM-Grundlagen Die meisten Mikrocontroller besitzen – wenn es um die Ansteuerung von Verbrauchern geht – von Hause aus lediglich digitale Ausgänge. Damit kann man, wenn es um Themen der Digitaltechnik geht, einiges bewirken, um die Verbraucher an- bzw. auszuschalten, also z. B. Leuchtdioden, Lampen, Relais oder auch Motoren, um nur einige wenige zu nennen. Wenn wir aber z. B. eine LED oder einen Motor nicht ausschließlich in ihren Grenzzuständen – an oder aus – betreiben möchten, wird es mit digitalen Ausgängen schwierig, das Vorhaben umzusetzen. Wir können damit entweder 0V oder die Betriebsspannung von 3,3V an den Verbraucher schicken. Es gibt keinerlei Abstufungen oder Zwischenwerte, damit die LED nur halb so hell leuchtet oder sich der Motor nur halb so schnell dreht. Wir benötigen also einen analogen Ausgang, der z. B. den Verbraucher mit lediglich 1,5V versorgt. Das ist ungefähr die Hälfte des Wertes der Betriebsspannung, womit auch weniger Energie zum Betreiben eines Verbrauchers zur Verfügung steht. Doch es hilft alles nichts, ein derartiger analoger Ausgang steht uns nicht zur Verfügung. Und dennoch gibt es einen Trick, um einen Verbraucher mit regelbarer Energie zu versorgen. Mir fällt ein Beispiel aus der Praxis ein, das zum Verständnis dessen, worauf ich hinaus möchte, sicher helfen wird. Zur Behandlung von Hautwucherungen werden teilweise Laser eingesetzt, die das Gewebe auf der Haut – laienhaft ausgedrückt – wegbrennen. Es ist aber keinesfalls wünschenswert, den Laserstrahl mit voller Leistung auf die betroffene Wucherung zu lenken, weil darunterliegende oder benachbarte nicht erkrankte Hautregionen in Mitleidenschaft gezogen würden.

● 141

Das ESP32 Praxisbuch DE 180509.indd 141

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 10 • Digital-Analog-Wandlung Bits in Spannung wandeln Wir haben gesehen, wie man mithilfe eines ADC (Analog/Digital-Converter) analoge Werte verarbeiten kann. Dazu stehen uns beim ESP32-Pico-Board 16-Kanäle zur Verfügung. Beim Arduino-Board gibt es vergleichbare 6 analoge Eingänge, die ebenfalls analoge Spannungen messen können. Wir sehen also, dass analoge Eingänge bei verschiedenen Mikrocontrollerboards durchaus vorhanden sind. Wollen wir jedoch analoge Signale aus digitalen Werten erzeugen, was über einen DAC (Digital/Analog-Converter) erfolgen kann, sieht es beim Arduino-Board schlecht aus. Mit unserem ESP32-Pico-Board sind wir da schon besser gestellt. Er verfügt über 2 unabhängige DAC mit einer 8-Bit-Auflösung, die digitale Signale in analoge wandeln. Ein DAC (Digital-to-Analog Converter), auch Digital-Analog-Wandler genannt, wird verwendet, um digitale Signale in analoge Signale umzusetzen. DACs sind grundlegende Komponenten vieler Geräte der digitalen Unterhaltungselektronik (z. B. CD-, DVD- und BlueRay-Player) und der Kommunikationselektronik (z. B. Smartphones oder Funkgeräte). Die beiden IO-Pins IO25 und IO26 können als DAC1 und DAC2 genutzt werden und sind hier auf der linken Seite in lila gekennzeichnet.

Abbildung 151: Die zwei Digital/Analog-Converter (DAC1 und DAC2) Ich sagte, dass die beiden DAC eine Auflösung von 8-Bit besitzen. Die Auflösung sagt uns, in welchen kleinen Schritten die Spannung erhöht werden kann. Um das Ergebnis zu ermitteln, muss die sogenannte Referenzspannung bekannt sein, und die beträgt bei unserem ESP32-Pico-Board natürlich 3,3V. Die allgemeine Formel zur Bestimmung des genannten kleinsten Wertes lautet:

● 150

Das ESP32 Praxisbuch DE 180509.indd 150

30-05-18 21:57

Hack 11 • Sehr geräuschvoll

Hack 11 • Sehr geräuschvoll Wir erzeugen Töne In diesem Hack wollen wir mit einfachsten Mitteln Töne erzeugen. Ich nutze dafür einen Piezo-Summer. Bei diesem Piezo-Element handelt es sich um ein Bauteil, das den sogenannten Piezo-Effekt ausnutzt, um entweder durch das Anlegen einer elektrischen Spannung eine mechanische Bewegung zu bewirken oder bei der Einwirkung einer mechanischen Kraft eine elektrische Spannung zu erzeugen. Wir werden Ersteres nutzen, um durch das Anlegen einer Spannung die Membran auszulenken. Wenn wir das in unterschiedlicher Geschwindigkeit machen, entstehen Töne in verschiedenen Frequenzen. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich: Bauteile 1 x Piezo-Summer (z. B. EKULIT 1096)

Tabelle 1 Erforderliche Bauteile Hier noch ein kleiner Hinweis: Es gibt sogenannte aktive Buzzer, die ebenfalls Töne von sich geben. Doch sie geben nach dem Anlegen einer Spannung immer ein und denselben Ton von sich und sind aus diesem Grund für unser Experiment nicht geeignet. Eine Sirene Bei unserem ersten Test mit dem Piezo-Summer werden wir ihn einfach mit einem GPIOPin verbinden und im Wechsel mit 3,3V bzw. 0V versorgen. Machen wir das mit verschiedenen Pausen zwischen dem Wechsel, erhalten wir verschiedene Töne. Sehen wir uns zuerst den Schaltplan an, der ausgesprochen übersichtlich ist. Der Schaltplan Auf der folgenden Abbildung sehen wir eine Schaltung, bei der der GPIO-Pin 21 den Piezo-Summer ansteuert.

● 159

Das ESP32 Praxisbuch DE 180509.indd 159

30-05-18 21:57

Hack 12 • Ein Keypad

Hack 12 • Ein Keypad Wir basteln uns ein Eingabefeld Was ein Taster ist und wie er arbeitet, haben wir schon in diversen Hacks kennengelernt. Für manch ein Projekt bzw. Hack ist es aber notwendig, mehrere Taster in einer Matrix, also in Zeilen und Spalten anzuordnen, um beispielsweise mit den Ziffern von 0 bis 9 und zwei Sondertasten wie * und # arbeiten zu können. Wo wird das benötigt? Nun, man verwendet diese Kombination von Tasten täglich, z. B. beim Telefonieren.

Abbildung 160: Die Wahltasten eines Telefons Es handelt sich um eine Matrix von 4x3 (4 Zeilen und 3 Spalten) Tasten. Diese Matrix wird auch Keypad – kleine Tastatur – genannt, es gibt sie fertig in unterschiedlichen Varianten zu kaufen. Auf der folgenden Abbildung sehen wir zwei Folien-Keypads. Das linke besitzt sogar zusätzliche Sondertasten A bis D, die sehr sinnvoll sein können, falls die 12 Tasten des rechten Keypads für einen Hack nicht ausreichen.

Abbildung 161: Ein 4x4-Folien-KeyPad mit 16 Tasten und ein 4x3-Folien-KeyPad mit 12 Tasten Um eine Abfrage aller 16 Taster zu ermöglichen, benötigen wir eigentlich 16 Leitungen. Das ist eine ganze Menge, und wenn es noch mehr Taster werden, erhöht sich die Leitungsanzahl entsprechend. Es gibt aber eine viel elegantere Lösung. Das Stichwort lautet Multiplexing. Es bedeutet, dass bestimmte Signale zusammengefasst und über ein Übertragungsmedium geschickt werden, um den Aufwand an Leitungen zu minimieren und so

● 163

Das ESP32 Praxisbuch DE 180509.indd 163

30-05-18 21:57

Hack 13 • Der Motor und Touch-Sensor

Hack 13 • Der Motor und Touch-Sensor Es kommt Bewegung ins Spiel Schon als Kind fand ich es sehr spannend, ein elektrisch betriebenes Fahrzeug zu besitzen, was man fernsteuern kann. Zu Beginn war das nur über Kabel möglich, später auch über eine Funkfernsteuerung. In diesem Hack lernen wir einiges über die Ansteuerung von Gleichstrommotoren und natürlich die Steuerung über Funk. Ein ganz normaler Gleichstrommotor mit lediglich 2 Anschlüssen kann über das ESP32-Pico-Board angesteuert werden. Doch so einfach, wie es sich vielleicht anhört, ist es dann doch nicht, denn die GPIO-Pins sind nicht in der Lage, einen oder auch mehrere Gleichstrommotoren direkt anzusteuern. Fangen wir ganz von vorne an und sehen, worauf zu achten ist. Bevor wir beginnen, sollten wir uns ein paar Gedanken über die Ansteuerung eines Motors machen. Wenn ein Motor fest mit einer Spannungsquelle verbunden wird, gibt es nur zwei Zustände:

Abbildung 171: Die Ansteuerung eines Motors Wir sehen, dass der Motor über das Schaltzeichen fest in der Schaltung verdrahtet wurde und die beiden Zustände "Motor dreht sich" bzw. "Motor steht" annehmen kann. Für die Ansteuerung eines Roboterfahrzeugs ist diese Schaltung aber nicht zu gebrauchen, denn wie sollte es in die entgegengesetzte Richtung fahren können? Ein Anschluss ist immer mit +12V und der andere mit 0V verbunden. Damit der Motor sich in entgegengesetzter Richtung dreht, müsste man entweder die Spannungsquelle oder den Motor umpolen. Das ist jedoch nicht praktikabel, deshalb verwenden wir später eine besondere Schaltung, die das Umpolen ermöglicht. Zunächst jedoch wenden wir uns dem Ansteuern eines Gleichstrommotors zu und dem, was dabei zu beachten ist. Sehen wir uns zunächst die Liste der erforderlichen Bauteile für diesen ersten Teil des Hacks an. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich:

● 173

Das ESP32 Praxisbuch DE 180509.indd 173

30-05-18 21:57

Hack 14 • Der ESPTrak – Teil 1

Hack 14 • Der ESPTrak – Teil 1 Wir basteln uns ein Roboterfahrzeug Auf der folgenden Abbildung ist ein Roboterfahrzeug zu sehen, das in den 1980er-Jahren sehr beliebt war. Man kann über eine Tastatur Fahrbefehle eingeben, die zu einer Sequenz zusammengefasst werden und die Befehle am Ende abrufen. Das Fahrzeug kann auf diese Weise einen mehr oder weniger komplexen Parcours abfahren. Es macht mir heute noch sehr viel Spaß, dieses Spielzeug hervorzuholen.

Abbildung 194: Der BigTrak aus den 1980ern Dieses Fahrzeug wollen wir in diesem Hack – natürlich ein wenig abgewandelt – selbst bauen. Es geht also nicht schon wieder um ein weiteres Roboterfahrzeug neben den 1001 schon im Internet vorhandenen Beispielen. Es wird ein Fahrgestell benötigt, das mit zwei Gleichstrommotoren angetrieben wird und die gibt es wie Sand am Meer. Auf der folgenden Abbildung habe ich zwei meiner Fahrgestelle aufgebaut. Das linke ist von der Firma Makeblock, ein Kettenfahrzeug mit einem Arduino-kompatiblen Mikrocontroller. Das rechte Fahrgestell ist von mir aus Bauteilen von Lego zusammengebaut worden.

Abbildung 195: Verschiedene Fahrgestelle (links Makeblock, rechts Lego) Dieser Hack ist aufgrund der Komplexität in zwei Teile untergliedert. Im ersten Teil geht es

● 193

Das ESP32 Praxisbuch DE 180509.indd 193

30-05-18 21:57

Hack 15 • Der ESPTrak – Teil 2

Hack 15 • Der ESPTrak – Teil 2 Die Programmierung des ESPTrak Da die Programmerstellung zur Steuerung des ESPTrak etwas umfangreicher ist, werden wir die sogenannte objektorientierte Programmierung – kurz OOP – nutzen. Damit ist es uns möglich, gewisse Programmteile auszulagern und modular zu gestalten. Da dies kein Buch über die OOP ist, kann ich nur auf entsprechende Fachliteratur oder das Internet verweisen. Dennoch versuche ich natürlich, das Ganze so klar wie möglich zu erklären. Wenn in der Arduino-Entwicklungsumgebung Bibliotheken zur Verfügung gestellt werden, handelt es sich in der Regel um programmtechnische Erweiterungen, die einen OOP-Ansatz besitzen. Das bedeutet, dass eine Klassendefinition vorhanden ist, aus der später Objekte erstellt werden. Derartige Bibliotheken bestehen meistens aus mindestens zwei Dateien. Es handelt sich um eine Klassen-Definitionsdatei mit der Endung .cpp und eine Header-Definitionsdatei mit der Endung .h. Diese beiden Dateien sollen unsere Motorsteuerung vereinfachen und dafür sollen sie Teil des ESP32-Projektes werden. In der Arduino-IDE können neben der eigentlichen Hauptdatei mit der Endung .ino weitere Dateien hinzugefügt werden. In der rechten oberen Ecke der IDE ist ein kleines nach unten weisendes Dreieck zu sehen. Durch einen Mausklick darauf öffnet sich eine Menüstruktur. Für das Anlegen einer neuen Datei muss der Eintrag Neuer Tab gewählt werden.

Abbildung 211: Eine neue Datei (neuer Tab) hinzufügen Im Anschluss erscheint unterhalb der eigentlichen Quellcodes ein Dialog, der es uns ermöglicht, den Namen der neuen Datei inklusive Dateiendung einzugeben. Wir nennen diese Datei Motor.cpp.

Abbildung 212: Den Namen der neuen cpp-Datei (neuer Tab) hinzufügen Im zweiten Schritt muss die Anlage der Header-Datei auf dieselbe Art und Weise erfolgen.

Abbildung 213: Den Namen der neuen h-Datei (neuer Tab) hinzufügen

● 207

Das ESP32 Praxisbuch DE 180509.indd 207

30-05-18 21:57

Hack 16 • Ein Webserver

Hack 16 • Ein Webserver Wir erstellen uns einen Server Im Wetterdaten-Hack haben wir schon gesehen, wie man zu einem entfernten Server im Internet eine Verbindung aufbauen kann, um darüber die unterschiedlichsten Daten abzurufen. In diesem Hack wollen wir selbst einen Server einrichten, der eine Webseite zur Verfügung stellt. Ein derartiger Webserver stellt quasi einen Dienstleister dar, der Informationen – wie immer die auch aussehen mögen – an Clients weiterleitet. Das geschieht in der Regel nur auf Anfrage (Request), und heutzutage wird ein Webbrowser dazu verwendet, der diese Aufgabe übernimmt. Diese Client-Server-Architektur stellt eine Möglichkeit dar, Informationen innerhalb eines Netzwerks zu verteilen.

Abbildung 218: Eine Client-Server-Architektur Wie schaut das jetzt aber hinsichtlich eines Webbrowsers und eines Webservers aus? Wenn wir eine Adresse in das Adressfeld des Browsers eingeben, so erfolgt das über eine sogenannte URL (Uniform Resource Locator) und definiert eine Ressource. In unserem Fall ist dies eine Internetseite.

Abbildung 219: Webbrowser und Webserver im Zusammenspiel Die URL in einem Webbrowser kann in lesbarer Form erfolgen, wie z. B. meine eigene, die über die folgende Internetadresse zu erreichen ist:

● 219

Das ESP32 Praxisbuch DE 180509.indd 219

30-05-18 21:57

Hack 17 • Ein Webserver steuert Relais

Hack 17 • Ein Webserver steuert Relais Relais-Control Im vorangegangen Hack haben wir gesehen, wie einfach es ist, über eine Weboberfläche einzelne LEDs anzusteuern. Richtig interessant wird es aber erst, wenn man auf diese Weise z. B. Lampen, eine Kaffeemaschine oder einen elektrischen Rollladen steuern kann. Die Grundlagen hierfür wollen wir uns in diesem Hack ansehen. 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 wird. 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 225: 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. Ausschalten möchten, eignet sich dafür ein sogenanntes Relais. Eine mögliche und recht einfache Schaltung ist die Ansteuerung einer Lampe:

Abbildung 226: Die Ansteuerung einer Lampe über ein Relais Der Schalter S im Steuerkreis steuert die Lampe L im Lastkreis. Etwas Ähnliches wollen wir jetzt mit unserem ESP32-Pico-Board versuchen. Natürlich ist dazu noch ein zusätzliches Bauteil in Form eines Relais-Moduls erforderlich, das eine einfache Ansteuerung ermöglicht. Das folgende 4-Kanal-Relais-Modul besitzt vier unabhängig ansteuerbare Relais.

● 229

Das ESP32 Praxisbuch DE 180509.indd 229

30-05-18 21:57

Hack 18 • Der Zugriff auf den Webserver von außen

Hack 18 • Der Zugriff auf den Webserver von außen Netzwerkzugriff von überall Im vorangegangen Hack haben wir gesehen, wie man sehr einfach im eigenen Hausnetz auf den Webserver des ESP32-Pico-Boards zugreifen kann, um dann z. B. das angesprochene Relais-Modul zu steuern. Sitzt man jedoch auf der Arbeit und möchte schon einmal die Kaffeemaschine anschalten oder auch einen elektrischen Rollladen rauf- oder runterfahren, steht man vor einem Problem. Der Zugriff über das Internet auf unseren Webserver funktioniert nicht so ohne Weiteres. Eine charmante Lösung bietet ngrok, das über die folgende Internetadresse zu erreichen ist: https://ngrok.com Dieser Service etabliert einen Tunnel durch das Internet bis zum eigenen Hausnetz. Sehen wir uns das im Detail an. Folgende Schritte sind erforderlich: Einen Account anlegen Nach dem Besuch der Internetseite von ngrok ist u. a. die folgende Schaltfläche zu sehen:

Abbildung 236: Wir starten mit ngrok Über einen Klick darauf gelangen wir zu der Seite, die es uns ermöglicht, einen Account anzulegen. Das folgende Formular muss dafür ausgefüllt werden:

Abbildung 237: Der ngrok-Account wird angelegt Nach der Angabe des Namens, der E-Mail-Adresse, einem Passwort, der Bestätigung, dass man ein Mensch ist, und das abschließende Anklicken der Create an Account-Schaltfläche,

● 237

Das ESP32 Praxisbuch DE 180509.indd 237

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 19 • MQTT Was ist 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 Dinge (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 ist hier die Namensgebung etwas anders, was aber im Endeffekt auf dasselbe herauskommt. Es existiert 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 244: MQTT-Kommunikation Damit wir aber in die ganze Kommunikation eine gewisse Ordnung bekommen, erfolgt der Datenaustausch über sogenannte Topics, wobei die Struktur an den Seitenaufbau eines Webservers erinnert. Dort sind die einzelnen Unterseiten in einer bestimmten Hierarchie angeordnet. Ein Topic wird dazu verwendet, die Daten von verschiedenen Sensoren, die quasi als Clients arbeiten, auf dem MQTT-Broker zu filtern. Ein Topic kann wie folgt strukturiert sein:

● 242

Das ESP32 Praxisbuch DE 180509.indd 242

30-05-18 21:57

Hack 20 • MQTT konkret

Hack 20 • MQTT konkret Messwerteversand In diesem Hack wollen wir die Sache mit MQTT ein wenig vertiefen und einen Temperatursensor verwenden, um die Messwerte später an den Broker zu versenden. Wir benutzen zu diesem Zweck einen sehr bekannten Temperatursensor vom Typ DS18B20. 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. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich: Bauteile 1 x Temperatursensor DS18B20

1 x Widerstand 4,7KΩ (gelb/lila/rot)

Tabelle 1 Erforderliche Bauteile Diesen Sensor gibt es noch wasserdicht verschweißt und somit ist er auch für Feuchträume geeignet.

Abbildung 251: Spezieller wasserdichter Temperatursensor in Edelstahl verpackt Auf der folgenden Abbildung sehen wir die Pin-Belegung.

● 249

Das ESP32 Praxisbuch DE 180509.indd 249

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 21 • MQTT und die Datenbank Wir speichern unsere Daten In den nun folgenden Schritten dieses Hacks werden wir besprechen, wie es möglich ist, die Publish-Informationen an den MQTT-Server abzufangen und entsprechend aufzubereiten, sodass sie in eine Datenbank gespeichert werden können. Als Beispiel soll diesmal – wie schon angekündigt – ein Raspberry Pi herhalten, auf dem die notwendige Software im Handumdrehen mit wenigen Befehlen installiert wird. Ich nutze dazu den Raspberry Pi 3, es funktioniert aber auch mit älteren Versionen.

Abbildung 260: Der Raspberry Pi Die Installation von MQTT – wir erinnern uns – lautet auf dem Raspberry Pi wie auch auf dem Linux Mint: # sudo apt-get update # sudo apt-get upgrade # sudo apt-get install mosquitto mosquitto-clients

Zu Beginn versehen wird die Programmiersprache Python mit einem weiteren Package, das eine Bibliothek darstellt und eine Verbindung zum MQTT-Server herstellt. Danach installieren wir eine Datenbank, die die Messwerte aufnimmt und komfortabel verwaltet. Mit SQL-Befehlen ist es dann recht einfach, auf die Datensätze zuzugreifen und sie nach Belieben zu filtern. Die folgende Abbildung zeigt die Struktur des Ablaufs.

Abbildung 261: Der Datenfluss vom Sensor über MQTT bis hin zur Datenbank

● 258

Das ESP32 Praxisbuch DE 180509.indd 258

30-05-18 21:57

Hack 22 • Der Hall-Sensor

Hack 22 • Der Hall-Sensor Der Hall-Effekt Beim Magnetismus handelt es sich um ein physikalisches Phänomen, das sich z. B. als Kraft zwischen Magneten äußert. Aber auch stromdurchflossene Leitern bilden ein Magnetfeld aus konzentrischen Kreisen. Ein Stabmagnet ist ein Körper, der andere Körper, z. B. aus Eisen, magnetisch anzieht oder abstößt. Die magnetische Anziehungs- bzw. Abstoßungswirkung ist ein grundlegendes Naturphänomen. Auf der folgenden Abbildung sehen wir einen Magneten, der aus vielen kleinen Scheiben zusammengesetzt ist, die seine Wirkung in Summe noch verstärken. Es sind die beiden Pole (Nord- und Südpol) und die entsprechenden Feldlinien zu sehen.

Abbildung 273: Ein Magnet Es gibt einen speziellen Sensor, der diese Feldlinien messen kann. Er wird Hall-Sensor genannt. Wird ein Hall-Sensor von einem Strom durchflossen und in ein senkrecht dazu verlaufendes Magnetfeld geführt, liefert der Sensor – vereinfacht gesprochen – eine Ausgangsspannung, die vom magnetischen Einfluss abhängt und Hall-Effekt genannt wird. Unser ESP32-Modul besitzt einen internen Hall-Sensor, der zur Messung von Feldlinien genutzt werden kann. Es gibt dafür die unterschiedlichsten Anwendungen wie z. B. • die Magnetfeldmessung • berührungsfreier Kontaktsensor • Schichtdickenmessung • Lageermittlung von Permanentmagneten • etc. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich: Bauteile 1 x Permanentmagnet

Tabelle 1 Erforderliche Bauteile

● 271

Das ESP32 Praxisbuch DE 180509.indd 271

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 23 • Der Schrittmotor Ein ganz besonderer Motor Wenn man mithilfe eines Motors eine sehr präzise und wiederholbar genaue Positionierung erreichen muss, dann sind Gleichstrommotoren denkbar ungeeignet. Die Welle dreht sich beim Anlegen einer Spannung und hört auf damit, wenn die Spannung weggenommen wird. Ein Nachlaufen ist dabei fast sicher. Es gibt andere Motoren, die dafür besser geeignet sind. Im Wetterdaten-Hack sind wir das erste Mal mit einem Bauteil – dem Servo – in Berührung gekommen, das elektrischen Strom in Bewegung umwandelt. Sein Aktionsradius ist von Haus aus insofern eingeschränkt, als dass er sich nur um 1800 drehen kann. Natürlich gibt es Modifikationen, um dieses Manko zu beheben, doch für die meisten Anwendungszwecke reicht es durchaus. Falls mehr Aktionsfreiheit verlangt wird, kommt der Schrittmotor zum Einsatz. Das Einsatzgebiet für Schrittmotoren ist sehr weit gefächert, man findet sie z. B. in folgenden Geräten: • Drucker • Flachbettscanner • CD/DVD-Laufwerke bzw. Festplatten • 3D-Drucker • CNC-Maschinen Auf dem folgenden Bild sehen wir einen universellen Schrittmotor, der für Bastelprojekte sehr gut geeignet ist und der um die 10 € kostet.

Abbildung 276: Ein Schrittmotor Dieser Schrittmotor ist mit 4 Anschlüssen versehen, die wir uns ein wenig genauer anschauen wollen. Das Schaltbild eines Schrittmotors sehen wir auf der folgenden Abbildung. Wir müssen auf jeden Fall auf die farbigen Leitungen achten, denn zwei bilden immer ein Paar. • Schwarz + Grün • Rot + Blau

● 274

Das ESP32 Praxisbuch DE 180509.indd 274

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 24 • Eine Zeichenmaschine Wir werden kreativ In den 1980er-Jahren war ein Spielzeug für kreatives Zeichen sehr angesagt. Es nannte sich Spirograph und man konnte mit ihm verschiedene Muster oder auch mathematische Kurven zeichnen. Nähere Informationen dazu, sind z. B. unter der folgenden Internetadresse zu finden: https://de.wikipedia.org/wiki/Spirograph_(Spielzeug) Ich habe versucht, das Prinzip mit zwei Schrittmotoren umzusetzen, obwohl das natürlich auch mit ganz einfachen Gleichstrommotoren oder auch Servos zu realisieren ist. Auf der folgenden Abbildung ist meine Zeichenmaschine zu sehen.

Abbildung 281: Eine Zeichenmaschine Der Schrittmotor auf der rechten Seite treibt die Gelenke an, an dessen einem Ende sich der Zeichenstift befindet. Auf der linken Seite befindet sich die Zeichenunterlage, die auf einer alten CD angebracht wurde, die ihrerseits vom zweiten Schrittmotor in Rotation versetzt wird. Auf dem ESP32-Pico-Board sind auf dem kleinen Breadboard zwei Motortreiber vom Typ A4988 aufgesteckt, die die beiden Schrittmotoren individuell ansteuern. Welche Bauteile werden benötigt? Die folgenden Bauteile sind zur Umsetzung des Hacks erforderlich:

● 280

Das ESP32 Praxisbuch DE 180509.indd 280

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 25 • Die Siebensegmentanzeige Wir steuern einzelne Segmente an Wenn wir logische Zustände (wahr oder falsch) oder Daten (14, 2.5, »Hallo User«) in irgendeiner Form visualisieren wollten, müssen wir z. B. LEDs ansteuern, auf den Serial-Monitor zurückgreifen oder das schon verwendete LC-Display bemühen. In der Elektronik gibt es weitere Anzeigeelemente und eines davon ist die sogenannte Siebensegmentanzeige. Wie der Name schon vermuten lässt, besteht diese Anzeige aus sieben einzelnen Elementen, die in einer bestimmten Form angeordnet sind, um Ziffern und in beschränktem Maße auch Zeichen darstellen zu können.

Abbildung 283: Eine Siebensegmentanzeige Wir sehen, dass jedes der sieben Segmente mit einem kleinen Buchstaben versehen wurde. Die Reihenfolge spielt zwar keine unmittelbare Rolle, doch die hier gezeigte Form hat sich etabliert und wird fast überall verwendet. Darum werden wir sie auch beibehalten. Wenn wir die einzelnen Segmente geschickt ansteuern, können wir unsere Ziffern von 0 bis 9 gut abbilden. Es sind auch Buchstaben möglich, auf die wir etwas später zu sprechen kommen werden. Wir sehen des Öfteren im Alltag verschiedene Siebensegmentanzeigen, ohne dass wir weiter darüber nachdenken. Hier eine kleine Liste der Einsatzmöglichkeiten: Preisanzeige an Tankstellen (sie zeigen irgendwie immer zu viel an ...) • Zeitanzeige an hohen Gebäuden • Temperaturanzeige • Digitaluhren • Blutdruck-Messgeräte • elektronische Fieberthermometer In der folgenden Tabelle wollen wir für die zukünftige Programmierung festhalten, bei welchen Ziffern welches der sieben Segmente angesteuert werden muss.

● 284

Das ESP32 Praxisbuch DE 180509.indd 284

30-05-18 21:57

Hack 26 • Die Programmiersprache MicroPython

Hack 26 • Die Programmiersprache MicroPython Ein Blick über den Tellerrand Ich hatte es im Installationskapitel schon kurz angedroht und nun ist es so weit: Neben der Programmiersprache C++, die wir bisher mit der Arduino-Entwicklungsumgebung reichlich genutzt haben, möchte ich noch eine weitere Programmiersprache anreißen. Es geht um MicroPython. Es handelt sich um eine Variante von Python, die speziell für den Einsatz auf Mikrocontrollern entwickelt wurde. MicroPython ist eine Neuimplementierung von Python 3, die mithilfe der Programmiersprache C entwickelt wurde. Es sind die heutzutage gängigen programmtechnischen Komponenten wie Compiler, Parser, VM (virtuelle Maschine), RTE (Runtime Environment – Laufzeitumgebung) und GC (Garbage Collector – automatische Speicherbereinigung) vorhanden. Damit das Ganze auch flexibel und für den universellen Einsatz auf Mikrocontrollern geeignet ist, sind diverse Bibliotheken vorhanden. Der Name MicroPython lässt vermuten, dass es sich um eine kleinere Version des großen Bruders Python (Version 2 bzw. 3) handelt, wobei naturgemäß nicht alle Sprachmerkmale vorhanden sind, denn der Speicher auf Mikrocontrollern ist hier und da sehr begrenzt. Gehen wir jetzt die Installation an. Python in der Version 2.7 müssen wir – falls noch nicht geschehen – zuerst auf unserem Rechner installieren. Ich verwende als Beispiel meinen Windows-10Rechner. Schritt 1: (Installation von Python 2.7) Unter der folgenden Internetadresse kann das Installationspaket von Python 2.7 heruntergeladen werden: https://www.python.org/downloads/

Abbildung 289: Die Auswahl der richtigen Python-Version Schritt 2: (Installation des ESPTools) Im nächsten Schritt muss die neueste Version des esptool auf dem Rechner installiert werden. Das erfolgt über die Kommandozeile von Python. Falls auch noch nicht geschehen, muss die Umgebungsvariable PATH angepasst werden, um den Installationsspfad von Python 2.7 hinzuzufügen. Der Pfad ist standardmäßig C:\Python27.

● 295

Das ESP32 Praxisbuch DE 180509.indd 295

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 27 • Der Ultraschall-Sensor Wir messen Entfernungen Was fällt uns zum Thema Ultraschall spontan ein? Ich muss direkt an Fledermäuse denken, die mithilfe eines hochfrequenten Signals beim Fliegen navigieren oder auch Beutetiere wie Insekten fangen. Der Ultraschall liegt oberhalb des menschlichen Hörfrequenzbereichs und beginnt ab circa 16KHz. Die Fledermäuse senden ein Signal aus und analysieren das zurückgeworfene Echo, sodass sie auf Größe und Entfernung von beispielsweise einer Fliege schließen können. Die Stärke des reflektierten Signals ist gleichbedeutend mit der Größe des Objekts, das als Ziel erkannt wurde, und die Laufzeit des Schalls ist ein direktes Maß für die Entfernung des Objekts. In ähnlicher Weise arbeitet ein Ultraschall-Sensor, den wir im folgenden Hack einsetzen wollen. Es gibt im Hobbybereich eine große Anzahl von Modulen, die in ähnlicher Weise arbeiten. Auf der folgenden Abbildung sehen wir drei unterschiedliche Sensoren.

Abbildung 304: Verschiedene Ultraschall-Sensoren Der günstigste Ultraschall-Sensor ist der HC-SR04, der im Arduino-Umfeld sehr verbreitet ist und im 5er-Pack für ungefähr 7€ zu bekommen ist. Also eine sehr kostengünstige Variante, im Gegensatz zum Ping von Parallax, der mit über 30€ pro Stück zu Buche schlägt. Der Sensor von Makeblock ist aufgrund des RJ-25 Anschlusses speziell für Produkte von Makeblock vorgesehen, kann aber auch über kleine Buchsen mithilfe von Patch-Kabeln ganz normal verwendet werden. Dieser Sensor gleicht demjenigen von Parallax, ist aber preislich um einiges günstiger. Diese Sensoren sind jedoch für eine Betriebsspannung von 5V vorgesehen und können so nicht ohne Weiteres mit 3,3V betrieben werden. Natürlich werden wir gleich sehen, dass auch das ohne größeren Aufwand möglich ist. Wie aber arbeitet ein Ultraschall-Sensor eigentlich? Jeder Sensor verfügt in der Regel über zwei kleine zylinderförmige Röhren auf einer kleinen Platine. Es handelt sich um den Sender und den Empfänger. Sehen wir uns das Funktionsprinzip in der folgenden Abbildung genauer an.

● 304

Das ESP32 Praxisbuch DE 180509.indd 304

30-05-18 21:57

Das ESP32-Praxisbuch

Hack 28 • Deep Sleep Wir gehen schlafen Unser ESP32-Modul wird natürlich mit Spannung betrieben, die entweder über ein Netzteil oder auch eine Batterie zur Verfügung gestellt wird. Auf dem Modul sind die unterschiedlichsten Komponenten wie CPUs, RAM, ROM, Wifi, Bluetooth, RTC-Modul und andere vorhanden, die natürlich im Normalbetrieb alle mit Spannung versorgt werden müssen. Das geht im Falle von batteriebetriebener Versorgung natürlich schnell auf Kosten der Kapazität der Batterie, denn der Stromfluss ist mehr oder weniger hoch. Gerade die CPUs, das Wifi und Bluetooth sind sehr hungrig, wenn es um die Stromversorgung geht. Was aber, wenn unser ESP32-Modul nur zu bestimmten Zeiten bzw. auf bestimmte Ereignisse reagieren soll, um dann erst mit der Arbeit zu beginnen? Vorher würde demnach unnötigerweise Strom verbraucht, der später, wenn es wirklich darauf ankommt, vielleicht zur Neige geht. Es gibt dafür eine Lösung, die sich beim ESP32 Deep-Sleep-Mode nennt. Unter der folgenden Internetadresse sind detaillierte Informationen zu finden: https://esp-idf.readthedocs.io/en/v2.0/api/system/deep_sleep.html Wir können also das ESP32-Modul in einen Tiefschlaf versetzen, was nahezu alle Komponenten deaktiviert. Natürlich muss es auch eine Möglichkeit geben, den Schlafenden wieder zu wecken. Aus diesem Grund bleibt das sogenannte RTC-Modul (RTC ist die Abkürzung für Real Time Clock) aktiv. Es beinhaltet den RTC-Controller, RTC-Peripherie und RTC-Memory. Für den niedrigen Stromverbrauch während dieser Tiefschlafphase sorgt ein ULP-Prozessor (Ultra-Low-Power). Es lassen sich in diesem Fall bis zu 8 KByte an Daten und Programmen in das SRAM der RTC auslagern, was in dieser Phase den Zugriff auf die Timer, Interrupts und Peripherie ermöglicht. Das Einleiten der Aufwachphase kann über verschiedene Ereignisse erfolgen: • Timer Wakeup • External Wakeup • ULP Coprocessor Wakeup Wir werden uns in diesem Hack dem External Wakeup über einen Touch-Sensor widmen. Bevor wir beginnen, mache ich einen kurzen Test hinsichtlich des Stromverbrauchs im Normalbetrieb und im Deep-Sleep-Mode. Dazu habe ich mein USB-Kabel aufgetrennt und in die Stromversorgung mein Multimeter eingeschleift, um den Stromverbrauch anzeigen zu lassen.

● 318

Das ESP32 Praxisbuch DE 180509.indd 318

30-05-18 21:57

Index

Index Symbolen * (Sondertaste) # (Sondertaste)

I 163 163

A Anode 179 gemeinsame 286 Typ SA 39-11 GE 286 Arbeitsstrom 175 Arbeitsstromkreis 175

IDE Compiler-Meldungen Editor Status-Informationen Tabulatoren

36 35 35 36

K Kathode 179 gemeinsame 286 Kollektor 175

B BC547C 177 BC557C 177 Beinchenpaare Mikrotaster 32

D Dezimalpunkt 287 Diode 178 Schaltzeichen 179 Direction-Register 105 DP (Dezimalpunkt) 287 Dreieck Treibersymbol 188

L LED Anode Kathode Licht emittierende Diode (LED) Light-Emitting-Diode (LED)

43 43 43 43

M Makeblock 304 Motor Ansteuerung 173 H-Bridge 186 umpolen 173 Multiplexing 163

E Emitter 175

N NPN 176

F Farbkodierungstabelle 47 Festwiderstand Schaltzeichen 32, 47 Folien-KeyPad 163

Germanium 178

Parallax 304 Ping 304 PNP 176 Prellen 130 println 291 Pulsbreite 95

Halbleiterelemente 178 H-Bridge 185 HC-SR04 304, 305 H-Schaltung 185

R2R-Netzwerk 152 RJ-25 Anschluss 304

S Schrittmotor 274

â&#x2014;? 333

Das ESP32 Praxisbuch DE 180509.indd 333

30-05-18 21:57

Das ESP32-Praxisbuch

bipolarer 275 Serial-Monitor 36 Servo Frequenz 94 Pulsbreite 95 Silizium 178 Steuerstrom 175 Syntax-Highlighting 35

T Tabelle 263 Tabulatoren 36 Taster 32 Kreuzungspunkte 164 prellen 131 Transistor 176 Basis 175 Collektor 175 Emitter 175 Transistors Schaltzeichen 175 Treiber Symbol 188

U Ultraschall-Sensor 304

V Verstärker 174 Verstärkung 175

W Widerstand Farbkodierung 46 Widerstandsleiter 152

● 334

Das ESP32 Praxisbuch DE 180509.indd 334

30-05-18 21:57

ISBN 978-3-89576-333-5

Elektor-Verlag GmbH 52072 Aachen www.elektor.de

DAS ESP32-PRAXISBUCH

●

DAS ESP32-PRAXISBUCH

Erik Bartmann

PROGRAMMIEREN MIT DER ARDUINO-IDE

ERIK BARTMANN

DAS ESP32-PRAXISBUCH

DESIGN SHARE

PROGRAMMIEREN MIT DER ARDUINO-IDE

Erik Bartmann

LEARN

LEARN DESIGN SHARE

ESP32_Cover.indd All Pages

31/05/2018 08:14