Home
ESP8266

ESP8266 - Taster - Entprellung

Wenn eine Taste gedrückt oder losgelassen wird oder ein Schalter umgelegt wird, nehmen Neulinge oft an, dass sich der Zustand von LOW zu HIGH oder von HIGH zu LOW ändert. In Wirklichkeit ist das nicht der Fall. Aufgrund mechanischer und physikalischer Eigenschaften kann der Zustand der Taste (oder des Schalters) zwischen LOW und HIGH mehrfach während einer einzigen Benutzeraktion schwanken. Dieser Effekt wird als Prellen bezeichnet. Prellen kann dazu führen, dass ein einzelner Tastendruck als mehrere Tastendrücke erkannt werden, was zu Fehlfunktionen in bestimmten Anwendungen führt.

Klapperphänomen

Die Methode, dieses Problem zu verhindern, wird als Debouncing oder Debounce bezeichnet. Diese Anleitung zeigt Ihnen, wie man es bei der Verwendung des Tasters mit dem ESP8266 macht. Wir lernen anhand der folgenden Schritte:

Erforderliche Hardware

1×ESP8266 NodeMCU
1×USB-Kabel Typ-A zu Typ-C (für USB-A PC)
1×USB-Kabel Typ-C zu Typ-C (für USB-C PC)
1×Breadboard-Taster mit Kappe
1×Breadboard-Taster-Kit
1×Panel-Drucktaster
1×Taster-Modul
1×Breadboard
1×Verbindungskabel
1×(Empfohlen) Schraubklemmen-Erweiterungsboard für ESP8266
1×(Empfohlen) Stromverteiler für ESP8266 Typ-C

Oder Sie können die folgenden Kits kaufen:

1×DIYables Sensor-Kit (30 Sensoren/Displays)
1×DIYables Sensor-Kit (18 Sensoren/Displays)
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.

Über die Schaltfläche

Wenn Sie mit Tasten nicht vertraut sind (einschließlich Pinbelegung, Funktionsweise und Programmierung), können Ihnen die folgenden Tutorials helfen:

Verdrahtungsdiagramm

ESP8266 NodeMCU-Taster-Schaltplan

Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.

Weitere Informationen finden Sie unter ESP8266-Pinbelegung und wie man ESP8266 und andere Komponenten mit Strom versorgt.

Lassen wir uns den ESP8266-Code sowohl mit als auch ohne Entprellung ansehen und deren jeweiliges Verhalten vergleichen.

Tasterauslesen ohne Entprellung

Bevor Sie das Debouncing untersuchen, werfen Sie einen Blick auf den Code ohne Debouncing und beobachten Sie dessen Verhalten.

Schnelle Schritte

Um mit dem ESP8266 in der Arduino-IDE zu beginnen, befolgen Sie diese Schritte:

  • Schauen Sie sich das Tutorial [Wie man die Umgebung für ESP8266 in der Arduino IDE einrichtet] an, falls dies Ihre erste Verwendung des ESP8266 ist.
  • Verdrahten Sie die Bauteile wie im Diagramm gezeigt.
  • Verbinden Sie das ESP8266-Board mit Ihrem Computer über ein USB-Kabel.
  • Öffnen Sie die Arduino-IDE auf Ihrem Computer.
  • Wählen Sie das richtige ESP8266-Board aus, z. B. NodeMCU 1.0 (ESP-12E Module), und den jeweiligen COM-Port.
  • Verbinden Sie Ihren ESP8266 mit Ihrem Computer über ein USB-Kabel.
  • Starten Sie die Arduino-IDE und wählen Sie das passende Board sowie den entsprechenden Port aus.
  • Kopieren Sie den unten stehenden Code und öffnen Sie ihn in der Arduino-IDE.
/* * Dieser ESP8266 NodeMCU Code wurde von newbiely.de entwickelt * Dieser ESP8266 NodeMCU Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp8266/esp8266-button-debounce */ #define BUTTON_PIN D7 // The ESP8266 pin D7 connected to button int prev_button_state = LOW; // The previous state from the input pin int button_state; // The current reading from the input pin void setup() { // Initialize the Serial to communicate with the Serial Monitor. Serial.begin(9600); // Configure the ESP8266 pin as a pull-up input: HIGH when the button is open, LOW when pressed. pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: button_state = digitalRead(BUTTON_PIN); if (prev_button_state == HIGH && button_state == LOW) Serial.println("The button is pressed"); else if (prev_button_state == LOW && button_state == HIGH) Serial.println("The button is released"); // save the the last state prev_button_state = button_state; }
  • Klicken Sie in der Arduino IDE auf die Schaltfläche Hochladen, um den Code zu kompilieren und auf den ESP8266 hochzuladen.
Code in der Arduino-IDE hochladen
  • Öffne den seriellen Monitor.
  • Drücke den Knopf einige Sekunden lang, dann lasse ihn los.
  • Prüfe die Ausgabe im seriellen Monitor.
COM6
Send
The button is pressed The button is pressed The button is pressed The button is released The button is released
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Sie werden möglicherweise feststellen, dass Sie den Knopf manchmal nur einmal gedrückt und losgelassen haben. Der ESP8266 interpretiert es jedoch als mehrere Druck- und Loslassvorgänge. Dies ist das Prellen, das am Anfang des Tutorials erwähnt wurde. Lassen Sie uns sehen, wie man es im nächsten Teil behebt.

Taster mit Entprellung

Der unten stehende Code wendet die Debounce-Methode an, um das Prellen zu verhindern.

/* * Dieser ESP8266 NodeMCU Code wurde von newbiely.de entwickelt * Dieser ESP8266 NodeMCU Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp8266/esp8266-button-debounce */ #define BUTTON_PIN D7 // The ESP8266 pin D7 connected to button #define DEBOUNCE_TIME 50 // The debounce time in millisecond, increase this time if it still chatters int lastSteadyState = LOW; // The previous steady state from the input pin int lastFlickerableState = LOW; // The previous flickerable state from the input pin int button_state; // The current reading from the input pin // The following variables are unsigned longs because the time, measured in // milliseconds, will quickly become a bigger number than can be stored in an int. unsigned long lastDebounceTime = 0; // The last time the output pin was toggled void setup() { // Initialize the Serial to communicate with the Serial Monitor. Serial.begin(9600); // Configure the ESP8266 pin as a pull-up input: HIGH when the button is open, LOW when pressed. pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: button_state = digitalRead(BUTTON_PIN); // check to see if you just pressed the button // (i.e. the input went from LOW to HIGH), and you've waited long enough // since the last press to ignore any noise: // If the switch/button changed, due to noise or pressing: if (button_state != lastFlickerableState) { // reset the debouncing timer lastDebounceTime = millis(); // save the the last flickerable state lastFlickerableState = button_state; } if ((millis() - lastDebounceTime) > DEBOUNCE_TIME) { // whatever the reading is at, it's been there for longer than the debounce // delay, so take it as the actual current state: // if the button state has changed: if(lastSteadyState == HIGH && button_state == LOW) Serial.println("The button is pressed"); else if(lastSteadyState == LOW && button_state == HIGH) Serial.println("The button is released"); // save the the last steady state lastSteadyState = button_state; } }

Schnelle Schritte

  • Verdrahten Sie die Komponenten wie im Diagramm gezeigt.
  • Schließen Sie das ESP8266-Board mit einem USB-Kabel an Ihren Computer an.
  • Öffnen Sie die Arduino-IDE auf Ihrem Computer.
  • Wählen Sie das richtige ESP8266-Board aus, z. B. NodeMCU 1.0 (ESP-12E-Modul), und den entsprechenden COM-Port.
  • Kopieren Sie den obigen Code und öffnen Sie ihn in der Arduino-IDE.
  • Klicken Sie in der Arduino-IDE auf die Hochladen-Schaltfläche, um den Code zu kompilieren und auf den ESP8266 hochzuladen.
  • Öffnen Sie den Seriellen Monitor.
  • Halten Sie den Knopf einige Sekunden gedrückt und lassen Sie ihn dann los.
  • Überprüfen Sie den Seriellen Monitor, um das Ergebnis zu sehen.
COM6
Send
The button is pressed The button is released
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Wie Sie sehen können, haben Sie den Knopf nur einmal gedrückt und losgelassen. Der ESP8266 kann dies als einen einzelnen Tastendruck und Freigabe erkennen, wodurch unnötiges Prellen vermieden wird.

Wir haben es einfach gemacht - ESP8266-Taster-Entprellungscode mit Bibliothek

Wir haben eine Bibliothek entwickelt, ezButton, um es Anfängern leichter zu machen, insbesondere wenn sie mehrere Knöpfe verwenden. Hier erfahren Sie mehr über die ezButton-Bibliothek.

ESP8266-Button-Entprellungscode für einen einzelnen Button

/* * Dieser ESP8266 NodeMCU Code wurde von newbiely.de entwickelt * Dieser ESP8266 NodeMCU Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp8266/esp8266-button-debounce */ #include <ezButton.h> ezButton button(D7); // create ezButton object for pin D7 void setup() { Serial.begin(9600); button.setDebounceTime(50); // set debounce time to 50 milliseconds } void loop() { button.loop(); // MUST call the loop() function first if(button.isPressed()) Serial.println("The button is pressed"); if(button.isReleased()) Serial.println("The button is released"); }

ESP8266-Tasten-Entprell-Code für mehrere Tasten

/* * Dieser ESP8266 NodeMCU Code wurde von newbiely.de entwickelt * Dieser ESP8266 NodeMCU Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp8266/esp8266-button-debounce */ #include <ezButton.h> ezButton button1(D5); // create ezButton object for pin D5 ezButton button2(D6); // create ezButton object for pin D6 ezButton button3(D7); // create ezButton object for pin D7 void setup() { Serial.begin(9600); button1.setDebounceTime(50); // set debounce time to 50 milliseconds button2.setDebounceTime(50); // set debounce time to 50 milliseconds button3.setDebounceTime(50); // set debounce time to 50 milliseconds } void loop() { button1.loop(); // MUST call the loop() function first button2.loop(); // MUST call the loop() function first button3.loop(); // MUST call the loop() function first if(button1.isPressed()) Serial.println("The button 1 is pressed"); if(button1.isReleased()) Serial.println("The button 1 is released"); if(button2.isPressed()) Serial.println("The button 2 is pressed"); if(button2.isReleased()) Serial.println("The button 2 is released"); if(button3.isPressed()) Serial.println("The button 3 is pressed"); if(button3.isReleased()) Serial.println("The button 3 is released"); }

Der Schaltplan des oben gezeigten Codes.

Die Abbildung der Verkabelung für den Code.

Die Darstellung der Verbindungen für den Code.

Verdrahtungsdiagramm der ESP8266 NodeMCU-Tasterbibliothek

Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.

Video Tutorial

Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.

Zusätzliches Wissen

  • Der Wert von DEBOUNCE_DELAY hängt von den physischen Eigenschaften des Knopfes ab. Jeder Knopf kann einen anderen Wert haben.

Erweiterbarkeit

Die Entprelltechnik kann bei Schaltern, Berührungssensoren und vielem mehr eingesetzt werden.

Verwandte Tutorials

※ UNSERE NACHRICHTEN

  • Sie können gerne den Link zu diesem Tutorial teilen. Bitte verwenden Sie jedoch unsere Inhalte nicht auf anderen Websites. Wir haben viel Mühe und Zeit in die Erstellung der Inhalte investiert, bitte respektieren Sie unsere Arbeit!
OFFENLEGUNG
Newbiely.de ist Teilnehmer des Amazon Services LLC Associates Program, einem Affiliate-Werbeprogramm, das entwickelt wurde, um Websites eine Möglichkeit zu bieten, Werbegebühren durch Werbung und Verlinkung zu Amazon.com, Amazon.it, Amazon.de, Amazon.co.uk, Amazon.ca, Amazon.de, Amazon.es, Amazon.nl, Amazon.pl und Amazon.se zu verdienen
Copyright © 2025 Newbiely.de. Alle Rechte vorbehalten.
Allgemeine Geschäftsbedingungen | Datenschutzrichtlinie
Email: newbiely.com@gmail.com