ESP32-Boot-Optimierung: Menuconfig mit PlatformIO

Beschleunige die Boot-Zeit mit Menuconfig (ESP32)

Wenn du das hier liest, bist du vielleicht schon weit gekommen … und ich bin noch auf dem Weg … daher ist das hier nur mein aktueller Stand. Korrigiere mich gerne und hilf mir, das Ganze weiter auszuarbeiten – und sei dir bewusst, dass nicht alles unten wirklich korrekt ist … aber zumindest … habe ich es so zum Laufen gebracht … 🙂

Warum dauert das Booten eine Sekunde?

Die Bootzeit wird für jedes eingebettete Gerät kritisch, wenn es aus dem Tiefschlaf geweckt werden und sofort reagieren muss. Ich brauchte eine kurze Bootzeit für das Goodwatch-Projekt, um sicherzustellen, dass die Uhr superschnell aufwacht, wenn ich möchte, dass sie die Zeit in Sekunden bei einer „Zeigerbewegung“ anzeigt (schau dir das Video hier an).

Auf dem Wemos D32 Pro dauerte der Bootvorgang ca. 1 Sekunde – das ist für viele Aufgaben zu lang.

Während dieser 1 Sekunde führt der Prozessor z. B. einen Selbsttest für den RAM (PSRAM) und einige andere Dinge durch.

Also – ich habe mir überlegt, wie ich das überspringen kann.

Wenn du dir schon mal das BIOS deines PCs angesehen hast, kennst du sicher einige Optionen dort; etwas Ähnliches gibt es auch für den ESP32: Menuconfig ist ein von Espressif bereitgestelltes Konfigurationsprogramm, um die Einstellungen für die ESP32-Prozessorfamilie fein abzustimmen – es sieht ein bisschen wie BIOS-Einstellungen aus:

Aber mit Menuconfig kannst du viel mehr machen, also – was ich für Goodwatch gemacht habe

Boot-Vorgang beschleunigen, wie beschrieben unter: https://esp32.com/viewtopic.php?t=9448
Unterstützung für externen RAM: Y
Speichertest bei SPI-Initialisierung ausführen: N
Schnelleres SPI: „Serial Flasher Config“ QIO
Doppelte Flash-Lesegeschwindigkeit: Setze CONFIG_ESPTOOLPY_FLASHFREQ auf 80 MHz über Serial

Das Ergebnis: Die Bootzeit hat sich drastisch verkürzt – statt Sekunden wird jetzt fast sofort angezeigt 🙂

Aber hier kommt mein Problem – ich habe es nicht geschafft, menuconfig zu installieren und mit meinem Arduino-Build-System und den Bibliotheken zum Laufen zu bringen….

Ich verwende ein E-Ink-Display und ziemlich viele Sensoren – daher ist es toll, Zugriff auf alle Arduino-Bibliotheken zu haben – allein schon ESP-Audio von Schreibfaul, das den ESP in ein Radio oder einen Sprachlautsprecher verwandelt, ist den Einsatz von Arduino wert, ebenso wie die großartige E-Ink-Bibliothek von ZinggJM.

Das Build-System und „Frameworks“ verstehen

Das Einrichten dieses Build-Systems ist eine komplizierte Aufgabe. Um die Arduino-Projekte zu erstellen, verwende ich Platformio.io – eine Build- und Entwicklungsplattform für eingebettete Geräte, die Arduino, aber auch viele andere Frameworks unterstützt.

Es hilft, diese Begriffe zu verstehen:

Framework: Arduino oder espidf: Welche Art von Bibliotheken wird für die Kommunikation mit der Hardware verwendet? Das ist die grundlegendste Entscheidung.
Plattform: Das ist der Kern von Platformio – eine Reihe von Skripten und Dateien, die die ganze Arbeit übernehmen und das Build-System für dich einrichten. Die Plattform bestimmt, welche Version des
Komponenten: Code-Blöcke, die dem Framework hinzugefügt werden können, um die Funktionalität zu erweitern (Bibliotheken). Arduino kann als Komponente verwendet werden. Arduino-spezifische Komponenten (Bibliotheken, die ESP-Aufrufe in Arduino einbinden) werden hier von ESP-IDF bereitgestellt und können hier hinzugefügt werden

Die Standardkonfiguration von Platformio ist in der Datei platformio.ini gespeichert; für ein einfaches „Arduino“-Projekt ist sie wie folgt eingerichtet:

platform = espressif32
board = lolin_d32_pro
framework = arduino

Das arduinoespressif32-Framework übernimmt die ganze Arbeit – es ermöglicht den geräteunabhängigen Arduino-Bibliotheken den Zugriff auf die gerätespezifischen ESP-IDF- und ESP32-Hardwarefunktionen.

Wenn du den Build mit Platformio ausführst, siehst du Folgendes:

PLATFORM: Espressif 32 (5.1.1+sha.4901957) > WEMOS LOLIN D32 PRO
HARDWARE: ESP32 240MHz, 320KB RAM, 16MB Flash
DEBUG: Current (cmsis-dap) External (cmsis-dap, esp-bridge, esp-prog, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa)
PACKAGES: -framework-arduinoespressif32 @ 3.20004.220825 (2.0.4)

Es verwendet eine Version 2.04 von arduinoespressif32 . Zur Erleichterung für alle Entwickler handelt es sich hierbei um eine „vorkompilierte/gebündelte“ Version, für die nicht die gesamte ESP32-Build-Kette installiert sein muss.

Das erklärt, warum menuconfig nicht funktioniert – es ändert die Einstellungen im Framework. Das ist super, um mit der Entwicklung zu starten (keine Probleme mit der Versionskompatibilität) – aber es gibt keine Möglichkeit, irgendwelche Einstellungen zu ändern 🙁

Raus aus der Höhle – ESP Framework mit Komponenten nutzen

Die einzige Möglichkeit, menuconfig zum Laufen zu bringen und vollen Zugriff auf alle ESP32-Funktionen zu erhalten, ist der Wechsel zum Espressif IoT Development Framework. Dieses stammt direkt vom Hersteller und ermöglicht die Konfiguration der Build-Chain mit menuconfig.

Um das Beste aus beiden Welten zu behalten, müssen wir weiterhin die Arduino-Bibliotheken verwenden, indem wir sie als Komponenten hinzufügen. Wie das funktioniert, wird hier beschrieben. Kurz gesagt: Das Projekt wird nicht mit dem Arduino-Build-System und -Ansatz eingerichtet, sondern als vollständige Espressif-Kette.

Ein Ordner „components“ enthält die Bibliotheken, die Arduino in die „Sprache“ des ESP32 übersetzen. Alle Arduino-Bibliotheken funktionieren weiterhin und rufen die ESP32-Funktionen über den Komponenten-Wrapper auf – der wiederum die Kernfunktionen des ESP aufruft.

Die Herausforderung – das Abgleichspiel & die Magie von Platformio

Aber jetzt – am Ende muss alles zusammenpassen: Arduino-Version -> Komponente -> Espressif-Framework… hier beginnt der Albtraum…

Espressif liefert bereits wichtige Informationen und stellt die Komponenten auf dieser Seite bereit.

Die Komponenten können hier installiert werden: https://github.com/espressif/arduino-esp32.git

Dort steht auch, dass sie mit ESP-IDF v4.4 zusammenarbeiten.

Jetzt müssen wir das passende Framework von espidf finden, das ESP-IDF v4.4 unterstützt

Erste Option – Probier einfach das Standard-Framework aus

Also – lass uns die platformio.ini mit dem espidf-Framework aktualisieren. Sollte funktionieren, wir haben die Komponenten bereit

framework = espidf
platform = espressif32
board = lolin_d32_pro

Ergebnis:

PLATFORM: Espressif 32 (5.1.1+sha.4901957) > WEMOS LOLIN D32 PRO
HARDWARE: ESP32 240MHz, 320KB RAM, 16MB Flash
DEBUG: Current (cmsis-dap) External .....
PACKAGES:  - framework-espidf @ 3.40401.0 (4.4.1)

Hoppla… das hat nicht funktioniert – es wird für ESP-IDF 4.4.1 kompiliert, und das passt nicht zu unseren Komponenten. Am Ende des Builds erhalten wir eine Fehlermeldung: „undefined reference to `uart_get_tx_buffer_free_size'“

Zweite Option – Die richtige Plattform für IDF v4.4 auswählen

framework = espidf
platform = https://github.com/platformio/platform-espressif32/archive/refs/tags/v4.4.0.zip
board = lolin_d32_pro

Das sieht besser aus, wir sind jetzt bei ESP-IDF 4.4.0

PLATFORM: Espressif 32 (4.4.0) > WEMOS LOLIN D32 PRO
HARDWARE: ESP32 240MHz, 320KB RAM, 16MB Flash
PACKAGES:  - framework-espidf @ 3.40302.0 (4.3.2)

Argh… aber wieder eine Fehlermeldung:

Arduino-esp32 kann mit ESP-IDF-Versionen zwischen 4.4.0 und 4.4.99 verwendet werden,
aber es wird eine ältere Version erkannt: 4.3.2

Das ist seltsam, auch die Plattformversion deutet auf 4.4 hin – es scheint, dass das ausgewählte Framework immer noch auf dem Stand von 4.3.2 ist – das passt nicht zu unseren Komponenten

Dritte Option – Verwendung der Tasmota-Plattform

Ich weiß nicht mehr, wo ich diesen Tipp gefunden habe – aber er hat mir das Leben gerettet. Tasmota stellt freundlicherweise eine weitere Plattformdatei für Platformio zur Verfügung, die funktioniert. Vielen Dank an Jason2866 (der dies auf Github pflegt) für all seine Arbeit – er macht das wirklich möglich!!!!!

framework = espidf
platform =https://github.com/tasmota/platform-espressif32
board = lolin_d32_pro

Das Ergebnis sieht besser aus:

PLATFORM: Espressif 32 (2.0.4) > WEMOS LOLIN D32 PRO
HARDWARE: ESP32 240MHz, 320KB RAM, 16MB Flash
PACKAGES:  - framework-espidf @ 3.40403.0 <strong>(4.4.3) </strong>

Die „2.0.4“ ist die Tasmota-Version der Plattform-Datei (nicht die ESP-IDF-Version). Aber wir sehen erfreulicherweise ein Framework mit der Auswahl 4.4.3. Hurra!!!!!!

Ehrlich gesagt verstehe ich die ganze Magie der Tasmota-Plattformkonfiguration nicht ganz… mal sehen, was wir haben

Tief tauchen… was unterscheidet die Tasmota- von der Platformio-Plattformdatei?

Jede Plattformdatei enthält eine JSON-Datei, die die für die Build-Kette zu verwendenden Elemente definiert.

Schauen wir uns diese Datei an:

"version": "2.0.4+1",
  "frameworks": {
    "arduino": {
      "package": "framework-arduinoespressif32",
      "script": "builder/frameworks/arduino.py"
    },
    "espidf": {
      "package": "framework-espidf",
      "script": "builder/frameworks/espidf.py",
      "description": "ESP-IDF is the official development framework for the ESP32 and ESP32-S Series SoCs.",
      "homepage": "https://docs.espressif.com/projects/esp-idf/en/latest/esp32/",
      "title": "Espressif IoT Development Framework"
    }
  },
  "packages": {
    "framework-arduinoespressif32": {
      "type": "framework",
      "optional": true,
      "owner": "tasmota",
      "version": "https://github.com/tasmota/arduino-esp32/releases/download/2.0.4.1/framework-arduinoespressif32.tar.gz"
    },
    "framework-espidf": {
      "type": "framework",
      "optional": true,
      "owner": "tasmota",
      "version": "https://github.com/tasmota/esp-idf/releases/download/v4.4.3/esp-idf-v4.4.3.zip"
    },

Was sehen wir hier?

Die „Version“ 2.0.4 scheint Tasmota-spezifisch zu sein und gibt nicht die ESP-IDF-Version an
Das Tasmota-Paket unterstützt zwei Frameworks: „Arduino“ und „espidf“ – wir suchen nach espidf
Der framework-espidf Framework verweist tatsächlich auf ein spezifisches Framework von Tasmota mit der Version 4.4.3 -> und das ist der Haken: Tasmota baut sein eigenes Framework.
Wenn wir uns das Framework von Tasmota hier ansehen: https://github.com/tasmota/esp-idf, sehen wir, dass es sich um einen Fork von espressif/esp-idf Version 4.4.3 handelt.
Wenn ich beide Forks vergleiche, sehe ich, dass sie gleich aussehen. Ich schätze also, dass die Unterschiede zwischen dem Tasmota-Paket und dem Platformio-Paket minimal sind, vielleicht nur die Versionseinstellungen in der JSON-Datei

Das reicht mir – jetzt habe ich eine einfache Konfiguration, die funktioniert 🙂

So geht’s – Tipps & Tricks

Dies ist kein Tutorial zur Einrichtung der kompletten Build-Umgebung. Um dorthin zu gelangen:

Richte ein normales Entwicklungsprojekt mit Platformio und folgender platformio.ini ein:
framework = espidfplatform =https://github.com/tasmota/platform-espressif32
board = lolin_d32_pro
Füge die passenden Komponenten von espidf zur Ordnerstruktur hinzu, wie hier beschrieben:https://espressif-docs.readthedocs-hosted.com/projects/arduino-esp32/en/latest/esp-idf_component.html
Ich verwende Platformio in CLION und erhalte nach dem Befehl „pio init“ eine nicht funktionierende CMake-Datei. Ich verwende die folgende „CMakeLists.txt“:
```
cmake_minimum_required(VERSION 3.16.0)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
list(APPEND EXTRA_COMPONENT_DIRS arduino)
project(GoodWatch_espif)
```
Führe „platformio build“ aus

Lange Geschichte … kurz gesagt … aber es funktioniert 🙂

Markiert:Boot Time ESP32 Firmware Menuconfig Optimization PlatformIO