Home
ESP32 S3

ESP32 S3 - Taster - Langer Druck, kurzer Druck

Dieses Tutorial zeigt Ihnen, wie Sie Ihren ESP32 S3 so programmieren, dass er sowohl lange als auch kurze Tastendrücke erkennt. Sie lernen alles von der grundlegenden Verdrahtung und Entprelltechniken bis hin zur Kombination mehrerer Druckarten an einem einzigen Taster für eine leistungsfähigere Eingabeverarbeitung.

Was Sie bauen werden:

  1. Einen Detektor für kurze Drücke, der eine Druckdauer unter einem Schwellenwert misst
  2. Einen Detektor für lange Drücke, der beim Loslassen oder während des Drückens auslöst
  3. Einen Taster mit zwei Modi, der kurze und lange Drücke am selben Pin unterscheidet
  4. Eine entprellte Version mit der ezButton-Bibliothek für praxistaugliche Zuverlässigkeit
ESP32 S3 - Taster - Langer Druck, kurzer Druck

Erforderliche Hardware

1×ESP32 S3 WROOM N16R8
1×(Alternativ) ESP32 S3 SuperMini Dev Module
1×(Alternativ) ESP32 S3 Uno-form Board
1×(Alternativ) ESP32 S3 Camera Board
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×(Optional) DC-Stromanschluss
1×(Empfohlen) Screw Terminal Expansion Board for ESP32 S3
1×(Empfohlen) Breakout Expansion Board for ESP32 S3
1×(Empfohlen) Power Splitter for ESP32 S3

Oder Sie können die folgenden Kits kaufen:

1×DIYables ESP32 S3 Starter-Kit (ESP32 S3 enthalten)
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.

Überblick über Button

Ein Taster ist ein einfaches Eingabegerät, das beim Drücken einen Stromkreis schließt. Wenn er mit aktiviertem internem Pull-up-Widerstand an den ESP32 S3 angeschlossen ist, liest der Pin im losgelassenen Zustand HIGH und beim Drücken LOW. So lassen sich Drück- und Loslass-Ereignisse einfach und präzise erkennen.

Wichtige Spezifikationen

Taster am ESP32 S3 unterstützen mehrere Interaktionsmuster: kurzer Druck, langer Druck und Doppelklick. Sie funktionieren direkt mit den internen Pull-up-Widerständen des ESP32 S3, sodass keine externen Widerstände nötig sind. Da physische Taster mechanische Störungen (Prellen) erzeugen, ist für eine zuverlässige Erkennung in realen Projekten eine Entprellung erforderlich.

Weitere Ressourcen zu Tastern:

Verdrahtungsdiagramm

Schließen Sie Ihren Taster an den ESP32 S3 an, indem Sie einen Anschluss mit einem GPIO-Pin und den anderen mit GND verbinden. Der interne Pull-up-Widerstand wird per Software aktiviert, sodass kein externer Widerstand erforderlich ist.

Sicherheitshinweise

Überprüfen Sie Ihre Verdrahtung immer, bevor Sie das Board mit Strom versorgen. Mit einem Steckbrett können Sie Änderungen einfach ohne Löten vornehmen. Da dieses Tutorial den internen Pull-up-Widerstand verwendet, liest der Tasterzustand im losgelassenen Zustand HIGH und im gedrückten Zustand LOW – denken Sie daran, wenn Sie den Code lesen.

Bauteil-Pin ESP32 S3 Pin
Taster Anschluss 1 GPIO 9
Taster Anschluss 2 GND
Schaltplan ESP32 S3 Taster

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

Wie man einen kurzen Druck erkennt

Um einen kurzen Druck am ESP32 S3 zu erkennen, wird die Dauer zwischen dem Drück-Ereignis und dem Loslass-Ereignis gemessen. Liegt diese Dauer unter einem festgelegten Schwellenwert, gilt der kurze Druck als bestätigt.

Methode zur Erkennung eines kurzen Drucks:

  • Die Zeit zwischen dem Drück- und dem Loslass-Ereignis messen
  • Ist die Dauer kürzer als eine vordefinierte Zeit, wird ein kurzer Druck erkannt
  • Die Druckdauer mit Ihrem Schwellenwert SHORT_PRESS_TIME vergleichen

Schrittweise Umsetzung:

  • Festlegen, wie lange ein kurzer Druck maximal dauert
#define SHORT_PRESS_TIME 500 // 500 milliseconds
  • Erkennen, dass der Taster gedrückt wird, und den Zeitpunkt des Drückens speichern
if(prev_state == HIGH && button_state == LOW) pressed_time = millis();
  • Erkennen, dass der Taster losgelassen wird, und den Zeitpunkt des Loslassens speichern
if(prev_state == LOW && button_state == HIGH) released_time = millis();
  • Die Druckdauer berechnen und
long press_duration = released_time - pressed_time;
  • Den kurzen Druck bestimmen, indem die Druckdauer mit der definierten Zeit für einen kurzen Druck verglichen wird
if( press_duration < SHORT_PRESS_TIME ) Serial.println("A short press is detected");

ESP32 S3 Code zur Erkennung eines kurzen Drucks

Der folgende Sketch liest den Tasterzustand mit dem internen Pull-up-Widerstand des ESP32 S3 aus, berechnet die Dauer zwischen Drücken und Loslassen und gibt eine Meldung im Seriellen Monitor aus, wenn ein kurzer Druck erkannt wird. Der Schwellenwert ist standardmäßig auf 500 ms eingestellt und kann an Ihre Anwendung angepasst werden.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 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/esp32-s3/esp32-s3-button-long-press-short-press */ #define BUTTON_PIN 21 // The ESP32 S3 pin GPIO21 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 pressed_time = 0; unsigned long released_time = 0; void setup() { Serial.begin(115200); 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 pressed_time = millis(); else if (prev_button_state == LOW && button_state == HIGH) { // button is released released_time = millis(); long press_duration = released_time - pressed_time; 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

  1. Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  3. Code hochladen: Kopieren Sie den obigen Code und laden Sie ihn über die Arduino IDE auf Ihren ESP32 S3 hoch
  4. Hardware verdrahten: Schließen Sie den Taster gemäß dem Schaltplan an Ihren ESP32 S3 an
  5. Taster testen: Drücken Sie den Taster mehrmals kurz
  6. Ergebnisse prüfen: Öffnen Sie den Seriellen Monitor (115200 Baud), um die Erkennungsergebnisse zu sehen
  7. Profi-Tipp: Passen Sie den Wert SHORT_PRESS_TIME an, um die Erkennung kurzer Drücke schneller oder langsamer zu machen
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[00:01:12.345] A short press is detected [00:01:13.891] A short press is detected [00:01:15.204] A short press is detected
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

※ Notiz:

Der Serielle Monitor kann bei einem einzigen Druck mehrere kurze Drücke ausgeben. Das ist ein normales Verhalten des Tasters und wird "Prellen" genannt. Wie Sie dieses Problem beseitigen, lernen Sie später in diesem Tutorial.

Wie man einen langen Druck erkennt

Es gibt zwei Methoden, um lange Tastendrücke am ESP32 S3 zu erkennen, die jeweils für unterschiedliche Anforderungen geeignet sind. Die erste Methode erkennt den langen Druck nach dem Loslassen des Tasters, die zweite erkennt ihn in Echtzeit, während der Taster gedrückt gehalten wird.

Zwei Anwendungsfälle für die Erkennung eines langen Drucks:

  • Der lange Druck wird direkt nach dem Loslassen des Tasters erkannt
  • Der lange Druck wird erkannt, während der Taster gedrückt wird

Erste Methode (Erkennung beim Loslassen):

  • Die Zeitdauer zwischen dem Drück- und dem Loslass-Ereignis messen
  • Ist die Dauer länger als eine vordefinierte Zeit, wird ein langer Druck erkannt

Zweite Methode (Erkennung während des Drückens):

  • Die Druckzeit fortlaufend messen, solange der Taster gehalten wird
  • Überschreitet die Dauer die vordefinierte Zeit, wird sofort ein langer Druck erkannt
  • Weiter prüfen, bis der Taster losgelassen wird

ESP32 S3 Code zur Erkennung eines langen Drucks beim Loslassen

Dieser Sketch misst die gesamte Druckdauer vom Moment des Drückens bis zum Loslassen. Überschreitet die Dauer LONG_PRESS_TIME (1000 ms), wird der lange Druck im Seriellen Monitor gemeldet. Diese Methode eignet sich am besten, wenn Sie sicherstellen möchten, dass der Benutzer den Taster die volle Zeit gehalten hat, bevor eine Aktion ausgeführt wird.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 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/esp32-s3/esp32-s3-button-long-press-short-press */ #define BUTTON_PIN 21 // The ESP32 S3 pin GPIO21 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 pressed_time = 0; unsigned long released_time = 0; void setup() { Serial.begin(115200); 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 pressed_time = millis(); else if(prev_button_state == LOW && button_state == HIGH) { // button is released released_time = millis(); long press_duration = released_time - pressed_time; 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

  1. Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  3. Code hochladen: Kopieren Sie den obigen Code und laden Sie ihn über die Arduino IDE auf den ESP32 S3 hoch
  4. Langen Druck testen: Drücken und halten Sie den Taster länger als eine Sekunde und lassen Sie ihn dann los
  5. Seriellen Monitor prüfen: Öffnen Sie den Seriellen Monitor mit 115200 Baud, um die Ergebnisse zu sehen
  6. Profi-Tipp: Diese Methode eignet sich am besten, wenn die Aktion nach dem Loslassen des Tasters erfolgen soll und nicht während des Drückens
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[00:02:05.112] A long press is detected [00:02:08.774] A long press is detected
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

ESP32 S3 Code zur Erkennung eines langen Drucks während des Drückens

Dieser Sketch prüft die Druckdauer fortlaufend, während der Taster gehalten wird, und löst die Erkennung des langen Drucks in dem Moment aus, in dem der Schwellenwert überschritten wird – ohne auf das Loslassen des Tasters zu warten. Das ist ideal für Anwendungen, die eine sofortige Rückmeldung erfordern, etwa das Auslösen eines Werksresets, während der Taster noch gehalten wird.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 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/esp32-s3/esp32-s3-button-long-press-short-press */ #define BUTTON_PIN 21 // The ESP32 S3 pin GPIO21 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 pressed_time = 0; bool is_pressing = false; bool is_long_detected = false; void setup() { Serial.begin(115200); 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 pressed_time = 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() - pressed_time; 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

  1. Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  3. Code hochladen: Laden Sie den obigen Code über die Arduino IDE auf Ihren ESP32 S3 hoch
  4. Während des Drückens testen: Drücken und halten Sie den Taster mehrere Sekunden lang (nicht sofort loslassen)
  5. Timing beobachten: Beachten Sie, dass die Erkennung erfolgt, während Sie noch drücken
  6. Profi-Tipp: Diese Methode liefert eine sofortige Rückmeldung und eignet sich besser für zeitkritische Anwendungen wie Werksreset-Funktionen
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[00:03:22.601] A long press is detected
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

Wie man sowohl einen langen als auch einen kurzen Druck erkennt

Durch die Kombination beider Prüfungen der Druckdauer in einem einzigen Sketch kann ein Taster an Ihrem ESP32 S3 zwei völlig unabhängige Funktionen steuern. Das verringert die Anzahl der Bauteile und vereinfacht Ihre Schaltung, ohne die Bedienbarkeit einzuschränken.

Kurzer und langer Druck nach dem Loslassen

Dieser Sketch unterscheidet kurze und lange Drücke anhand der Dauer, die der Taster gehalten wurde, und trifft die Entscheidung erst nach dem Loslassen des Tasters. Ein einziger Schwellenwert LONG_PRESS_TIME trennt die beiden Verhaltensweisen und ermöglicht zwei verschiedene Aktionen mit einem Taster ohne zusätzliche Hardware.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 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/esp32-s3/esp32-s3-button-long-press-short-press */ #define BUTTON_PIN 21 // The ESP32 S3 pin GPIO21 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 pressed_time = 0; unsigned long released_time = 0; void setup() { Serial.begin(115200); 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 pressed_time = millis(); else if (prev_button_state == LOW && button_state == HIGH) { // button is released released_time = millis(); long press_duration = released_time - pressed_time; 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

  1. Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  3. Code hochladen: Laden Sie den obigen Code über die Arduino IDE auf den ESP32 S3 hoch
  4. Beide Arten testen: Probieren Sie sowohl einen langen Druck (>1 Sekunde halten) als auch einen kurzen Druck (kurzes Antippen)
  5. Seriellen Monitor prüfen: Öffnen Sie den Seriellen Monitor, um zu sehen, welche Druckart erkannt wird
  6. Profi-Tipp: Stellen Sie LONG_PRESS_TIME passend zum erwarteten Verhalten Ihrer Benutzer ein (typischerweise funktionieren 500–1500 ms gut)
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[00:04:10.330] A short press is detected [00:04:13.890] A long press is detected [00:04:15.210] A short press is detected [00:04:16.540] A short press is detected
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

※ Notiz:

Der Serielle Monitor kann bei einem langen Druck mehrere kurze Drücke anzeigen. Das ist ein normales Verhalten des Tasters und wird "Prellen" genannt. Das Problem wird im letzten Teil dieses Tutorials gelöst.

Kurzer und langer Druck während des Drückens

Dieser Sketch erkennt einen langen Druck sofort, wenn der Schwellenwert erreicht ist, und erkennt trotzdem einen kurzen Druck beim Loslassen, falls der Schwellenwert nie erreicht wurde. So erhalten Sie die schnellstmögliche Reaktion auf lange Drücke, während die Erkennung kurzer Drücke voll funktionsfähig bleibt.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 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/esp32-s3/esp32-s3-button-long-press-short-press */ #define BUTTON_PIN 21 // The ESP32 S3 pin GPIO21 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 pressed_time = 0; unsigned long released_time = 0; bool is_pressing = false; bool is_long_detected = false; void setup() { Serial.begin(115200); 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 pressed_time = millis(); is_pressing = true; is_long_detected = false; } else if (prev_button_state == LOW && button_state == HIGH) { // button is released is_pressing = false; released_time = millis(); long press_duration = released_time - pressed_time; 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() - pressed_time; 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

  1. Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  3. Code hochladen: Laden Sie den Code über die Arduino IDE auf Ihren ESP32 S3 hoch
  4. Timing testen: Probieren Sie kurzes Antippen und langes Halten, um die unterschiedlichen Verhaltensweisen zu sehen
  5. Reaktion beobachten: Beachten Sie, dass der lange Druck sofort auslöst und nicht erst beim Loslassen
  6. Profi-Tipp: Diese Methode verhindert versehentliches Auslösen eines langen Drucks, da Benutzer sofort eine Rückmeldung erhalten
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[00:05:02.145] A short press is detected [00:05:05.768] A long press is detected [00:05:07.093] A short press is detected [00:05:10.412] A long press is detected
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

Langer und kurzer Druck mit Entprellung

Mechanische Taster erzeugen beim Öffnen und Schließen ihrer Kontakte elektrische Störungen, wodurch der Mikrocontroller bei einem einzigen physischen Druck mehrere Übergänge liest. Die Entprellung filtert diese Störungen heraus und ist für eine zuverlässige Erkennung langer und kurzer Drücke am ESP32 S3 unerlässlich.

Die ezButton-Bibliothek übernimmt die gesamte Entprelllogik automatisch und ist daher sowohl für Einsteiger als auch für Serienprojekte der empfohlene Ansatz. Sie funktioniert zuverlässig mit mehreren Tastern und lässt sich sauber mit der in den vorherigen Abschnitten verwendeten Logik zur Druckdauer kombinieren.

Kurzer und langer Druck mit Entprellung nach dem Loslassen

Dieser Sketch kombiniert die Entprellung der ezButton-Bibliothek mit der Erkennung der Druckart nach dem Loslassen. Er beseitigt Fehlerkennungen durch Tasterprellen und unterscheidet gleichzeitig zuverlässig zwischen kurzen und langen Drücken – ein praxistauglicher Eingabe-Handler für Ihr ESP32 S3 Projekt.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 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/esp32-s3/esp32-s3-button-long-press-short-press */ #include <ezButton.h> #define SHORT_PRESS_TIME 1000 // 1000 milliseconds #define LONG_PRESS_TIME 1000 // 1000 milliseconds ezButton button(21); // create ezButton object for pin Arduino Nano ESP32 pin GPIO21 unsigned long pressed_time = 0; unsigned long released_time = 0; void setup() { Serial.begin(115200); button.setDebounceTime(50); // set debounce time to 50 milliseconds } void loop() { button.loop(); // MUST call the loop() function first if (button.isPressed()) pressed_time = millis(); if (button.isReleased()) { released_time = millis(); long press_duration = released_time - pressed_time; 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

  1. Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  3. Bibliothek installieren: Installieren Sie die ezButton-Bibliothek – siehe Anleitung
  4. Code hochladen: Laden Sie den obigen Code über die Arduino IDE auf den ESP32 S3 hoch
  5. Saubere Erkennung testen: Probieren Sie lange und kurze Drücke – keine doppelten Erkennungen mehr
  6. Ergebnisse prüfen: Öffnen Sie den Seriellen Monitor, um die saubere, genaue Erkennung der Tastendrücke zu sehen
  7. Profi-Tipp: Die ezButton-Bibliothek beseitigt alle Prellprobleme automatisch – verwenden Sie sie für alle Serienprojekte
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[00:06:14.221] A short press is detected [00:06:17.885] A long press is detected [00:06:19.103] A short press is detected
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

Kurzer und langer Druck mit Entprellung während des Drückens

Dieser Sketch ergänzt die Echtzeit-Erkennung langer Drücke um die Entprellung von ezButton und kombiniert so eine sofortige Reaktion auf lange Drücke mit einer sauberen Störfilterung. Dies ist die zuverlässigste Methode für ESP32 S3 Projekte, bei denen sowohl Genauigkeit als auch Reaktionsschnelligkeit gefragt sind.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 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/esp32-s3/esp32-s3-button-long-press-short-press */ #include <ezButton.h> #define SHORT_PRESS_TIME 1000 // 1000 milliseconds #define LONG_PRESS_TIME 1000 // 1000 milliseconds ezButton button(21); // create ezButton object for pin Arduino Nano ESP32 pin GPIO21 unsigned long pressed_time = 0; unsigned long released_time = 0; bool is_pressing = false; bool is_long_detected = false; void setup() { Serial.begin(115200); button.setDebounceTime(50); // set debounce time to 50 milliseconds } void loop() { button.loop(); // MUST call the loop() function first if (button.isPressed()) { pressed_time = millis(); is_pressing = true; is_long_detected = false; } if (button.isReleased()) { is_pressing = false; released_time = millis(); long press_duration = released_time - pressed_time; 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() - pressed_time; if ( press_duration > LONG_PRESS_TIME ) { Serial.println("A long press is detected"); is_long_detected = true; } } }

Schnelle Schritte

  1. Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  3. Bibliothek installieren: Installieren Sie die ezButton-Bibliothek – siehe Anleitung
  4. Code hochladen: Laden Sie den Code über die Arduino IDE auf Ihren ESP32 S3 hoch
  5. Zuverlässigkeit testen: Drücken Sie den Taster mehrmals – es gibt keine doppelten Messwerte
  6. Methoden vergleichen: Dies ist die zuverlässigste Methode für ESP32 S3 Serienprojekte
  7. Profi-Tipp: Verwenden Sie diese Methode für kritische Anwendungen wie Geräte-Resets oder wichtige Bedienelemente, bei denen Genauigkeit entscheidend ist
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[00:07:31.447] A short press is detected [00:07:34.922] A long press is detected [00:07:36.250] A short press is detected [00:07:39.788] A long press is detected
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

Warum langer und kurzer Druck nützlich sind

Wenn Sie Ihren ESP32 S3 Projekten eine Erkennung mehrerer Druckarten hinzufügen, erhalten Sie mehr Funktionen aus einem einzigen Taster, ohne die Hardware komplexer zu machen.

  1. Pins sparen: Ein einziger Taster kann zwei oder mehr Funktionen steuern (kurzer Druck für Licht, langer Druck für Ventilator)
  2. Unfälle vermeiden: Verwenden Sie einen langen Druck für kritische Funktionen wie den Werksreset, um versehentliches Auslösen zu verhindern
  3. Bessere Bedienbarkeit: Benutzer können mehrere Aktionen ohne zusätzliche Hardware ausführen
  4. Kostenersparnis: Weniger Taster bedeuten einfachere Schaltungen und geringere Bauteilkosten
  5. Platzsparend: Ideal für kompakte ESP32 S3 Projekte mit wenig Platz
  6. Professionelles Design: Multifunktionstaster sind Standard in der Unterhaltungselektronik

Anwendungsideen

Die Erkennung langer und kurzer Drücke eröffnet viele praktische Anwendungsfälle für Ihre ESP32 S3 Projekte.

  1. Smart-Home-Lichtsteuerung: kurzer Druck für Ein/Aus, langer Druck für den Dimmmodus
  2. Alarmanlage: kurzer Druck zum Scharf-/Unscharfschalten, langer Druck für den Panikmodus
  3. Timer-Gerät: kurzer Druck zum Starten/Stoppen, langer Druck zum Zurücksetzen
  4. Multifunktions-Thermostat: kurzer Druck passt die Temperatur an, langer Druck wechselt zwischen Heiz- und Kühlmodus
  5. IoT-Türschloss: kurzer Druck zum vorübergehenden Entriegeln, langer Druck für dauerhaftes Entriegeln
  6. Batteriebetriebener Sensor: kurzer Druck zum Prüfen des Status, langer Druck zum Wechsel in den Tiefschlafmodus

Video Section

Sehen Sie sich unten die Schritt-für-Schritt-Videoanleitung für dieses ESP32 S3 Projekt an.

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 © 2026 Newbiely.de. Alle Rechte vorbehalten.
Allgemeine Geschäftsbedingungen | Datenschutzrichtlinie
Email: newbiely.com@gmail.com