Der ESP32 ist ein kostengünstiger Microcontroller der Firma Espressif, zu dem es verschiedene Entwicklungsboards mit unterschiedlicher Hardwareausstattung gibt.

Hardware

Das von mir genutzte Board heißt DEBO JT ESP32.

Das Pin-Layout vom Datenblatt entspricht dem folgenden:

Pin-Layout ESP32

Von den 25 GPIO-Pins können

  • 15 als analoge Pins (ADC)
  • 2 für Digital-nach-Analog-Umwandlung (DAC)
  • 9 als kapazitive Toch-Eingänge verwendet werden.

Alle als Output geschalteten Pins können auch PWM.

Nur die Pins < 34 können Output, siehe hier: https://techoverflow.net/2020/02/22/ how-to-fix-esp32-micropython-valueerror-pin-can-only-be-input/

Programmierung

Es gibt verschiedenen Möglichkeiten, um den ESP32 zu programmieren:

ESP-IDF:

  • offizelle Entwicklungsumgebung des Herstellers
  • Programmiersprache C

Arduino-IDE:

  • Programmiersprache C++

NodeMCU:

  • Programmiersprache Lua
  • Entwicklungsumgebung ESPlorer oder ChiliPeppr ESP32 Web IDE

Verwendet man MicroPython, gibt es wiederum mehrere Möglichkeiten, den Programmcode zu erstellen und auf den ESP32 zu übertragen:

  • mit der Python-IDE Thonny
  • mit der Erweiterung Pymakr im Editor VSCode bzw. im Editor Atom
  • mit der MicroPython-IDE uPyCraft
  • auf der Kommandozeile mit ampy

Es gibt also viele Möglichkeiten und man kann die wählen, die am ehesten den persönlichen Vorlieben enstpricht. Ich habe bislang folgende Umgebungen ausprobiert:

  • Arduino-IDE
  • MicroPython mit Kommandozeilentool ampy
  • MicroPython mit dem Addon Pymakr im Editor VSCode

Da ich gerne Python und VSCode als Editor nutze, ist letzteres für mich die Umgebung der Wahl.

Tutorials

Hier noch ein paar Links zu hilfreichen Tutorials, die zum Teil andere Umgebungen nutzen.

https://open.hpi.de/courses/mikrocontroller2019

Hier wird der ESP32 über die die Arduino IDE bzw. über die graphische Oberfläche ArduBlockly programmiert.

Micropython mit ESP 32 - Youtube

  • Nutzung von Micropython
  • IDE Thonny

Micropython Grundlagen

Verwendung der Arduino IDE für ESP32

Wenn man zuvor Micropython verwendet hat, muss man den ESP32 zunächst wieder in den Ursprungszustand flashen.

Um die Arduino IDE für die Programmierung des ESP32 zu nutzen, geht man wie folgt vor:

  1. Arduino IDE starten
  2. Unter Datei - Voreinstellungen unter “Zusätzliche Boardverwalter-URLS” folgende URL eingeben: https://dl.espressif.com/dl/package_esp32_index.json
  3. Unter Werkzeuge - “Board Arduino Uno” auf Boardverwalter klicken
  4. Unter Werkzeuge - Port /dev/ttyUSB0 auswählen

Zum Testen:

  1. Unter Datei - Beispiele - ESP32 - ChipID - GetChipID auswählen
  2. Hochladen klicken
  3. Werkzeuge - serieller Monitor öffnen
  4. Ausgabe des Testprogramms anschauen

Zunächst kam unter Manjaro eine Fehlermeldung bzgl. serieller Schnittstelle wie hier: https://bugs.archlinux.org/task/62704

Lösung:

  • Alte Java-Version jre8 - alle Pakete entfernt
  • Aktuelle Java-Version 14.02 erneut installiert.
  • Neustart Arduino-IDE

Folgender Arduino-Sketch bringt die blaue interne LED (GPIO 2) zum Blinken.

void setup() {
  // initialize digital pin 2 as an output.
  pinMode(2, OUTPUT);
}

void loop() {
  digitalWrite(2, HIGH);
  delay(1000);
  digitalWrite(2, LOW);
  delay(1000);

Verwendung Micropython für den ESP32

Um MicroPython auf dem ESP32 zu nutzen, muss zunächst die Micropython-Firmware auf den ESP32 geflashed werden. Dieser Vorgang ist unabhängig davon, welches Tool man später zum Ausführen bzw. zum Übertragen der Python-Programme nutzt.

Man kann die MicroPython-Firmware hier herunterladen: http://micropython.org/download/esp32/. Wir wählen die neueste “stable idf3”: http://micropython.org/resources/firmware/esp32-idf3-20200902-v1.13.bin,

Geflashed wird mit dem esptool, das per pip installiert werden kann:

$ sudo pip install esptool

esptool.py findet sich (in meinem Setting) dann hier:

$ cd /usr/lib/python3.8/site-packages

Mit folgendem Befehl kann der Flash-Speicher des ESP32 gelöscht werden. Dazu muss eventuell die BOOT-Taste gedrückt gehalten, dann die EN-Taste gedrückt und dann die BOOT-Taste wieder losgelassen werden.

$ python3 esptool.py --port /dev/ttyUSB0 erase_flash
esptool.py v2.8
Serial port /dev/ttyUSB0
Connecting........__
Detecting chip type... ESP32
Chip is ESP32D0WDQ6 (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
Crystal is 40MHz
MAC: 24:6f:28:7b:98:e4
Uploading stub...
Running stub...
Stub running...
Erasing flash (this may take a while)...
Chip erase completed successfully in 9.4s
Hard resetting via RTS pin...

Und mit folgendem Befehl kann dann die neue Micro-Python-Firmware übertragen werden:

$ python esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 /mnt/Daten/Computer/esp32/esp32-idf3-20200902-v1.13.bin 
esptool.py v2.8
Serial port /dev/ttyUSB0
Connecting....
Chip is ESP32D0WDQ6 (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
Crystal is 40MHz
MAC: 24:6f:28:7b:98:e4
Uploading stub...
Running stub...
Stub running...
Configuring flash size...
Auto-detected Flash size: 4MB
Compressed 1448768 bytes to 926007...
Wrote 1448768 bytes (926007 compressed) at 0x00001000 in 82.0 seconds (effective 141.3 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Danach kann man sich über die serielle Schnittstelle mit dem ESP32 verbinden und landet direkt im interaktiven MicroPython-Prompt, dem sogenannten REPL(= Read Evaluate Print Loop). Für die serielle Verbindung kann man unter Linux beispielsweise das Programm picocom nutzen.

$ picocom -b 115200 /dev/ttyUSB0

>>> 5*4
20
>>>

Bei Verwendung von MicroPython können auf dem Microcontroller Dateien gespeichert werden. Zwei Python-Dateien spielen dabei eine besondere Rolle:

Die Datei boot.py wird beim Start und beim Reset des ESP32 ausgeführt. Danach wird die Datei main.py ausgeführt. Sie enthält üblicherweise den Programmcode, der vom ESP32 ausgeführt werden soll, wenn er nicht über USB mit dem Computer verbunden ist.

Wie kommen nun diese Dateien auf den ESP32? Zur Übertragung kann entweder das Kommandozeilentool ampy, die IDE Thonny oder der VSCode mit dem pymakr-Plugin genutzt werden.

MicroPython mit ampy

Mit ampy kann man über die Kommandozeile die Programme des ESP32 verwalten.

Zunächst muss man ampy mit pip installieren:

sudo pip install adafruit-ampy

Mit folgendem Befehl kann sich dann die auf dem ESP32 gespeicherten Dateien auflisten lassen.

ampy --port /dev/ttyUSB0 ls

Wir erstellen nun eine Datei blink.py, die die interne blaue LED des ESP32 zum Blinken bringt:

import time
from machine import Pin
interne_led = Pin(2, Pin.OUT)
while True:
    interne_led.on()
    time.sleep_ms(500) 
    interne_led.off()
    time.sleep_ms(500)

Folgender Befehl führt diese Datei auf dem ESP32 aus:

ampy --port /dev/ttyUSB0 run blink.py

Folgender Befehl überträgt diese Datei auf den ESP32:

ampy --port /dev/ttyUSB0 put blink.py

Auf diesem Wege kann man auch die Datei main.py auf dem Computer mit einem beliebigen Editor erstellen und anschließend mit ampy auf den ESP32 übertragen.

Weitere Informationen zu ampy findet man hier: https://github.com/scientifichackers/ampy

MicroPython mit VSCode (Pymakr)

Das Addon Pymakr fügt dem Editor VSCode die Funktionalitäten von ampy sowie den interaktiven MicroPython-Prompt REPL hinzu. Man kann also aus VSCode heraus unter anderem:

  • MicroPython-Code interaktiv auf dem ESP32 ausführen
  • MicroPython-Dateien auf dem ESP32 ausführen
  • MicroPython-Dateien hochladen
  • ein Projektverzeichnis hochladen bzw. herunterladen

Man kann also den vertrauten Editor zur Erstellung der Dateien nutzen und spart sich den ständigen Wechsel vom Editor in die Kommandozeile.

Nach Installation von pymakr innerhalb von VSCode, erzeugt man am besten ein Projektverzeichnis, in dem man die MicroPython-Dateien erstellt, die auf den ESP32 übertragen werden sollen. In diesem Verzeichnis muss man unter Pymakr > Projekt settings folgende Einstellungen vornehmen:

"address": "/dev/ttyUSB0",
"auto_connect": false,

Anschließend kann man folgende Pymakr-Befehle ausführen:

  • Pymakr - Connect: Verbinden mit dem Esp32
  • Pymakr - Run current file: aktuelles PythonFile ausführen
  • Pymakr - Upload project: gesamtes Projektverzeichnis hochladen

MicroPython mit Thonny

Auch die Python-IDE Thonny bietet eine MicroPython-Integration. Unter Tools - Options kann man den Interpreter auswählen, den Thonny verwenden soll. Wählt man MicroPython (ESP32) kann man die USB-Schnittstelle auswählen, an der man den ESP32 ansgeschlossen hat, oder diese automatisch erkennen lassen.

Zudem kann man dort unter “Firmware” ein Dialogfenster öffnen, aus dem man MicroPython auf dem Gerät installieren oder updaten kann (statt wie oben beschrieben mit esptool.py)

MicroPython API

Was kann man nun alles mit MicroPython machen?

Einen guten Überblick bietet die Quick reference for the ESP32. Einige Beispiele finden sich auch in diesem Tutorial.

Einige Beispiele werde ich in späteren Posts beschreiben.

Ursprungszustand wieder herstellen

Zunächst muss man mit dem esptool den Flashspeicher löschen

python3 esptool.py --port /dev/ttyUSB0 erase_flash

Dann lädt man die aktuelle Firmware (für ESP32-WROOM-32 Series) von https://docs.espressif.com/projects/esp-at/en/latest/esp32/AT_Binary_Lists/ESP32_AT_binaries.html herunter und entpackt das zip-File. Danach kann man die Firmware aufspielen:

python esptool.py --chip esp32 --baud 460800 --port /dev/ttyUSB0 write_flash -z 0x1000 /home/verena/Downloads/ESP32-WROOM-32_AT_Bin_V2.4.0.0/ESP32-WROOM-32-V2.4.0.0/esp-at.bin
esptool.py v3.1

Lua / NodeMCU

Hier noch ein Link für die Nutzung von Lua und NodeMCU für den ESP32: https://nodemcu.readthedocs.io/en/release/getting-started