Erste Schritte mit Python für ESP8266 & ESP32 - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:16

Hintergrund

Der ESP8266 und sein jüngerer großer Bruder ESP32 sind kostengünstige Wi-Fi-Mikrochips mit vollem TCP/IP-Stack und Mikrocontroller-Fähigkeit. Der ESP8266-Chip wurde erstmals 2014 in der Maker-Community aufgefallen. Seitdem sind der niedrige Preis (<5 USD), seine Wi-Fi-Fähigkeit, ein eingebauter Flash-Speicher von 1 oder 4 MB und eine Vielzahl verfügbarer Entwicklungen Boards, hat den ESP-Chip zu einem der beliebtesten Mikrocontroller für WiFi- und IoT-DIY-Projekte gemacht.

MicroPython ist eine schlanke und effiziente Implementierung der immer beliebter werdenden Programmiersprache Python, die einen kleinen Teil der Python-Standardbibliothek enthält und für die Ausführung auf Mikrocontrollern optimiert ist.

Die Kombination dieser beiden ist eine sehr interessante Option für DIY-Projekte, sowohl für Anfänger als auch für Fortgeschrittene.

Das MiPy-ESP-Projekt

Im Jahr 2015 begannen meine ersten Projekte mit ESP8266 mit dem ESP-01-Chip mit Arudions zum Ausführen von Chip-AT-Befehlen über eine serielle Verbindung. Danach habe ich in den nächsten Jahren den Arduino-Kern für ESP8266 verwendet, um die Chips mit der Sprache C++ zu programmieren. Das funktioniert gut, aber für einen Python-Enthusiasten war meine Entdeckung der MicroPython-Implementierung von Python 3 eine großartige Nachricht.

Das MiPy-ESP-Projekt ist ein flexibles Framework, das MicroPython für Full-Stack-Python-IoT-Projekte auf den Mikrocontrollern der ESP-Familie anwendet.

Das Framework wurde vom LeGarage Technical Committee Software Developer Team (LG-TC-SWDT-01) entwickelt, um bereits etablierten C++-basierten Code für unsere Mikrocontroller-Anwendungen zu ersetzen.

Das Projekt bietet grundlegende Funktionen wie

• Verfahren zur Netzwerkverbindung
• Chip Access Point Webserver (für WLAN-Verbindung und Bereitstellung von Chip-Webseiten für Daten-I/O)
• MQTT-Funktionalitäten
• Protokollieren/Debuggen
• Ereignisplanung für Mikrocontroller
• Hardware-I/O-Routinen

Mit einem kompakten Hauptcode-Skript (main.py), alle mit globaler Konfiguration (config.py).

Dieser Mikrocontroller-Code läuft mit robuster Wartung von Chipverbindungen zu WiFi-Netzwerken und MQTT-Brokern. Vorhandene MicroPython-Module für unterschiedliche Hardware lassen sich einfach in das System integrieren.

Das MiPy-ESP-Framework ist zum Rückgrat all unserer Hobby-Elektronik-IoT-Projekte mit Mikrocontrollern der ESP-Familie geworden. Es wurde auf mehreren Boards der ESP-Familie getestet, wie den NodeMCU-, Wemos- und Lolin-Boards.

Das folgende Tutorial ist eine Anleitung für die ersten Schritte mit Mikrocontrollern der ESP-Familie und MicroPython unter Verwendung des MiPy-ESP-Frameworks.

Schritt 1: Das Wemos D1 Mini ESP8266 Board

Das MiPy-ESP-Framework funktioniert mit den meisten ESP8266-basierten Mikrocontrollern.

Das Wemos D1 Mini-Entwicklungsboard basiert auf dem ESP-8266EX-Chip. Auf einer Grundfläche von 2,5 x 3,5 cm verfügt es über 4 MB Flash-Speicher, 11 digitale Ein-/Ausgangspins, alle Pins unterstützen Interrupt, PWM, I2C, SPI, seriell und 1 analoger Eingang mit 3,3 V maximalem Eingang, kann mit 5 V betrieben werden, hat Micro-USB-Anschluss und ist Breadboard-kompatibel. Der niedrige Preis und die geringe Größe haben es zu meinem Lieblings-ESP-Board gemacht.

Darüber hinaus bietet die D1 mini pro-Version des Boards die Möglichkeit, eine externe Antenne anzuschließen, wodurch die Verbindungsreichweite deutlich erhöht wird (+100 m Reichweite). Darüber hinaus wird das Board mit einer Vielzahl von Out-of-the-Box-Erweiterungsboards mit ähnlich kompakter Größe geliefert.

Schritt 2: Vorbereitung für MicroPython auf dem ESP-Chip

In diesem ersten Schritt werden Sie

• Verbinden Sie das ESP-Board über USB mit Ihrem Computer
• Installieren Sie die Esptool-Software zum Flashen des Chips
• Chipspeicher löschen
• Flashen Sie den Chip mit der MicroPython-Firmware
• Installieren Sie Rshell, um die Befehlszeileninteraktion mit Ihrem Chip zu aktivieren
• Installieren Sie mpy-cross (zum Kompilieren von.py-Dateien in Binärdateien)

Das Anschließen des Boards an Ihren Computer über USBBoards mit integriertem USB-seriellem Anschluss machen den UART für Ihren PC verfügbar und sind die einfachste Möglichkeit für den Einstieg. Bei Boards ohne USB-Anschluss kann ein FTDI-Modul mit USB zu Seriell verwendet werden, um die GPIO-Pins zum Flashen mit der Außenwelt zu verbinden, dies wird jedoch in diesem Tutorial nicht behandelt.

Für MicroPython, das den MiPy-ESP-Code verwendet, beträgt die Mindestanforderung für die Chip-Flash-Größe 1 MB. Es gibt auch einen speziellen Build für Boards mit 512kB, dieser unterstützt aber kein Dateisystem, auf das MiPy-ESP angewiesen ist.

Bei Verwendung eines USB-Kabels wird das Board von Ihrem Computer mit Strom versorgt, während es angeschlossen ist. Dies ermöglicht auch das Programmieren und Debuggen über die serielle Verbindung. Wenn der Projektcode hochgeladen und Ihr Projekt bereitgestellt wird, wird die externe Stromversorgung über die Stromversorgungspins des Boards angelegt.

Esptool installierenInformationen zur Esptool-Software finden Sie im Esptool GitHub-Repository. Wenn Sie Windows/Linux/OSX (MAC) verwenden möchten, deckt der obige Link auch dies ab. Das Python-Paket kann installiert werden von

pip installieren esptool

Für Linux-Benutzer werden Pakete für Esptool für Debian und Ubuntu gepflegt und können auch mit installiert werden

sudo apt installieren esptool

Löschen des ESP-Flash-SpeichersMit Esptool löschen Sie dann den ESP-Flash-Speicher mit dem Befehl

esptool.py --port /dev/ttyUSB0 era_flash

Herunterladen der MicroPyton-FirmwareDie MicroPython-Firmware befindet sich in einer.bin-Datei, die von der MicroPython-Website heruntergeladen werden kann.

Der aktuelle Projekt-Master-Zweig des Repos wurde getestet und ist mit Micropython v.1.12 betriebsbereit. Um den Erfolg mit dem MiPY-ESP-Framework sicherzustellen, laden Sie die Datei 'esp8266-20191220-v1.12.bin' von diesem Link herunter und schreiben Sie die Firmware mit dem Befehl auf den Chip:

esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect 0 esp8266-20191220-v1.12.bin

Installieren von RshellDas Rshell-Paket ermöglicht die Befehlszeileninteraktion mit Ihrer auf dem Chip installierten MicroPython-Umgebung. Es ist in diesem Link zu finden. Rshell ist eine einfache Shell, die auf dem Host läuft und MicroPythons raw-REPL verwendet, um Python-Schnipsel an das Pyboard zu senden, um Dateisysteminformationen zu erhalten und Dateien in und aus MicroPythons Dateisystem zu kopieren. REPL steht für Read Evaluate Print Loop und ist der Name der interaktiven MicroPython-Eingabeaufforderung, auf die Sie auf dem ESP8266 zugreifen können. Die Verwendung von REPL ist bei weitem der einfachste Weg, um Ihren Code zu testen und Befehle auszuführen. Installieren Sie Rshell mit dem Befehl:

sudo pip install rshell

Installieren des MPy-Cross-Compilers MicroPython kann mit ASCII-.py-Dateien angewendet werden, die in das Chip-Dateisystem hochgeladen wurden. MicroPython definiert auch das Konzept von.mpy-Dateien, einem binären Container-Dateiformat, das vorkompilierten Code enthält und wie ein normales.py-Modul importiert werden kann. Durch das Kompilieren von.py-Dateien in.mpy steht mehr RAM-Speicher für Ihren laufenden Code zur Verfügung - und dies wird benötigt, um ein funktionierendes Kernmodul des MiPy-ESP-Frameworks zu haben.

Für die Bereitstellung von MiPy-ESP-Code kompiliert ein mpy-cross-MicroPython-Cross-Compiler die.py-Skripte vor dem Chip-Upload in.mpy. Installieren Sie das mpy-cross-Paket gemäß den Anweisungen in diesem Link. Alternativ kann der Befehl mpy-cross mit dem Python-Befehl pip installiert oder über den Ordnerpfad mpy-cross ausgeführt werden, wenn Sie das MicroPython-Repository von GitHub hier klonen.

Sie haben jetzt MicroPython und alle erforderlichen Tools installiert, um mit dem Erstellen Ihres ersten MiPy-ESP-Projekts zu beginnen

Schritt 3: Erste Schritte mit MiPy-ESP

In diesem Schritt wirst du

Laden Sie das MyPy-ESP-Framework herunter

Herunterladen des MiPy-ESP-Frameworks Das MiPy-ESP-Projekt finden Sie auf GitHub in diesem Code-Repository. Von GitHub können Sie die Repository-Dateistruktur herunterladen oder auf Ihren Computer klonen, indem Sie

git-Klon

Wenn das Code-Repository auf Ihrem Computer installiert ist, verfügen Sie jetzt über alle Codemodule, die Sie zum Erstellen eines einsatzbereiten ESP IoT-Projekts benötigen. Weitere Details zur Toolbox im nächsten Schritt.

Schritt 4: Die MiPy-ESP-Framework-Architektur

In diesem Schritt wirst du

Erfahren Sie mehr über den MiPy-ESP-Code-Workflow

MiPy-ESP-Codearchitektur

Alle Python-Framework-Module befinden sich im Ordner /src des MiPY-ESP-Code-Repository. Der Ordner src/core enthält die Kernmodule, die in jedes Projekt eingehen. Der Ordner src/drivers enthält eine Auswahl an Modulen für verschiedene Hardware, die an Ihren Chip angeschlossen werden können. Der Ordner src/utilities enthält optionale Dienstprogrammmodule, die Sie in Ihr Projekt aufnehmen können.

Die Dateien main.py und config.py befinden sich im Ordner src/. Dies sind die wichtigsten Dateien, die Sie zum Erstellen Ihres Projekts bearbeiten müssen:

config.py:

Diese Datei ist die globale Konfigurationsdatei für Ihr Projekt. Es hat verschiedene Einstellungen, alle mit beschreibenden Kommentaren in der Datei.

main.py:

Dies ist das Hauptskript für die Codeschleife des Mikrocontrollers. Es enthält den anwendungsspezifischen Code im Framework. Beim Booten des Chips wird main.py ausgeführt und importiert alle projektabhängigen Module mit den angegebenen Eingaben aus der Datei config.py. Das obige Flussdiagramm zeigt das Layout des main.py-Skripts.

Die obige Abbildung beschreibt den Workflow von main.py:

1. Beim Booten versucht der Code, den Chip mit dem Wi-Fi-Netzwerk zu verbinden. Zuvor angewendete Netzwerke und ihre Passwörter (auf dem Chip verschlüsselt) werden im Flash-Speicher gespeichert. Netzwerk-SSIDs und ihre Passwörter können in der Datei wifi.json im Format {" bereitgestellt werden. SSID1":"Passwort", "SSID":"Passwort2"}. Die angegebenen Netzwerke in dieser Datei werden gespeichert, Passwörter werden verschlüsselt und die Datei wird beim Booten gelöscht.
2. Wenn keine bereits bekannten Netzwerke gefunden werden, richtet der Code einen Access Point (AP)-Webserver ein. Die SSID und das Passwort des Chip-AP-Servers werden in der Datei config.py festgelegt. Durch die Anmeldung an der Chip-SSID wird eine Webseite zur Anmeldung des Chips am WLAN unter 192.168.4.1 bereitgestellt. Erkannte Netzwerke werden in einem Menü angezeigt, oder die SSID kann manuell (versteckte Netzwerke) zusammen mit WLAN-Passwort eingegeben werden. Nach erfolgreicher Verbindung des Chips mit Wi-Fi wird der AP-Server heruntergefahren und der main.py-Code fährt mit den nächsten Schritten fort.

3. Im Setup-Abschnitt von main.py,

   • Funktionen für Jobs und Callbacks (usw. MQTT Callbacks) und regelmäßige Events sind definiert.
   • Es werden verschiedene zeitgesteuerte Jobs für laufende Funktionen eingestellt.
   • MQTT-Broker-Client ist eingerichtet

4. Der Code geht dann in die Hauptschleife des Mikrocontrollers,

   • ständige Überprüfung der Netzwerk- und MQTT-Broker-Verbindungen,
   • MQTT-Abonnements,
   • Hardware-E/A
   • und geplante Jobs.
   • Bei Verlust der Netzwerk- oder MQTT-Broker-Verbindung versucht der Code eine Wiederherstellung.

Schritt 5: Vorbereiten Ihres Projektcodes

In diesem Schritt wirst du

• Erfahren Sie mehr über die Dateistruktur des MiPy-ESP-Repositorys
• Bereiten Sie Ihren Projektcode für den Chip-Upload vor

Repository-OrdnerstrukturDie obige Abbildung beschreibt die Repository-Ordnerstruktur und listet die aktuellen Module des Frameworks auf. Ihr Projekt befindet sich im Ordner src/. Core-MiPy-ESP-Framework-Module befinden sich in src/core, optionale Utility-Module in src/utilities und Hardware-Module in src/drivers.

Die meisten verfügbaren MicroPython-Hardwarebibliotheken können ohne Änderungen in den Treiber/Ordner verschoben werden. Alle vorhandenen Treiber werden mit dem MiPy-ESP-Framework getestet. In Bezug auf Module im Ordner Utilities/ werden weitere hinzugefügt, sobald sie zum Leben erweckt werden.

Bereitstellung von ProjektcodeIhr projektspezifischer Code sollte im Ordner src/ abgelegt werden. Dort befinden sich bereits die Dateien main.py und config.py, die Sie bearbeiten können. Kopieren Sie auch die gewünschten Projekt-Utilities von src/utilities und src/drivers nach src/.

Falls Sie dem Chip bekannte WLAN-Netzwerke und Passwörter bereitstellen möchten, fügen Sie die Datei wifi.json zu src/ hinzu.

Kompilieren und zum Hochladen vorbereiten Ein bereitgestelltes Makefile kann zum Vorbereiten von Dateien für die Übertragung auf den Chip verwendet werden, indem.py-Dateien in /src kompiliert, die Kernmodule kompiliert und die kompilierten Dateien mit dem Befehl in einen neuen Ordner namens build/ übertragen werden

machen bauen

Die Dateien im Build sind bereit zum Hochladen in das Chip-Dateisystem. Standardmäßig werden main.py und config.py nicht in Binärdateien kompiliert, um für die Überprüfung der bereitgestellten Chips einfach darauf zugreifen zu können. Der Befehl:

sauber machen

Löscht den build/-Ordner und seinen Inhalt.

Schritt 6: Kompilieren und Hochladen des Codes auf den Mikrocontroller

In diesem Abschnitt wirst du

• Laden Sie die vorbereiteten Dateien in build/ aus dem letzten Abschnitt hoch
• Starten und überwachen Sie den laufenden Code

Hochladen von Builds/Dateien mit Rshell

Laden Sie alle Dateien im Verzeichnis /build mit Rshell auf den ESP-Chip hoch. Wenn der Mikrocontroller an USB angeschlossen ist, starten Sie Rshell aus dem build/-Ordner mit dem Befehl

rshell -p /dev/ttyUSB0

Überprüfen Sie dann die Chipdateien (falls vorhanden) von

ls /pyboard

Alle Dateien auf dem Chip können gelöscht werden durch

rm /pyboard/*.*

Kopieren Sie alle Projektdateien in build/ auf den Chip:

cp *.* /pyboard

Starten Sie dann das interaktive Python-Terminal mit dem Befehl

erwidern

Sie können jetzt Python-Befehle aufrufen oder Module importieren und die serielle Ausgabe des Chips vom MiPy-ESP-Loggermodul überwachen.

Starten Sie den Chip neu, indem Sie die Reset-Taste drücken oder von der Befehlszeile aus mit

Hauptimport

oder

Importmaschine

und dann

maschine.reset()

Abhängig von Ihren Logging-/Debug-Einstellungen in der Projektkonfigurationsdatei zeigt der Repl nun Debugging-Meldungen vom ESP-Chip über die serielle Verbindung an.

Dies sollte Ihnen hoffentlich den Einstieg erleichtern.