ESP32 Hardware-Timer statt millis(): Präzise Intervalle, saubere ISR & jitterfreie Abtastung

Warum millis() irgendwann nicht mehr reicht

Der millis()-Ansatz ist der richtige Einstieg ins nicht-blockierende Programmieren und deckt 90 % aller Projekte ab. Sein Prinzip: Du fragst in jedem Schleifendurchlauf, ob genug Zeit vergangen ist. Das heißt aber auch – dein Timing ist nie besser als die Dauer eines Schleifendurchlaufs.

Solange loop() in 200 Mikrosekunden durch ist, merkst du davon nichts. Sobald aber eines dieser Dinge dazukommt, wird es unangenehm:

• Ein OLED-Update überträgt 1024 Byte über I2C – bei 400 kHz sind das rund 2,5 ms, in denen nichts anderes passiert.
• Ein WLAN-Request blockiert je nach Router zwischen 20 und 500 ms.
• Ein DHT22 braucht für eine Messung rund 25 ms, in denen der Bus mit Timing-kritischen Pulsen belegt ist.
• Der WiFi-Stack im Hintergrund unterbricht deinen Code auch dann, wenn du gar nichts anforderst.

Was im ESP32 tatsächlich passiert

Der klassische ESP32 (WROOM32) enthält vier 64-Bit-Timer, verteilt auf zwei Timer-Gruppen. Jeder besteht aus drei Bausteinen:

• Ein Basistakt, der bei den meisten Modulen vom APB-Bus mit 80 MHz kommt.
• Ein Prescaler (Vorteiler), der diesen Takt herunterteilt. Bei einem Prescaler von 80 tickt der Zähler mit 1 MHz – also exakt einmal pro Mikrosekunde. Das ist der Grund, warum 80 in fast jedem Beispiel steht.
• Ein Alarmwert: Erreicht der Zähler diese Zahl, löst er einen Interrupt aus und startet (bei aktiviertem Autoreload) wieder bei null.

Ein Timer mit Prescaler 80 und Alarmwert 1000 feuert also alle 1000 Mikrosekunden – exakt 1000-mal pro Sekunde, egal was dein Sketch gerade tut. Der Zähler läuft in Hardware, nicht in Software.

1Der API-Bruch: Core 2.x gegen Core 3.x

Hier scheitern die meisten Tutorials, die älter als ein Jahr sind. Mit dem Arduino-ESP32-Core 3.0 wurde die Timer-API grundlegend vereinfacht. Wenn du einen Beispielcode kopierst und es heißt „too few arguments to function timerBegin", dann hast du genau dieses Problem.

Die gute Nachricht: Du kannst beides in einem Sketch abfangen. Der Core definiert das Makro ESP_ARDUINO_VERSION_MAJOR, und damit lässt sich der richtige Zweig automatisch wählen:

#include <Arduino.h>

hw_timer_t *timer = nullptr;
volatile uint32_t ticks = 0;

void IRAM_ATTR onTimer() {
  ticks++;
}

// Legt einen Timer an, der mit der gewuenschten Frequenz feuert.
// Funktioniert mit Core 2.x und 3.x.
void timerSetupHz(uint32_t hz) {
#if ESP_ARDUINO_VERSION_MAJOR >= 3
  // Core 3.x: Basistakt 1 MHz, Alarm bei 1000000/hz Mikrosekunden
  timer = timerBegin(1000000);
  timerAttachInterrupt(timer, &onTimer);
  timerAlarm(timer, 1000000UL / hz, true, 0);
#else
  // Core 2.x: Timer 0, Prescaler 80 -> 1 Tick = 1 us
  timer = timerBegin(0, 80, true);
  timerAttachInterrupt(timer, &onTimer, true);
  timerAlarmWrite(timer, 1000000UL / hz, true);
  timerAlarmEnable(timer);
#endif
}

void setup() {
  Serial.begin(115200);
  delay(300);
  Serial.printf("Arduino-ESP32 Core %d.%d.%d\n",
                ESP_ARDUINO_VERSION_MAJOR,
                ESP_ARDUINO_VERSION_MINOR,
                ESP_ARDUINO_VERSION_PATCH);

  timerSetupHz(1000);   // 1000 Interrupts pro Sekunde
}

void loop() {
  static uint32_t letzte = 0;
  if (millis() - letzte >= 1000) {
    letzte = millis();

    noInterrupts();
    uint32_t t = ticks;
    ticks = 0;
    interrupts();

    Serial.printf("Ticks in der letzten Sekunde: %lu\n", t);
  }
}

Das brauchst du

2Die goldenen Regeln für die ISR

Eine Interrupt-Service-Routine ist kein normaler Funktionsaufruf. Sie unterbricht mitten im laufenden Programm – auch mitten in einer I2C-Übertragung, mitten in einem Serial.print() und mitten im WLAN-Stack. Was in einer ISR erlaubt ist, ist entsprechend eng begrenzt.

So sieht die saubere Variante mit Spinlock aus, wie sie in der ESP-IDF üblich ist:

portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;

volatile uint32_t impulse   = 0;
volatile uint64_t summeRoh  = 0;
volatile bool     neuesFenster = false;

void IRAM_ATTR onTimer() {
  portENTER_CRITICAL_ISR(&timerMux);
  impulse++;
  summeRoh += impulse;
  neuesFenster = true;
  portEXIT_CRITICAL_ISR(&timerMux);
}

void loop() {
  if (neuesFenster) {
    portENTER_CRITICAL(&timerMux);
    uint32_t i = impulse;
    uint64_t s = summeRoh;
    neuesFenster = false;
    portEXIT_CRITICAL(&timerMux);

    // Ab hier gefahrlos: lokale Kopien, kein Zugriff mehr auf volatile
    Serial.printf("Impulse %lu, Summe %llu\n", i, s);
  }
}

3Praxisbeispiel: 1000 Messwerte pro Sekunde, jitterfrei

Das ist die klassische Anwendung: Du willst ein analoges Signal in gleichmäßigen Abständen abtasten, um daraus einen Effektivwert, eine Frequenz oder eine FFT zu berechnen. Ungleichmäßige Abstände machen jede dieser Rechnungen kaputt.

Der Trick besteht aus zwei Teilen: Die ISR macht nur die Messung und legt sie in einen Ringpuffer. Die Auswertung passiert im Hauptprogramm.

#include <Arduino.h>

#define ADC_PIN     34
#define ABTASTRATE  1000        // Hz
#define PUFFER_N    256         // Zweierpotenz -> schneller Modulo

hw_timer_t *timer = nullptr;
portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;

volatile uint16_t puffer[PUFFER_N];
volatile uint16_t schreibIdx = 0;
volatile uint32_t verloren   = 0;
uint16_t leseIdx = 0;

void IRAM_ATTR abtastIsr() {
  // analogRead ist auf dem ESP32 IRAM-sicher und braucht ca. 10 us
  uint16_t wert = analogRead(ADC_PIN);

  portENTER_CRITICAL_ISR(&mux);
  uint16_t naechste = (schreibIdx + 1) & (PUFFER_N - 1);
  if (naechste == leseIdx) {
    verloren++;                 // Puffer voll - Hauptprogramm zu langsam
  } else {
    puffer[schreibIdx] = wert;
    schreibIdx = naechste;
  }
  portEXIT_CRITICAL_ISR(&mux);
}

bool naechsterWert(uint16_t &out) {
  bool da = false;
  portENTER_CRITICAL(&mux);
  if (leseIdx != schreibIdx) {
    out = puffer[leseIdx];
    leseIdx = (leseIdx + 1) & (PUFFER_N - 1);
    da = true;
  }
  portEXIT_CRITICAL(&mux);
  return da;
}

void setup() {
  Serial.begin(115200);
  analogReadResolution(12);
  analogSetPinAttenuation(ADC_PIN, ADC_11db);

#if ESP_ARDUINO_VERSION_MAJOR >= 3
  timer = timerBegin(1000000);
  timerAttachInterrupt(timer, &abtastIsr);
  timerAlarm(timer, 1000000UL / ABTASTRATE, true, 0);
#else
  timer = timerBegin(0, 80, true);
  timerAttachInterrupt(timer, &abtastIsr, true);
  timerAlarmWrite(timer, 1000000UL / ABTASTRATE, true);
  timerAlarmEnable(timer);
#endif
}

void loop() {
  static uint32_t summe = 0, n = 0;
  static uint32_t min = 4095, max = 0;
  static uint32_t letzteAusgabe = 0;

  uint16_t w;
  while (naechsterWert(w)) {
    summe += w;
    n++;
    if (w < min) min = w;
    if (w > max) max = w;
  }

  if (millis() - letzteAusgabe >= 1000) {
    letzteAusgabe = millis();

    if (n > 0) {
      float mittel = (float)summe / n;
      Serial.printf("n=%lu  Mittel=%.1f  Min=%lu  Max=%lu  SpitzeSpitze=%lu  verloren=%lu\n",
                    n, mittel, min, max, max - min, verloren);
    }
    summe = 0; n = 0; min = 4095; max = 0;
  }
}

4Praxisbeispiel: Frequenzzähler mit exaktem Zeitfenster

Beim Drehzahl- oder Frequenzmessen gibt es zwei Wege: Man misst die Zeit zwischen zwei Impulsen, oder man zählt die Impulse in einem exakt definierten Zeitfenster. Der zweite Weg ist bei hohen Frequenzen deutlich genauer – und er steht und fällt mit der Genauigkeit des Fensters. Genau dafür ist ein Hardware-Timer gemacht.

#include <Arduino.h>

#define IMPULS_PIN   27
#define FENSTER_MS   500          // Messfenster
#define IMPULSE_PRO_U 1           // Marken pro Umdrehung

hw_timer_t *fensterTimer = nullptr;
portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;

volatile uint32_t zaehler        = 0;
volatile uint32_t letzterStand   = 0;
volatile bool     fensterFertig  = false;
volatile uint32_t letzteFlankeUs = 0;

// Impuls-ISR mit Entprellung ueber Mindestabstand
void IRAM_ATTR impulsIsr() {
  uint32_t jetzt = micros();
  if (jetzt - letzteFlankeUs < 200) return;   // max. 5 kHz
  letzteFlankeUs = jetzt;
  zaehler++;
}

// Timer-ISR: schnappt den Zaehlerstand und meldet das Fenster
void IRAM_ATTR fensterIsr() {
  portENTER_CRITICAL_ISR(&mux);
  letzterStand  = zaehler;
  zaehler       = 0;
  fensterFertig = true;
  portEXIT_CRITICAL_ISR(&mux);
}

void setup() {
  Serial.begin(115200);
  pinMode(IMPULS_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(IMPULS_PIN), impulsIsr, FALLING);

#if ESP_ARDUINO_VERSION_MAJOR >= 3
  fensterTimer = timerBegin(1000000);
  timerAttachInterrupt(fensterTimer, &fensterIsr);
  timerAlarm(fensterTimer, (uint64_t)FENSTER_MS * 1000ULL, true, 0);
#else
  fensterTimer = timerBegin(1, 80, true);
  timerAttachInterrupt(fensterTimer, &fensterIsr, true);
  timerAlarmWrite(fensterTimer, (uint64_t)FENSTER_MS * 1000ULL, true);
  timerAlarmEnable(fensterTimer);
#endif
}

void loop() {
  if (!fensterFertig) return;

  portENTER_CRITICAL(&mux);
  uint32_t n = letzterStand;
  fensterFertig = false;
  portEXIT_CRITICAL(&mux);

  float hz  = n * (1000.0f / FENSTER_MS);
  float rpm = hz * 60.0f / IMPULSE_PRO_U;

  Serial.printf("%lu Impulse  ->  %.2f Hz  =  %.0f U/min\n", n, hz, rpm);
}

5Timer plus FreeRTOS-Task: die saubere Trennung

Wenn in der ISR etwas passieren soll, das eigentlich verboten ist – Display schreiben, Daten senden, Datei speichern – dann weckst du aus der ISR einen Task auf. Der Timer sorgt für das exakte Timing, der Task erledigt die Arbeit mit allen Freiheiten eines normalen Programms.

#include <Arduino.h>
#include <Wire.h>
#include <U8g2lib.h>

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

hw_timer_t *timer = nullptr;
TaskHandle_t anzeigeTask = nullptr;
volatile uint32_t sekunden = 0;

void IRAM_ATTR sekundenIsr() {
  sekunden++;

  // Task aus der ISR aufwecken - das ist erlaubt und sehr schnell
  BaseType_t hoeherPrioritaetGeweckt = pdFALSE;
  vTaskNotifyGiveFromISR(anzeigeTask, &hoeherPrioritaetGeweckt);
  if (hoeherPrioritaetGeweckt) portYIELD_FROM_ISR();
}

void anzeigeLoop(void *param) {
  char zeile[24];
  for (;;) {
    // Blockiert bis die ISR uns weckt - kostet null CPU-Zeit
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

    uint32_t s = sekunden;

    u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_6x12_te);
    u8g2.drawUTF8(0, 12, "Hardware-Timer");
    u8g2.drawHLine(0, 16, 128);

    u8g2.setFont(u8g2_font_logisoso24_tn);
    snprintf(zeile, sizeof(zeile), "%02lu:%02lu:%02lu",
             s / 3600UL, (s / 60UL) % 60UL, s % 60UL);
    u8g2.drawStr(0, 48, zeile);

    u8g2.setFont(u8g2_font_5x8_tf);
    snprintf(zeile, sizeof(zeile), "Heap %u kB", (unsigned)(ESP.getFreeHeap() / 1024));
    u8g2.drawStr(0, 62, zeile);

    u8g2.sendBuffer();
  }
}

void setup() {
  Wire.begin();
  Wire.setClock(400000);
  u8g2.begin();
  u8g2.enableUTF8Print();

  xTaskCreatePinnedToCore(anzeigeLoop, "anzeige", 4096, nullptr, 1, &anzeigeTask, 1);

#if ESP_ARDUINO_VERSION_MAJOR >= 3
  timer = timerBegin(1000000);
  timerAttachInterrupt(timer, &sekundenIsr);
  timerAlarm(timer, 1000000, true, 0);
#else
  timer = timerBegin(2, 80, true);
  timerAttachInterrupt(timer, &sekundenIsr, true);
  timerAlarmWrite(timer, 1000000, true);
  timerAlarmEnable(timer);
#endif
}

void loop() {
  // Bleibt komplett frei - hier koennte WLAN, MQTT oder was auch immer laufen
  delay(1000);
}

Troubleshooting

Praxistipps

• Timer 0 lieber freilassen. Einige Bibliotheken und der Task-Watchdog greifen auf Timer 0 zu. Wenn du nur einen brauchst, nimm bei Core 2.x lieber Timer 1 oder 2 – das erspart schwer auffindbare Konflikte.
• Miss die Dauer deiner ISR. Setz am Anfang einen GPIO auf HIGH, am Ende auf LOW, und häng ein Oszilloskop oder einen Logic Analyzer dran. Die ISR sollte deutlich unter 10 % des Intervalls liegen – bei 1 kHz also unter 100 µs.
• Zweierpotenzen für Ringpuffer. idx = (idx + 1) & (N - 1) ist eine einzelne Bit-Operation, idx = (idx + 1) % N eine Division. In einer ISR bei 10 kHz macht das einen messbaren Unterschied.
• Ein Timer kann mehrere Aufgaben bedienen. Lass ihn mit dem kleinsten gemeinsamen Intervall laufen und zähle in der ISR mit: Bei 1 kHz ist jeder 10. Tick 100 Hz, jeder 1000. eine Sekunde. Das spart Timer und hält die Aufgaben phasenstarr.
• Zum Debuggen die LED nehmen. Eine LED an GPIO2, die in der ISR getoggelt wird, zeigt dir die halbe Timerfrequenz. Bei 2 Hz Toggle siehst du 1 Hz Blinken – und ob es gleichmäßig ist, erkennt das Auge erstaunlich gut.
• Für reine Signalerzeugung ist LEDC oft besser. Wenn du nur ein Rechtecksignal oder ein PWM-Signal brauchst, mach das nicht mit einem Timer-Interrupt, sondern mit der LEDC-Einheit – die erzeugt das Signal komplett in Hardware, ganz ohne CPU-Last.
• Auf dem Arduino Nano heißt das anders. Der Nano hat drei Timer, die man über Register wie TCCR1B und OCR1A konfiguriert. Das Prinzip ist identisch, die Schreibweise völlig anders – dafür gibt es Bibliotheken wie TimerOne.