Inhaltsverzeichnis

ESP32 Log / Debugging

Die hier gemachten Angaben beziehen sich auf das Arduino-Framework in der Version 3.3.5.

Das Arduino-Framework des ESP32 bietet eine Reihe von Debugging-Möglichkeiten. U.a. ein komplexes Logging-System. Die Verwendung dieses Systems gegenüber der einfacher Ausgabe per Serial.print hat den Vorteil, dass die Logging-Anweisungen nach der Testphase nicht wieder entfernt werden müssen. Das Logging-System kann durch Kompilierzeit-Parameter gesteuert oder ausgeschaltet werden. Ein ausführliche Dokumentation findet man im Espress-IDF: Logging library.

Logging aktivieren

Der Logging-Level kann nur über die Einstellungen in der IDE bestimmt werden. Die Funktion esp_log_level_set("*", ESP_LOG_ERROR); funktioniert leider im Arduino-Framework nicht. In der Arduino-IDE findet man im Reiter Werkzeuge (Tools) die Rubrik Core Debug Level. In der Visual Micro Extension für das Visual Studio ist dies eine der Optionen:


Logging Level in der Arduino-IDE		Logging Level in VM

Ins Log schreiben

Damit die Logging-Funktionen zur Verfügung stehen, muss die Datei esp-log.h eingebunden werden:

#include <esp_log.h>

Es gibt für jeden Level eine eigene Ausgabefunktion (als Makro). Generell gilt: Meldungen mit niedrigerem Level werden ebenfalls ausgegeben.

ESP_LOGV (verbose): Höchste Stufe., Sehr detaillierte und häufige Debugging-Meldungen, die oft interne Zustände enthalten und die Ausgabe überladen können.
ESP_LOGD (debug): Detaillierte Diagnosemeldungen zur Unterstützung der Fehlersuche (z. B. Variablenwerte, Zeigeradressen).
ESP_LOGI (info): Allgemeine Informationsmeldungen, die den normalen Betrieb des Systems beschreiben.
ESP_LOGW (warning): Probleme, die möglicherweise zu Schwierigkeiten führen könnten, aber bereits behoben oder gemildert wurden.
ESP_LOGE (error): Kritische Fehler, die darauf hinweisen, dass die Software ohne Eingreifen nicht wiederhergestellt werden kann.

Das Prototyp-Äquivalent ist

ESP_LOGD(const char* tag, const char* format, ...);

Dies ist analog zur Funktion printf.

Die Ausgabe erfolgt über Serial. Hier ein Beispiel für den Aufruf von ESP_LOGD in einer Memberfunktion:

#pragma once

#include <Arduino.h>
#include <esp_log.h>

const auto TAG = "FooTag";

class Foo{
 public:
	 int bar(int x) {
		 ESP_LOGD(TAG, "Argument x is %i", x);
		 return x;
	}
};

Output von ESP_LOGD

Die Angaben sind:

[ 1468]: Timestamp in ms seit Prgrammstart
[D]: Logging Level
[Foo.h:11]: Datei und Zeile des Aufrufs von ESP_LOGD
bar(): Name der Funktion in der ESP_LOGD aufgerufen wurde
[FooTag]: Das in ESP_LOGD angegebene Argument für TAG.
Der Rest ist das Argument für format und die variablen Parameter.

Ausgabe von Systeminformationen

Wenn der Logging-Level Debug oder Verbose ist und in der Funktion setup nach der Initialisierung der seriellen die Anweisung Serial.setDebugOutput(true); gegeben wird, werden ausführlich Informationen über das aktuelle System ausgegeben. Leider nur unvollständig direkt nach dem Programmieren, nach einem manuellen Reset dann komplett. Besonders interessant ist die Pin-Belegung im Anschnitt After Setup Start.

=========== Before Setup Start ===========
Chip Info:
------------------------------------------
Model : ESP32-C6
Package : 0
Revision : 0.01
Cores : 1
CPU Frequency : 40 MHz
XTAL Frequency : 40 MHz
Features Bitfield : 0x00000052
Embedded Flash : No
Embedded PSRAM : No
2.4GHz WiFi : Yes
Classic BT : No
BT Low Energy : Yes
IEEE 802.15.4 : Yes
------------------------------------------
INTERNAL Memory Info:
------------------------------------------
Total Size : 475580 B ( 464.4 KB)
Free Bytes : 440264 B ( 429.9 KB)
Allocated Bytes : 28988 B ( 28.3 KB)
Minimum Free Bytes: 440240 B ( 429.9 KB)
Largest Free Block: 417780 B ( 408.0 KB)
------------------------------------------
Flash Info:
------------------------------------------
Chip Size : 4194304 B (4 MB)
Block Size : 65536 B ( 64.0 KB)
Sector Size : 4096 B ( 4.0 KB)
Page Size : 256 B ( 0.2 KB)
Bus Speed : 40 MHz
Flash Frequency : 40 MHz (source: 40 MHz, divider: 1)
Bus Mode : QIO
------------------------------------------
Partitions Info:
------------------------------------------
nvs : addr: 0x00009000, size: 20.0 KB, type: DATA, subtype: NVS
otadata : addr: 0x0000E000, size: 8.0 KB, type: DATA, subtype: OTA
app0 : addr: 0x00010000, size: 1280.0 KB, type: APP, subtype: OTA_0
app1 : addr: 0x00150000, size: 1280.0 KB, type: APP, subtype: OTA_1
spiffs : addr: 0x00290000, size: 1408.0 KB, type: DATA, subtype: SPIFFS
coredump : addr: 0x003F0000, size: 64.0 KB, type: DATA, subtype: COREDUMP
------------------------------------------
Software Info:
------------------------------------------
Compile Date/Time : Jan 3 2026 17:04:08
Compile Host OS : windows
ESP-IDF Version : v5.5.1-710-g8410210c9a
Arduino Version : 3.3.4
------------------------------------------
Board Info:
------------------------------------------
Arduino Board : ESP32C6_DEV
Arduino Variant : esp32c6
Arduino FQBN : esp32:esp32:esp32c6:UploadSpeed=921600,CDCOnBoot=default,CPUFreq=40,FlashFreq=80,FlashMode=qio,FlashSize=4M,PartitionScheme=default,DebugLevel=none,EraseFlash=none,JTAGAdapter=de∞
============ Before Setup End ============

-- Ausgaben von Serial.print in setup --

=========== After Setup Start ============
INTERNAL Memory Info:
------------------------------------------
Total Size : 475580 B ( 464.4 KB)
Free Bytes : 442852 B ( 432.5 KB)
Allocated Bytes : 26144 B ( 25.5 KB)
Minimum Free Bytes: 439692 B ( 429.4 KB)
Largest Free Block: 417780 B ( 408.0 KB)
------------------------------------------
GPIO Info:
------------------------------------------
GPIO : BUS_TYPE[bus/unit][chan]
--------------------------------------
16 : UART_TX[0]
17 : UART_RX[0]
19 : SPI_MASTER_MOSI[0]
20 : SPI_MASTER_MISO[0]
21 : SPI_MASTER_SCK[0]
============ After Setup End =============

Makros zum Debugging

In den neueren C++-Versionen gibt es eine Reihe von vordefinierten Makros, über die Angaben zum Programm oder zur Kompilierung abgerufen erden können. In der GCC-Dokumentation gibt es den Abschnitt 3.7.1 Standard Predefined Macros, in dem diese Makros aufgeführt sind, wie z.B. __FILE__. Es gibt weitere GNU-spezifische Makros im Abschnitt 3.7.2 Common Predefined Macros. Im Kapitel 6 Extensions to the C Language Family. findet man weitere GCC-Spezialitäten, u.a. im Kapitel 6.51 Function Names as Strings die Makros __FUNCTION__ und __PRETTY_FUNCTION__. __FUNCTION__ ist mittlerweile als __func__ in den C++-Standard aufgenommen worden und sollte stattdessen verwendet werden.

Verwendet man diese Makros in in der Funktion bar der Klasse Foo (s.o.) erhält man diese Ausgaben:

__func__: bar
__PRETTY_FUNCTION__: int Foo::bar(int)