ESP8266 - Knopf - Langer Tastendruck Kurzer Tastendruck
Dieses Tutorial zeigt Ihnen, wie Sie mit dem ESP8266 den langen und den kurzen Tastendruck der Taste erkennen. Im Detail gehen wir auf die folgenden Beispiele ein:
- Der ESP8266 erkennt den kurzen Tastendruck am Knopf.
- Der ESP8266 erkennt den langen Tastendruck am Knopf.
- Der ESP8266 erkennt sowohl einen langen als auch einen kurzen Tastendruck am Knopf.
- Der ESP8266 entprellt sowohl den langen als auch den kurzen Tastendruck.
Im abschließenden Abschnitt untersuchen wir, wie man Entprellung in praktischen Anwendungen implementiert. Um mehr darüber zu erfahren, warum Entprellung bei Tasten notwendig ist, lesen Sie bitte diesen Artikel. Ohne Entprellung kann es zu einer fehlerhaften Erkennung eines Tastendrucks kommen.
Erforderliche Hardware
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.
Verdrahtungsdiagramm
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.
In diesem Tutorial verwenden wir den internen Pull-Up-Widerstand. Das bedeutet, dass der Taster im HIGH-Pegel ist, wenn er nicht gedrückt wird, und im LOW-Pegel, wenn er gedrückt wird.
So erkennen Sie einen kurzen Tastendruck
Wir berechnen die Zeitdauer zwischen dem Drücken und dem Loslassen. Wenn diese Dauer unter einer vorgegebenen Zeit liegt, erkennen wir einen kurzen Tastendruck.
Bestimmen Sie die Dauer eines maximalen Tastendrucks.
const int SHORT_PRESS_TIME = 500; // 500 Millisekunden
- Ermitteln Sie, wann der Knopf gedrückt wurde, und erfassen Sie den Zeitpunkt des Knopfdrucks.
if(prev_button_state == HIGH && button_state == LOW)
time_pressed = millis();
- Ermitteln, wann der Knopf losgelassen wird, und die Zeit seines Loslassens aufzeichnen.
if(prev_button_state == LOW && button_state == HIGH)
time_released = millis();
- Kraft
- Bestimmen Sie die Dauer und die Stärke des anzuwendenden Drucks.
long press_duration = time_released - time_pressed;
- Vergleichen Sie die Dauer des Tastendrucks mit der voreingestellten Zeit für einen kurzen Tastendruck.
- Bestimmen Sie anhand des Vergleichs, ob es sich um einen kurzen Tastendruck handelt.
if( press_duration < SHORT_PRESS_TIME )
Serial.println("A short press is detected");
ESP8266-Code zum Erkennen eines kurzen Tastendrucks
/*
* 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-long-press-short-press
*/
#define BUTTON_PIN D7 // The ESP8266 pin connected to button
#define SHORT_PRESS_TIME 500 // 500 milliseconds
int prev_button_state = LOW; // The previous state from the input pin
int button_state; // The current reading from the input pin
unsigned long time_pressed = 0;
unsigned long time_released = 0;
void setup() {
Serial.begin(9600);
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) // button is pressed
time_pressed = millis();
else if (prev_button_state == LOW && button_state == HIGH) { // button is released
time_released = millis();
long press_duration = time_released - time_pressed;
if ( press_duration < SHORT_PRESS_TIME )
Serial.println("A short press is detected");
}
// save the the last state
prev_button_state = button_state;
}
Schnelle Schritte
Um mit ESP8266 in der Arduino-IDE zu beginnen, befolgen Sie diese Schritte:
- Schau dir das Tutorial wie man die Umgebung für ESP8266 in der Arduino IDE einrichtet an, falls du ESP8266 zum ersten Mal verwendest.
- Verdrahte die Bauteile wie im Diagramm gezeigt.
- Schließe das ESP8266-Board über ein USB-Kabel an deinen Computer an.
- Öffne die Arduino IDE auf deinem Computer.
- Wähle das richtige ESP8266-Board, z. B. (NodeMCU 1.0 (ESP-12E-Modul)), und den jeweiligen COM-Port.
- Lade den Code mit der Arduino-IDE auf den ESP8266 hoch.
- Drücke den Knopf mehrmals kurz hintereinander.
- Überprüfe die Ausgabe im Serial Monitor.
COM6
A short press is detected
Autoscroll
Clear output
9600 baud
Newline
※ Notiz:
Der serielle Monitor kann bei einem einzigen Druck mehrere kurze Betätigungen erkennen. Dies ist das erwartete Verhalten des Tasters und wird als das „Chattering-Phänomen“ bezeichnet. Wir werden dieses Problem im letzten Teil des Tutorials ansprechen.
Wie man einen langen Druck erkennt
Es gibt zwei Szenarien, in denen ein langes Drücken erkannt werden kann:
- Wenn die Schaltfläche losgelassen wird, wird das Langdruck-Ereignis erkannt.
- Solange die Schaltfläche gedrückt wird, wird das Langdruck-Ereignis erkannt, auch bevor sie losgelassen wird.
- Für den ersten Fall berechnen wir das Zeitintervall zwischen dem Druck- und dem Loslassen-Ereignis. 2. Ist die Dauer länger als die vorgegebene Zeit, wird das Langdruck-Ereignis erkannt.
Im zweiten Anwendungsfall wird die Drückzeit gemessen, sobald der Knopf gedrückt wird, kontinuierlich überwacht und das Langdruck-Ereignis wird geprüft, bis der Knopf losgelassen wird. Während der Knopf gedrückt gehalten wird, wird das Langdruck-Ereignis erkannt, wenn die Dauer eine vorgegebene Zeit überschreitet.
ESP8266-Code zur Erkennung eines langen Tastendrucks beim Loslassen
/*
* 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-long-press-short-press
*/
#define BUTTON_PIN D7 // The ESP8266 pin connected to button
#define LONG_PRESS_TIME 1000 // 1000 milliseconds
int prev_button_state = LOW; // The previous state from the input pin
int button_state; // The current reading from the input pin
unsigned long time_pressed = 0;
unsigned long time_released = 0;
void setup() {
Serial.begin(9600);
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) // button is pressed
time_pressed = millis();
else if(prev_button_state == LOW && button_state == HIGH) { // button is released
time_released = millis();
long press_duration = time_released - time_pressed;
if( press_duration > LONG_PRESS_TIME )
Serial.println("A long press is detected");
}
// save the the last state
prev_button_state = button_state;
}
Schnelle Schritte
Um mit dem ESP8266 in der Arduino-IDE zu beginnen, befolgen Sie diese Schritte:
- Schau dir das Tutorial Anleitung zum Einrichten der ESP8266-Umgebung in der Arduino-IDE an, wenn du ESP8266 zum ersten Mal verwendest.
- Verbinde die Komponenten gemäß dem Diagramm.
- Schließe das ESP8266-Board mit einem USB-Kabel an deinen Computer an.
- Öffne die Arduino-IDE auf deinem Computer.
- Wähle das richtige ESP8266-Board aus, z. B. NodeMCU 1.0 (ESP-12E Module), und den entsprechenden COM-Port.
- Lade den Code über die Arduino-IDE auf den ESP8266 hoch.
- Warte eine Sekunde und drücke dann den Knopf und lasse ihn wieder los.
- Schau dir das Ergebnis im Serial Monitor an.
COM6
A long press is detected
Autoscroll
Clear output
9600 baud
Newline
Das Ereignis des Langdrucks wird nur erkannt, wenn die Taste losgelassen wird.
ESP8266-Code zur Erkennung eines langen Tastendrucks
/*
* 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-long-press-short-press
*/
#define BUTTON_PIN D7 // The ESP8266 pin connected to button
#define LONG_PRESS_TIME 1000 // 1000 milliseconds
int prev_button_state = LOW; // The previous state from the input pin
int button_state; // The current reading from the input pin
unsigned long time_pressed = 0;
bool is_pressing = false;
bool is_long_detected = false;
void setup() {
Serial.begin(9600);
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) { // button is pressed
time_pressed = millis();
is_pressing = true;
is_long_detected = false;
} else if(prev_button_state == LOW && button_state == HIGH) { // button is released
is_pressing = false;
}
if(is_pressing == true && is_long_detected == false) {
long press_duration = millis() - time_pressed;
if( press_duration > LONG_PRESS_TIME ) {
Serial.println("A long press is detected");
is_long_detected = true;
}
}
// save the the last state
prev_button_state = button_state;
}
Schnelle Schritte
Um mit ESP8266 in der Arduino-IDE zu beginnen, befolgen Sie diese Schritte:
- Schauen Sie sich das Tutorial zur Einrichtung der Entwicklungsumgebung für ESP8266 in der Arduino-IDE an, falls dies Ihr erster Einsatz von ESP8266 ist.
- Verbinden Sie die Bauteile 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, z. B. (NodeMCU 1.0 (ESP-12E-Modul)), und den entsprechenden COM-Port.
- Laden Sie den Code mithilfe der Arduino-IDE auf den ESP8266 hoch.
- Warten Sie einige Sekunden und drücken Sie dann den Knopf.
- Öffnen Sie den Seriellen Monitor, um die Ergebnisse anzuzeigen.
COM6
A long press is detected
Autoscroll
Clear output
9600 baud
Newline
Das Drücken und Halten des Knopfes wird nur erkannt, wenn der Knopf nicht losgelassen wurde.
Wie erkennt man sowohl langes Drücken als auch kurzes Drücken
Kurzer Druck und Langer Druck nach dem Loslassen
/*
* 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-long-press-short-press
*/
#define BUTTON_PIN D7 // The ESP8266 pin connected to button
#define SHORT_PRESS_TIME 1000 // 1000 milliseconds
#define LONG_PRESS_TIME 1000 // 1000 milliseconds
int prev_button_state = LOW; // The previous state from the input pin
int button_state; // The current reading from the input pin
unsigned long time_pressed = 0;
unsigned long time_released = 0;
void setup() {
Serial.begin(9600);
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) // button is pressed
time_pressed = millis();
else if (prev_button_state == LOW && button_state == HIGH) { // button is released
time_released = millis();
long press_duration = time_released - time_pressed;
if ( press_duration < SHORT_PRESS_TIME )
Serial.println("A short press is detected");
if ( press_duration > LONG_PRESS_TIME )
Serial.println("A long press is detected");
}
// save the the last state
prev_button_state = button_state;
}
Schnelle Schritte
Um mit dem ESP8266 in der Arduino-IDE zu beginnen, befolgen Sie diese Schritte:
- Schau dir das Tutorial Wie man die ESP8266-Umgebung in der Arduino-IDE einrichtet an, falls dies dein erster Einsatz von ESP8266 ist.
- Verbinde die Bauteile wie im Diagramm gezeigt.
- Schließe das ESP8266-Board mit einem USB-Kabel an deinen Computer an.
- Öffne die Arduino-IDE auf deinem Computer.
- Wähle das richtige ESP8266-Board, z. B. NodeMCU 1.0 (ESP-12E-Modul), und den entsprechenden COM-Port.
- Lade den Code über die Arduino-IDE auf den ESP8266 hoch.
- Drücke den Knopf einmal lang und einmal kurz.
- Sieh dir das Ergebnis im seriellen Monitor an.
※ Notiz:
Der serielle Monitor kann mehrere kurze Tastendrücke anzeigen, wenn ein langer Tastendruck ausgeführt wird. Dies ist das erwartete Verhalten des Tasters und wird als das Prellphänomen bezeichnet. Das Problem wird im letzten Teil des Tutorials behandelt.
Kurzer Druck und langer Druck während des Drückens
/*
* 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-long-press-short-press
*/
#define BUTTON_PIN D7 // The ESP8266 pin connected to button
#define SHORT_PRESS_TIME 1000 // 1000 milliseconds
#define LONG_PRESS_TIME 1000 // 1000 milliseconds
int prev_button_state = LOW; // The previous state from the input pin
int button_state; // The current reading from the input pin
unsigned long time_pressed = 0;
unsigned long time_released = 0;
bool is_pressing = false;
bool is_long_detected = false;
void setup() {
Serial.begin(9600);
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) { // button is pressed
time_pressed = millis();
is_pressing = true;
is_long_detected = false;
} else if (prev_button_state == LOW && button_state == HIGH) { // button is released
is_pressing = false;
time_released = millis();
long press_duration = time_released - time_pressed;
if ( press_duration < SHORT_PRESS_TIME )
Serial.println("A short press is detected");
}
if (is_pressing == true && is_long_detected == false) {
long press_duration = millis() - time_pressed;
if ( press_duration > LONG_PRESS_TIME ) {
Serial.println("A long press is detected");
is_long_detected = true;
}
}
// save the the last state
prev_button_state = button_state;
}
Schnelle Schritte
Um mit ESP8266 in der Arduino-IDE zu beginnen, befolgen Sie diese Schritte:
- Schau dir das Tutorial zur Einrichtung der ESP8266-Umgebung in der Arduino IDE an, falls du ESP8266 zum ersten Mal verwendest.
- Verbinde die Bauteile wie im Diagramm gezeigt.
- Schließe das ESP8266-Board über ein USB-Kabel an deinen Computer an.
- Öffne die Arduino IDE auf deinem Computer.
- Wähle das richtige ESP8266-Board aus, z. B. NodeMCU 1.0 (ESP-12E-Modul), und seinen jeweiligen COM-Port.
- Lade den Code über die Arduino IDE auf dein ESP8266 hoch.
- Drücke den Knopf kurz bzw. lange.
- Sieh dir das Ergebnis im Serial Monitor an.
※ Notiz:
Der serielle Monitor könnte mehrere kurze Tastendrücke erkennen, wenn ein langer Tastendruck ausgeführt wird. Dies ist das erwartete Verhalten des Tasters und wird als das 'Prellphänomen' bezeichnet. Eine Lösung für dieses Problem wird im letzten Abschnitt dieses Tutorials bereitgestellt.
Langer Druck und Kurzer Druck mit Entprellung
Es ist wesentlich, das Entprellen am Taster in verschiedenen Anwendungen zu implementieren.
Die Entprellung kann knifflig sein, insbesondere wenn mehrere Tasten beteiligt sind. Um Anfängern die Nutzung zu erleichtern, haben wir eine Bibliothek namens ezButton erstellt.
Wir werden diese Bibliothek in den folgenden Codes verwenden.
Kurzer Knopfdruck und langer Knopfdruck mit Entprellung nach dem Loslassen
/*
* 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-long-press-short-press
*/
#include <ezButton.h>
#define SHORT_PRESS_TIME 1000 // 1000 milliseconds
#define LONG_PRESS_TIME 1000 // 1000 milliseconds
ezButton button(D7); // create ezButton object for pin D7
unsigned long time_pressed = 0;
unsigned long time_released = 0;
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())
time_pressed = millis();
if (button.isReleased()) {
time_released = millis();
long press_duration = time_released - time_pressed;
if ( press_duration < SHORT_PRESS_TIME )
Serial.println("A short press is detected");
if ( press_duration > LONG_PRESS_TIME )
Serial.println("A long press is detected");
}
}
Schnelle Schritte
Um mit ESP8266 in der Arduino-IDE zu beginnen, befolgen Sie diese Schritte:
- Schau dir das Tutorial Wie man die Umgebung für ESP8266 in der Arduino IDE einrichtet an, wenn du ESP8266 zum ersten Mal verwendest.
- Verbinde die Bauteile entsprechend der Zeichnung.
- Schließe das ESP8266-Board mit einem USB-Kabel an deinen Computer an.
- Öffne die Arduino-IDE auf deinem Computer.
- Wähle das passende ESP8266-Board, z. B. (NodeMCU 1.0 (ESP-12E-Modul)), und den jeweiligen COM-Port.
- Um die ezButton-Bibliothek zu installieren, siehe Wie man die ezButton-Bibliothek installiert.
- Lade den Code über die Arduino-IDE auf den ESP8266 hoch.
- Drücke die Taste kurz oder halte sie länger gedrückt.
- Sieh dir das Ergebnis im Serial Monitor an.
Kurzer Tastendruck und langer Tastendruck mit Entprellung während des Tastendrucks
/*
* 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-long-press-short-press
*/
#include <ezButton.h>
#define SHORT_PRESS_TIME 1000 // 1000 milliseconds
#define LONG_PRESS_TIME 1000 // 1000 milliseconds
ezButton button(D7); // create ezButton object for pin D7
unsigned long time_pressed = 0;
unsigned long time_released = 0;
bool is_pressing = false;
bool is_long_detected = false;
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()) {
time_pressed = millis();
is_pressing = true;
is_long_detected = false;
}
if (button.isReleased()) {
is_pressing = false;
time_released = millis();
long press_duration = time_released - time_pressed;
if ( press_duration < SHORT_PRESS_TIME )
Serial.println("A short press is detected");
}
if (is_pressing == true && is_long_detected == false) {
long press_duration = millis() - time_pressed;
if ( press_duration > LONG_PRESS_TIME ) {
Serial.println("A long press is detected");
is_long_detected = true;
}
}
}
Schnelle Schritte
- Verdrahten Sie die Komponenten wie im Diagramm gezeigt.
- Verbinden Sie das ESP8266-Board über ein USB-Kabel mit Ihrem Computer.
- Ö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 jeweiligen COM-Port.
- Installieren Sie die ezButton-Bibliothek. Siehe How To für Anweisungen.
- Verwenden Sie die Arduino-IDE, um den Code auf den ESP8266 hochzuladen.
- Drücken Sie den Knopf und halten Sie ihn gedrückt, anschließend lassen Sie ihn los.
- Überprüfen Sie den seriellen Monitor, um das Ergebnis zu beobachten.
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.
Warum Lang- und Kurzdrücken benötigt werden
- Um die Anzahl der Tasten zu minimieren, kann eine Taste für mehrere Zwecke verwendet werden. Zum Beispiel kann ein kurzer Druck verwendet werden, um Betriebsmodi zu wechseln, und ein langer Druck kann dazu dienen, das Gerät auszuschalten.
- Langes Drücken wird verwendet, um unbeabsichtigte Betätigungen zu verhindern. Beispielsweise verwenden einige Geräte eine Taste zum Zurücksetzen auf Werkseinstellungen. Wenn sie versehentlich gedrückt wird, kann das gefährlich sein. Um dies zu vermeiden, ist das Gerät so konzipiert, dass das Zurücksetzen auf Werkseinstellungen nur durch langes Drücken der Taste aktiviert wird (z. B. bei mehr als 5 Sekunden).