ESP8266: Präzise Impulserzeugung bei Flankenwechseln mit Arduino

Highlights

Präzise Flankenerkennung: Nutzen Sie Interrupts am ESP8266 (GPIO12) für eine schnelle und zuverlässige Erkennung von steigenden (LOW nach HIGH) und fallenden (HIGH nach LOW) Flanken am TTL-Eingang.
Nicht-blockierende Impulserzeugung: Generieren Sie 500ms HIGH-Impulse an den Ausgängen (GPIO14 für steigende Flanke, GPIO16 für fallende Flanke) mittels millis(), ohne die Hauptprogrammschleife zu blockieren.
Wichtige Hardware-Hinweise: Beachten Sie die 3.3V TTL-Logikpegel des ESP8266 und die spezifischen Eigenschaften der verwendeten GPIO-Pins (insbesondere GPIO16).

Einleitung: Ihr ESP8266 Projekt

Der ESP8266 ist ein leistungsstarker Mikrocontroller mit integriertem WLAN, ideal für IoT-Projekte. Eine häufige Anforderung ist die Reaktion auf externe Signale, wie z.B. TTL-Pegeländerungen (Flankenwechsel), um darauf basierend Aktionen auszuführen – in Ihrem Fall das Erzeugen zeitlich definierter Impulse an bestimmten Ausgängen. Diese Anleitung führt Sie durch die Erstellung eines robusten Arduino-Sketches, der genau diese Funktionalität auf Ihrem ESP8266 implementiert.

Die Aufgabenstellung im Detail

Sie benötigen einen Arduino-Code, der:

Einen TTL-Eingang an GPIO12 überwacht.
Zwei TTL-Ausgänge an GPIO14 und GPIO16 steuert.
Im Ruhezustand Eingang und beide Ausgänge auf LOW hält.
Bei einem Wechsel des Eingangs von LOW auf HIGH (steigende Flanke) einen 500 Millisekunden langen HIGH-Impuls an Ausgang 1 (GPIO14) sendet.
Bei einem Wechsel des Eingangs von HIGH auf LOW (fallende Flanke) einen 500 Millisekunden langen HIGH-Impuls an Ausgang 2 (GPIO16) sendet.

Der Arduino-Code für Ihren ESP8266

Der folgende Code implementiert die gewünschte Logik unter Verwendung von Interrupts für eine schnelle Flankenerkennung und der millis()-Funktion für eine nicht-blockierende Impulserzeugung. Dies stellt sicher, dass der ESP8266 auch während der Impulserzeugung für andere Aufgaben verfügbar bleibt.


// Definieren der verwendeten GPIO-Pins
const uint8_t EINGANG_PIN = 12;   // GPIO12 als TTL-Eingang
const uint8_t AUSGANG_PIN_1 = 14; // GPIO14 als TTL-Ausgang 1 (steigende Flanke)
const uint8_t AUSGANG_PIN_2 = 16; // GPIO16 als TTL-Ausgang 2 (fallende Flanke)

// Dauer des Ausgangsimpulses in Millisekunden
const unsigned long IMPULS_DAUER = 500;

// Volatile Variablen für die Kommunikation zwischen ISR und Hauptschleife
// 'volatile' verhindert, dass der Compiler Optimierungen vornimmt,
// die bei Variablen, die in ISRs geändert werden, zu Fehlern führen könnten.
volatile bool steigendeFlankeErkannt = false;
volatile bool fallendeFlankeErkannt = false;
volatile unsigned long impuls1StartTime = 0;
volatile unsigned long impuls2StartTime = 0;
volatile bool impuls1Aktiv = false;
volatile bool impuls2Aktiv = false;

// Interrupt Service Routine (ISR) - Wird bei JEDER Pegeländerung am EINGANG_PIN aufgerufen
// ICACHE_RAM_ATTR stellt sicher, dass die ISR im schnellen RAM ausgeführt wird
void ICACHE_RAM_ATTR handleInterrupt() {
  // Aktuellen Zustand des Eingangspins lesen
  bool aktuellerZustand = digitalRead(EINGANG_PIN);
  // Letzten bekannten Zustand speichern (statisch, damit der Wert über Aufrufe hinweg erhalten bleibt)
  static bool letzterZustand = LOW; 

  // Nur reagieren, wenn sich der Zustand tatsächlich geändert hat (Entprellung rudimentär)
  // Für robustere Entprellung siehe Hinweise unten.
  if (aktuellerZustand != letzterZustand) {
    if (aktuellerZustand == HIGH) {
      // Steigende Flanke (LOW -> HIGH) erkannt
      // Nur Flag setzen, wenn nicht schon ein Impuls auf diesem Ausgang aktiv ist
      if (!impuls1Aktiv) {
        steigendeFlankeErkannt = true;
      }
    } else {
      // Fallende Flanke (HIGH -> LOW) erkannt
      // Nur Flag setzen, wenn nicht schon ein Impuls auf diesem Ausgang aktiv ist
      if (!impuls2Aktiv) {
        fallendeFlankeErkannt = true;
      }
    }
    letzterZustand = aktuellerZustand; // Zustand für nächsten Interrupt-Aufruf merken
  }
}

void setup() {
  // Serielle Kommunikation für Debugging starten (optional)
  Serial.begin(115200);
  Serial.println("\nESP8266 Initialisierung...");

  // Pin-Modi festlegen
  pinMode(EINGANG_PIN, INPUT);     // Eingangspin konfigurieren
  pinMode(AUSGANG_PIN_1, OUTPUT);  // Ausgang 1 konfigurieren
  pinMode(AUSGANG_PIN_2, OUTPUT);  // Ausgang 2 konfigurieren

  // Initialen Zustand der Ausgänge auf LOW setzen
  digitalWrite(AUSGANG_PIN_1, LOW);
  digitalWrite(AUSGANG_PIN_2, LOW);
  Serial.println("Ausgangspins initial auf LOW gesetzt.");

  // Den Zustand des Eingangspins initial lesen, um den Startzustand für die ISR zu setzen
  // Dies ist wichtig, falls der Pin beim Start bereits HIGH ist.
  attachInterrupt(digitalPinToInterrupt(EINGANG_PIN), handleInterrupt, CHANGE);
  // Initialen Zustand in der ISR setzen (wird beim ersten Aufruf von handleInterrupt() erledigt)
  // Um sicherzugehen, den Startzustand hier explizit setzen:
  // bool startZustand = digitalRead(EINGANG_PIN);
  // // 'letzterZustand' in handleInterrupt direkt setzen ist nicht möglich, 
  // // daher ist ein erster Durchlauf der ISR nötig oder eine globale Variable.
  // // Der aktuelle Ansatz mit static bool in der ISR behandelt dies implizit.

  Serial.print("Interrupt an GPIO");
  Serial.print(EINGANG_PIN);
  Serial.println(" angehängt (Modus: CHANGE). Warte auf Flankenwechsel...");
}

void loop() {
  // Temporäre Variablen für die sichere Übertragung von volatile Werten
  bool lokaleSteigendeFlanke = false;
  bool lokaleFallendeFlanke = false;

  // Kritischer Abschnitt: Lese volatile Flags sicher aus
  // Deaktiviere Interrupts kurzzeitig, um inkonsistente Zustände zu vermeiden
  noInterrupts(); 
  if (steigendeFlankeErkannt) {
    lokaleSteigendeFlanke = true;
    steigendeFlankeErkannt = false; // Flag zurücksetzen
  }
  if (fallendeFlankeErkannt) {
    lokaleFallendeFlanke = true;
    fallendeFlankeErkannt = false; // Flag zurücksetzen
  }
  interrupts(); // Interrupts wieder aktivieren

  // Verarbeitung der erkannten Flankenwechsel (außerhalb des kritischen Abschnitts)
  unsigned long aktuelleZeit = millis();

  // Steigende Flanke verarbeiten: Impuls an Ausgang 1 starten
  if (lokaleSteigendeFlanke) {
      digitalWrite(AUSGANG_PIN_1, HIGH); // Ausgang 1 einschalten
      impuls1StartTime = aktuelleZeit;   // Startzeit des Impulses merken
      impuls1Aktiv = true;              // Markieren, dass Impuls 1 aktiv ist
      Serial.println("Steigende Flanke: Impuls 1 gestartet.");
  }

  // Fallende Flanke verarbeiten: Impuls an Ausgang 2 starten
  if (lokaleFallendeFlanke) {
      digitalWrite(AUSGANG_PIN_2, HIGH); // Ausgang 2 einschalten
      impuls2StartTime = aktuelleZeit;   // Startzeit des Impulses merken
      impuls2Aktiv = true;              // Markieren, dass Impuls 2 aktiv ist
      Serial.println("Fallende Flanke: Impuls 2 gestartet.");
  }

  // Aktive Impulse überprüfen und beenden, wenn die Dauer abgelaufen ist
  // Impuls 1 beenden
  if (impuls1Aktiv) {
    // Sicherstellen, dass millis() nicht übergelaufen ist oder die Differenz korrekt berechnet wird
    if (aktuelleZeit - impuls1StartTime >= IMPULS_DAUER) {
      digitalWrite(AUSGANG_PIN_1, LOW); // Ausgang 1 ausschalten
      impuls1Aktiv = false;             // Markieren, dass Impuls 1 beendet ist
      Serial.println("Impuls 1 beendet.");
    }
  }

  // Impuls 2 beenden
  if (impuls2Aktiv) {
    if (aktuelleZeit - impuls2StartTime >= IMPULS_DAUER) {
      digitalWrite(AUSGANG_PIN_2, LOW); // Ausgang 2 ausschalten
      impuls2Aktiv = false;             // Markieren, dass Impuls 2 beendet ist
      Serial.println("Impuls 2 beendet.");
    }
  }

  // Hier kann weiterer nicht-blockierender Code eingefügt werden
  // z.B. Netzwerkkommunikation, Sensorabfragen etc.
  // delay(1); // Optional: kleine Pause, um dem System Zeit zu geben
}

Erläuterungen zum Code

Pin-Definitionen: Die Konstanten EINGANG_PIN, AUSGANG_PIN_1, AUSGANG_PIN_2 und IMPULS_DAUER legen die verwendeten GPIOs und die Impulslänge fest.
Volatile Variablen: Variablen, die sowohl in der Interrupt Service Routine (ISR) als auch in der Hauptschleife (loop()) verwendet werden, müssen als volatile deklariert werden. Dies weist den Compiler an, diese Variablen nicht wegzuroptimieren und immer ihren aktuellen Wert aus dem Speicher zu lesen.
setup(): Initialisiert die serielle Kommunikation (optional für Debugging), konfiguriert die Pin-Modi (Eingang, Ausgänge) und setzt den Initialzustand der Ausgänge auf LOW. Anschließend wird der Interrupt mittels attachInterrupt() am EINGANG_PIN registriert. digitalPinToInterrupt(EINGANG_PIN) wandelt die GPIO-Nummer in die korrekte Interrupt-Nummer um. Der Modus CHANGE löst die ISR bei jeder Pegeländerung (steigend und fallend) aus.
handleInterrupt() (ISR): Diese Funktion wird automatisch aufgerufen, wenn eine Pegeländerung am Eingangspin erkannt wird. Sie liest den aktuellen Zustand, vergleicht ihn mit dem letzten bekannten Zustand (gespeichert in letzterZustand), um die Art der Flanke zu bestimmen (steigend oder fallend). Sie setzt dann das entsprechende volatile Flag (steigendeFlankeErkannt oder fallendeFlankeErkannt), aber nur, wenn der jeweilige Impuls nicht bereits aktiv ist. Wichtig: ISRs sollten so kurz wie möglich sein. Zeitaufwändige Operationen wie delay() oder lange Berechnungen sind hier tabu.
loop(): Die Hauptschleife überprüft kontinuierlich die volatile Flags. Um Race Conditions zu vermeiden (gleichzeitiger Zugriff auf die Variable durch ISR und loop()), werden Interrupts kurzzeitig mit noInterrupts() und interrupts() deaktiviert, während die Flags in lokale Variablen kopiert und zurückgesetzt werden. Wenn ein Flag gesetzt war, wird der entsprechende Impuls gestartet: Der Ausgang wird HIGH geschaltet, die Startzeit (millis()) wird gespeichert und ein Aktiv-Flag wird gesetzt. Die Schleife prüft auch, ob bei aktiven Impulsen die IMPULS_DAUER überschritten wurde. Wenn ja, wird der entsprechende Ausgang wieder LOW geschaltet und das Aktiv-Flag zurückgesetzt.
Nicht-blockierend: Durch die Verwendung von millis() statt delay() wird die loop()-Funktion nicht angehalten. Der ESP8266 kann während der 500ms-Impulse andere Aufgaben bearbeiten.

Wichtige Hardware-Aspekte

Spannungspegel (TTL 3.3V vs. 5V)

Der ESP8266 arbeitet mit einer Logikspannung von 3.3 Volt. Seine GPIO-Pins sind in der Regel nicht 5V-tolerant. Wenn Ihr TTL-Eingangssignal von einer 5V-Quelle stammt, müssen Sie unbedingt einen Logikpegelwandler (Level Shifter) oder einen einfachen Spannungsteiler verwenden, um die Spannung auf 3.3V zu reduzieren. Das direkte Anlegen von 5V an einen ESP8266-Eingangspin kann den Chip dauerhaft beschädigen!

ESP8266 verbunden über einen USB-zu-TTL-Adapter, der oft Pegelwandlung beinhaltet.

GPIO Pin-Besonderheiten

Die GPIO-Pins des ESP8266 haben unterschiedliche Funktionen und Einschränkungen. Für die von Ihnen gewählten Pins gilt:

GPIO12 (MISO): Ein gut geeigneter Pin für allgemeine Ein-/Ausgabe und unterstützt Interrupts.
GPIO14 (HSCLK): Ebenfalls ein Standard-GPIO, gut als Ausgang geeignet.
GPIO16 (XPD_DCDC / WAKE): Dieser Pin ist speziell. Er wird oft zum Aufwecken des ESP8266 aus dem Deep Sleep verwendet. Als normaler Ausgang funktioniert er, aber er unterstützt keine Interrupts, PWM oder I2C. Für Ihre Anwendung als reiner Ausgang ist er jedoch problemlos nutzbar.

GPIO Übersichtstabelle (Auswahl)

Diese Tabelle fasst die relevanten Eigenschaften der verwendeten Pins zusammen:

GPIO	Funktion im Code	Interrupt möglich?	Besonderheiten / Empfehlungen
12	Eingang	Ja	Standard-GPIO, gut für Interrupts geeignet.
14	Ausgang 1	Ja	Standard-GPIO, gut als Ausgang geeignet.
16	Ausgang 2	Nein	Funktioniert als Ausgang, aber ohne Interrupt/PWM. Hat oft internen Pull-down. Wird für Deep Sleep Wake benötigt.

Signalstabilität und Entprellung

Mechanische Schalter oder verrauschte Signale können schnelle, unerwünschte Pegelwechsel (Prellen) verursachen, die den Interrupt mehrfach auslösen. Der obige Code enthält eine minimale implizite Entprellung durch die Zustandsprüfung in der ISR. Für robustere Anwendungen sollten Sie eine explizite Entprellung hinzufügen:

Software-Entprellung: Prüfen Sie in der ISR oder im loop(), ob seit dem letzten gültigen Wechsel eine Mindestzeit (z.B. 20-50ms) vergangen ist, bevor Sie eine neue Flanke akzeptieren.
Hardware-Entprellung: Verwenden Sie einen RC-Filter (Widerstand und Kondensator) am Eingangspin.

Visualisierung der Implementierungsaspekte

Die Wahl der richtigen Methode zur Flankenerkennung und Impulsgenerierung beeinflusst die Performance und Zuverlässigkeit Ihres ESP8266-Projekts. Das folgende Diagramm vergleicht verschiedene Ansätze:

Dieses Diagramm zeigt, dass die Kombination aus Interrupts zur Erkennung und millis() zur Zeitsteuerung (empfohlene Methode) die beste Balance zwischen Reaktionsgeschwindigkeit, geringer CPU-Belastung und der Fähigkeit zur parallelen Verarbeitung anderer Aufgaben bietet.

Logikfluss als Mindmap

Die folgende Mindmap visualisiert den Ablauf der Signalverarbeitung im Arduino-Code:

mindmap root["ESP8266 Impulssteuerung"] id1["Initialisierung (setup)"] id1_1["Pins konfigurieren (12=IN, 14/16=OUT)"] id1_2["Ausgänge LOW setzen"] id1_3["Interrupt an Pin 12 anbinden (CHANGE)"] id1_4["Serielle Kommunikation starten (optional)"] id2["Laufzeit (loop)"] id2_1["Prüfe Flags (Interrupt erfolgt?)"] id2_1_1{"Steigende Flanke?"} id2_1_1_1["Ja: Impuls 1 starten"] id2_1_1_1_1["Pin 14 HIGH"] id2_1_1_1_2["Startzeit merken (millis)"] id2_1_1_1_3["'impuls1Aktiv' Flag setzen"] id2_1_1_2["Nein: Weiter"] id2_1_2{"Fallende Flanke?"} id2_1_2_1["Ja: Impuls 2 starten"] id2_1_2_1_1["Pin 16 HIGH"] id2_1_2_1_2["Startzeit merken (millis)"] id2_1_2_1_3["'impuls2Aktiv' Flag setzen"] id2_1_2_2["Nein: Weiter"] id2_2["Prüfe aktive Impulse"] id2_2_1{"Impuls 1 aktiv?"} id2_2_1_1{"Zeit abgelaufen (>= 500ms)?"} id2_2_1_1_1["Ja: Impuls 1 beenden (Pin 14 LOW, Flag löschen)"] id2_2_1_1_2["Nein: Weiter"] id2_2_2{"Impuls 2 aktiv?"} id2_2_2_1{"Zeit abgelaufen (>= 500ms)?"} id2_2_2_1_1["Ja: Impuls 2 beenden (Pin 16 LOW, Flag löschen)"] id2_2_2_1_2["Nein: Weiter"] id2_3["Andere Aufgaben (optional)"] id3["Interrupt Routine (ISR)"] id3_1["Pegel an Pin 12 lesen"] id3_2["Vergleich mit letztem Zustand"] id3_2_1{"Zustand geändert?"} id3_2_1_1["Ja: Flanke bestimmen (steigend/fallend)"] id3_2_1_1_1["Entsprechendes Flag setzen (volatile)"] id3_2_1_2["Nein: Ende ISR"] id3_3["Letzten Zustand aktualisieren"]

Die Mindmap verdeutlicht, wie der Eingangszustand über die Interrupt-Routine Flags setzt, die dann in der Hauptschleife abgefragt werden, um die zeitgesteuerten Impulse an den Ausgängen zu kontrollieren.

ESP8266 Programmierung via USB-TTL

Um den Arduino-Code auf Ihren ESP8266 zu übertragen, benötigen Sie in der Regel einen USB-zu-TTL-Konverter (wie CP2102 oder CH340). Diese Adapter wandeln die USB-Signale Ihres Computers in serielle TTL-Signale um, die der ESP8266 versteht. Achten Sie darauf, die richtigen Treiber für Ihren Konverter zu installieren und in der Arduino IDE das korrekte ESP8266-Board sowie den passenden COM-Port auszuwählen. Das folgende Video zeigt den generellen Prozess des Programmierens eines ESP8266 über einen solchen Adapter:

Video: Programmierung eines ESP8266 Moduls mit einem USB-zu-TTL Konverter.

Beim Hochladen muss der ESP8266 oft in den Programmiermodus versetzt werden (typischerweise durch Halten einer "Flash"- oder "GPIO0"-Taste beim Einschalten oder Resetten).