Arduino - Taste - Langer Druck Kurzer Druck

Bereit, das versteckte Potenzial einer einfachen Taste zu entschlüsseln? Sie sind hier genau richtig! Dieses Arduino Mega Tasten-Tutorial führt Sie durch alles, was Sie über die Erkennung von langen und kurzen Tastendrücken wissen müssen - eine Fähigkeit, die dramatisch erweitert, was Sie mit Ihren Arduino-Projekten machen können.

Denken Sie an Ihr Smartphone oder jedes moderne Gerät - eine einzige Taste kann mehrere Funktionen ausführen, je nachdem, wie Sie sie drücken. Kurzer Druck für eine Aktion, langer Druck für eine andere. Heute bringen wir genau diese intelligente Funktionalität in Ihre Arduino Mega Projekte! Egal, ob Sie gerade mit der Arduino-Programmierung anfangen oder erweiterte Benutzerinteraktionen zu Ihren bestehenden Projekten hinzufügen möchten, dieser umfassende Leitfaden deckt alles ab.

In diesem Tutorial meistern Sie vier wesentliche Techniken: die Erkennung kurzer Tastendrücke, das Erkennen langer Drücke, die Kombination beider Erkennungsmethoden und die Implementierung ordnungsgemäßer Entprellung für Zuverlässigkeit in der realen Welt. Machen Sie sich keine Sorgen, wenn Sie neu in der Programmierung sind - wir gehen alles Schritt für Schritt durch und erklären nicht nur das "Wie", sondern auch das "Warum" hinter jedem Konzept. Am Ende werden Sie verstehen, wie Sie responsive, professionelle Tasten-Interfaces erstellen, die zwischen schnellen Berührungen und bewussten langen Drücken unterscheiden können.

Die praktischen Anwendungsmöglichkeiten sind endlos! Sie könnten einen Smart-Home-Controller bauen, bei dem kurze Drücke durch Modi schalten und lange Drücke Geräte ein-/ausschalten, eine digitale Uhr erstellen, bei der kurze Drücke die Anzeige ändern und lange Drücke die Zeit einstellen, oder ein Sicherheitssystem entwerfen, bei dem nur ein langer Druck (um versehentliche Auslösung zu verhindern) den Alarm aktiviert. Welches fantastische Projekt werden Sie zuerst erstellen?

Wir werden lernen:

In den ersten drei Abschnitten erkunden wir die grundlegenden Prinzipien der Tastendruck-Erkennung und bauen Ihr Verständnis Schritt für Schritt auf. Im letzten Abschnitt implementieren wir praktische, reale Lösungen mit Entprellungstechniken. Das ist entscheidend, denn ohne ordnungsgemäße Entprellung könnten Sie falsche Messwerte erhalten - siehe warum wir Entprellung für Tasten benötigen für eine detaillierte Erklärung. Denken Sie an Entprellung als Feinabstimmung der "Ohren" Ihres Arduino, damit er klar zwischen beabsichtigten Tastendrücken und elektrischem Rauschen unterscheiden kann.

Erforderliche Hardware

1×Arduino Mega
1×USB 2.0 Kabel Typ A/B
1×Breadboard-montierte Taste mit Kappe
1×Breadboard-montiertes Tasten-Kit
1×Panel-montierter Drucktaster
1×Taster-Modul
1×Breadboard (Steckplatine)
1×Jumper-Kabel
1×(Empfohlen) Screw Terminal Block Shield for Arduino Uno/Mega
1×(Empfohlen) Breadboard Shield for Arduino Mega
1×(Empfohlen) Enclosure for Arduino Mega

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 Tasten

Eine Taste ist ein einfaches, aber unglaublich vielseitiges Eingabegerät, das es Benutzern ermöglicht, digitale Signale an Ihr Arduino Mega zu senden, indem sie sie physisch drücken und loslassen. Denken Sie daran wie an eine Brücke, die Sie öffnen und schließen können, um den Stromfluss in Ihrem Schaltkreis zu steuern. Wenn gedrückt, entsteht eine Verbindung; wenn losgelassen, wird diese Verbindung unterbrochen.

Das Verständnis des Tastenverhaltens ist grundlegend für die Erstellung interaktiver Arduino-Projekte. Tasten können verschiedene Arten von Benutzerinteraktionen erkennen - von einfachen Ein/Aus-Zuständen bis zu komplexen Druckmustern wie den langen und kurzen Drücken, die wir heute erkunden. Der Schlüssel zur Beherrschung der Tastensteuerung liegt im Verständnis von Timing, Zustandsänderungen und wie diese Änderungen in Ihrem Code interpretiert werden.

Was Tasten in der Arduino-Programmierung besonders kraftvoll macht, ist ihre Fähigkeit, Ereignisse basierend auf Benutzerabsicht auszulösen. Ein kurzer Druck könnte eine schnelle Auswahl oder Modusänderung anzeigen, während ein langer Druck eine bewusstere Aktion wie das Ausschalten eines Geräts oder die Bestätigung einer kritischen Operation signalisieren könnte. Diese Vielseitigkeit macht eine einzige Taste fähig, mehrere Funktionen zu steuern, wodurch sowohl Hardware-Kosten als auch physischer Platz in Ihren Projekten gespart werden.

Falls Sie nicht über die Grundlagen von Tasten Bescheid wissen (Pinout, Funktionsweise, Programmierung grundlegender Tastenfunktionen), empfehlen wir dringend, mit unserem umfassenden Tasten-Grundlagen-Leitfaden zu beginnen. Dieses Hintergrundwissen wird alles in diesem Tutorial viel klarer und sinnvoller machen:

Schaltbild

Schauen wir uns die Verkabelung an - keine Sorge, es ist einfacher als es aussieht! Das Verständnis dieser Verbindungen ist der Schlüssel für eine reibungslose Funktionsweise Ihrer Tastendruck-Erkennung.

Arduino Tasten-Schaltbild

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

In diesem Tutorial verwenden wir den internen Pull-up-Widerstand des Arduino Mega, ein praktisches eingebautes Feature, das Sie vor der Notwendigkeit externer Komponenten bewahrt. Das bedeutet, der Tasten-Pin liest HIGH (5V), wenn sich die Taste in ihrem normalen, nicht gedrückten Zustand befindet, und LOW (0V), wenn Sie sie herunterdrücken. Denken Sie an den internen Pull-up-Widerstand als sanftes "Ziehen" des Pins zu einem HIGH-Zustand, wenn nichts anderes verbunden ist - es ist wie eine Standardeinstellung, die verhindert, dass der Pin in einem undefinierten Zustand schwebt.

Tasten-Pin Arduino Mega Pin
Ein Anschluss Digital Pin 2
Anderer Anschluss GND (Masse)

Wichtiger Hinweis: Die Verwendung des internen Pull-up-Widerstands bedeutet, dass Ihre Tastenlogik im Vergleich zu dem, was Sie möglicherweise zunächst erwarten, invertiert ist. Gedrückt = LOW, Losgelassen = HIGH. Das ist völlig normal und tatsächlich die bevorzugte Methode für Tastenverbindungen in den meisten Arduino-Projekten, weil sie zuverlässiger ist und weniger Komponenten benötigt.

Wie man kurze Drücke erkennt

Jetzt zum aufregenden Teil - lassen Sie uns Ihre Taste mit intelligenter Druckerkennung zum Leben erwecken! Machen Sie sich keine Sorgen, wenn Sie neu in der zeitbasierten Programmierung sind; wir gehen dieses Konzept Schritt für Schritt durch, und ich verspreche, es ist einfacher als Sie denken.

Das Schlüsselprinzip der Kurzdruck-Erkennung ist die Messung der Zeitdauer. Wir erstellen im Wesentlichen eine Stoppuhr, die startet, wenn die Taste gedrückt wird, und stoppt, wenn sie losgelassen wird. Wenn diese Dauer unter unseren definierten Schwellenwert fällt (sagen wir 500 Millisekunden), wissen wir, dass der Benutzer einen schnellen, kurzen Druck beabsichtigte und nicht ein bewusstes langes Halten.

Lassen Sie uns den Erkennungsprozess in handhabbare Schritte aufteilen:

Wir messen die Zeitdauer zwischen den gedrückten und losgelassenen Ereignissen mit Arduinos eingebauter millis()-Funktion, die Millisekunden seit Programmstart zählt. Wenn die Dauer kürzer als unser vordefinierter Zeitschwellenwert ist, haben wir erfolgreich ein Kurzdruck-Ereignis erkannt. Denken Sie daran wie an die Messung, wie lange jemand einen Händedruck hält - ein schneller Händedruck im Vergleich zu einem anhaltenden Griff sagt Ihnen verschiedene Dinge über deren Absicht!

Sehen wir uns die schrittweise Implementierung an:

  • Definieren Sie den Kurzdruck-Dauerschwellenwert - Dies legt die maximale Zeit fest, die als "kurzer" Druck qualifiziert:
const int SHORT_PRESS_TIME = 500; // 500 Millisekunden
  • Erkennen, wann die Taste zuerst gedrückt wird und diesen Moment festhalten:
if(lastState == HIGH && currentState == LOW) pressedTime = millis();
  • Erkennen, wann die Taste losgelassen wird und die Loslasszeit aufzeichnen:
if(lastState == LOW && currentState == HIGH) releasedTime = millis();
  • Die gesamte Druckdauer berechnen durch Ermittlung der Differenz:
long pressDuration = releasedTime - pressedTime;
  • Bestimmen, ob es ein kurzer Druck ist durch Vergleich der Dauer mit unserem Schwellenwert:
if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected");

Arduino Code für die Erkennung kurzer Drücke

/* * Dieser Arduino Mega Code wurde von newbiely.de entwickelt * Dieser Arduino Mega 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/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int SHORT_PRESS_TIME = 500; // 500 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) // button is pressed pressedTime = millis(); else if(lastState == LOW && currentState == HIGH) { // button is released releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); } // save the the last state lastState = currentState; }

Schnelle Schritte

Neu bei Arduino? Keine Sorge! Beginnen Sie mit unserem Arduino Getting Started Leitfaden, um zuerst die Grundlagen zu lernen.

  • Code hochladen: Kopieren Sie den obigen Code in Ihre Arduino IDE und laden Sie ihn auf Ihr Arduino Mega hoch. Lassen Sie sich Zeit mit dem Upload-Prozess - es gibt keine Eile!
  • Kurze Drücke testen: Drücken Sie die Taste schnell mehrmals (weniger als eine halbe Sekunde pro Mal). Probieren Sie verschiedene Geschwindigkeiten aus, um ein Gefühl dafür zu bekommen, was als "kurz" qualifiziert.
  • Ergebnisse überwachen: Öffnen Sie Ihren Serial Monitor (Tools → Serial Monitor) und achten Sie auf Erkennungsmeldungen. Sie sollten Bestätigungen sehen, jedes Mal wenn ein kurzer Druck erkannt wird.

Profi-Tipp: Versuchen Sie, mit verschiedenen SHORT_PRESS_TIME-Werten zu experimentieren, um herauszufinden, was sich für Ihr spezifisches Projekt am natürlichsten anfühlt. Einige Anwendungen benötigen möglicherweise schnellere Antworten (200ms), während andere etwas längere Schwellenwerte bevorzugen (800ms).

COM6
Send
A short press is detected A short press is detected A short press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

※ Notiz:

Der Serial Monitor kann mehrere Kurzdruck-Erkennungen für einen Druck anzeigen. Das ist das normale Verhalten von Tasten aufgrund des sogenannten "Prellphänomens" - winzige elektrische Sprünge, die auftreten, wenn Metallkontakte Verbindungen herstellen und unterbrechen. Machen Sie sich vorerst keine Sorgen darüber; wir werden dieses Problem im Entprellungsabschnitt am Ende dieses Tutorials vollständig lösen. Denken Sie daran als Feinabstimmung, die wir angehen werden, sobald Sie die Kernkonzepte verstehen!

Wie man lange Drücke erkennt

Die Erkennung langer Drücke eröffnet eine völlig neue Welt von Benutzeroberflächen-Möglichkeiten! Es gibt tatsächlich zwei verschiedene Ansätze, die wir verfolgen können, die jeweils unterschiedlichen Zwecken dienen, je nach den Bedürfnissen Ihres Projekts. Lassen Sie mich Sie durch beide Methoden führen, damit Sie diejenige wählen können, die am besten zu Ihrer kreativen Vision passt.

Das Verständnis des Unterschieds zwischen diesen Ansätzen ist entscheidend für die Erstellung responsiver Benutzeroberflächen. Die erste Methode wartet geduldig, bis der Benutzer seine Interaktion vollständig beendet (die Taste loslässt), bevor sie Entscheidungen trifft. Die zweite Methode ist proaktiver und erkennt den langen Druck während er geschieht und reagiert sofort. Beide haben ihren Platz in verschiedenen Anwendungstypen!

Es gibt zwei praktische Anwendungsfälle für die Erkennung von Langdruck-Ereignissen:

  • Erkennung nach dem Loslassen: Das Langdruck-Ereignis wird direkt nach dem Loslassen der Taste erkannt - perfekt für Bestätigungen und abschließende Aktionen
  • Erkennung während des Drückens: Das Langdruck-Ereignis wird erkannt, während die Taste noch gehalten wird - ideal für Echtzeit-Feedback und kontinuierliche Aktionen

Im ersten Anwendungsfall messen wir die vollständige Zeitdauer zwischen den gedrückten und losgelassenen Ereignissen, ähnlich unserer Kurzdruck-Methode, aber mit einem längeren Schwellenwert. Wenn die gesamte Dauer unsere definierte Zeitgrenze überschreitet, wissen wir, dass der Benutzer eine Langdruck-Aktion beabsichtigte.

Im zweiten Anwendungsfall verfolgen wir einen dynamischeren Ansatz. Nachdem die Taste anfangs gedrückt wurde, überwachen wir kontinuierlich die Druckdauer in Echtzeit und prüfen wiederholt auf die Langdruck-Bedingung, bis die Taste losgelassen wird. Dies ermöglicht es uns, sofort zu reagieren, wenn der Langdruck-Schwellenwert erreicht wird, selbst während der Benutzer die Taste noch hält. Denken Sie daran wie an eine Fortschrittsleiste, die eine Aktion auslöst, sobald sie sich füllt, anstatt darauf zu warten, dass der Benutzer loslässt.

Arduino Code für die Erkennung langer Drücke beim Loslassen

/* * Dieser Arduino Mega Code wurde von newbiely.de entwickelt * Dieser Arduino Mega 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/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) // button is pressed pressedTime = millis(); else if(lastState == LOW && currentState == HIGH) { // button is released releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration > LONG_PRESS_TIME ) Serial.println("A long press is detected"); } // save the the last state lastState = currentState; }

Schnelle Schritte

Haben Sie Arduino noch nicht verwendet? Werfen Sie einen kurzen Blick auf unseren Arduino Getting Started Leitfaden, um Ihr Fundament zu bauen.

  • Hochladen und testen: Laden Sie den obigen Code auf Ihr Arduino Mega über die Arduino IDE hoch. Diese Methode erfordert Geduld - Sie müssen die Taste für die volle Dauer halten!
  • Lange Drücke üben: Drücken und halten Sie die Taste für mehr als eine Sekunde, dann lassen Sie sie los. Beachten Sie, wie die Erkennung nur geschieht, nachdem Sie losgelassen haben.
  • Das Timing beobachten: Überprüfen Sie die Serial Monitor Ergebnisse. Sie werden sehen, dass das Langdruck-Ereignis nur direkt nach dem Loslassen der Taste erkannt wird, nicht während des Drückens.

Profi-Tipp: Diese Methode ist perfekt für Aktionen, die Bestätigung erfordern, wie "Sind Sie sicher, dass Sie das löschen möchten?" Szenarien. Der Benutzer muss die gesamte Langdruck-Geste vollenden, bevor etwas passiert.

COM6
Send
A long press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Das Langdruck-Ereignis wird nur direkt nach dem Loslassen der Taste erkannt

Arduino Code für die Erkennung langer Drücke während des Drückens

/* * Dieser Arduino Mega Code wurde von newbiely.de entwickelt * Dieser Arduino Mega 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/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; bool isPressing = false; bool isLongDetected = false; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) { // button is pressed pressedTime = millis(); isPressing = true; isLongDetected = false; } else if(lastState == LOW && currentState == HIGH) { // button is released isPressing = false; } if(isPressing == true && isLongDetected == false) { long pressDuration = millis() - pressedTime; if( pressDuration > LONG_PRESS_TIME ) { Serial.println("A long press is detected"); isLongDetected = true; } } // save the the last state lastState = currentState; }

Schnelle Schritte

Arbeiten Sie zum ersten Mal mit Arduino? Wir empfehlen, einen Blick auf unseren Arduino Getting Started Leitfaden zu werfen - er wird alles verständlich machen!

  • Hochladen und erleben: Laden Sie diesen Code hoch und bemerken Sie den sofortigen Unterschied in der Responsivität. Die Erkennung geschieht, während Sie die Taste noch halten!
  • Echtzeit-Erkennung testen: Drücken und halten Sie die Taste mehrere Sekunden lang, ohne loszulassen. Sie sollten die Erkennungsmeldung erscheinen sehen, während Ihr Finger noch auf der Taste ist.
  • Den Unterschied spüren: Dieser Ansatz bietet sofortiges Feedback und lässt Ihre Projekte responsiver und professioneller wirken.

Profi-Tipp: Diese Methode ist ausgezeichnet für Aktionen wie "halten zum Ausschalten" oder "drücken und halten, um den Setup-Modus zu betreten", wo sofortiges Feedback den Benutzer beruhigt, dass etwas passiert.

COM6
Send
A long press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Das Langdruck-Ereignis wird sofort erkannt, wenn der Schwellenwert erreicht wird, selbst während die Taste noch gedrückt wird

Wie man sowohl lange als auch kurze Drücke erkennt

Jetzt kommen wir zum wirklich aufregenden Teil! Die Kombination von langer und kurzer Druckerkennung verwandelt eine einfache Taste in ein hochentwickeltes Benutzeroberflächenelement. Hier beginnen Ihre Projekte, sich wie professionelle Geräte mit intuitiven, multifunktionalen Steuerungen anzufühlen.

Die Schönheit der dualen Erkennung liegt in der Maximierung der Funktionalität bei gleichzeitiger Minimierung der Hardware. Anstatt mehrere Tasten für verschiedene Aktionen zu benötigen, kann eine einzige Taste zwei verschiedene Funktionen basierend auf der Benutzerabsicht handhaben. Kurzer Druck für schnelle Aktionen, langer Druck für bewusstere oder kritische Funktionen - genau wie die Einschalttaste Ihres Smartphones oder die Steuerungen moderner Geräte!

Kurzer Druck und langer Druck nach dem Loslassen

Dieser Ansatz wartet, bis die Tasten-Interaktion vollständig beendet ist, bevor er Entscheidungen trifft. Es ist, als würde man jemanden seinen Satz beenden lassen, bevor man antwortet - sehr höflich und bewusst!

/* * Dieser Arduino Mega Code wurde von newbiely.de entwickelt * Dieser Arduino Mega 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/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) // button is pressed pressedTime = millis(); else if(lastState == LOW && currentState == HIGH) { // button is released releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); if( pressDuration > LONG_PRESS_TIME ) Serial.println("A long press is detected"); } // save the the last state lastState = currentState; }

Schnelle Schritte

  • Hochladen und experimentieren: Laden Sie den obigen Code auf Ihr Arduino Mega hoch und beginnen Sie mit verschiedenen Druckdauern zu experimentieren. Probieren Sie schnelle Berührungen und längere Haltevorgänge aus, um zu sehen, wie das System zwischen ihnen unterscheidet.
  • Beide Typen testen: Üben Sie sowohl lange als auch kurze Drücke, um ein Gefühl für das Timing zu bekommen. Beachten Sie, wie das System wartet, bis Sie die Taste loslassen, bevor es entscheidet, welcher Drucktyp es war.
  • Duale Erkennung überwachen: Beobachten Sie den Serial Monitor, um zu sehen, wie Ihr Arduino Mega intelligent jede Tasten-Interaktion kategorisiert.

Profi-Tipp: Diese Methode ist perfekt für Anwendungen, bei denen Sie versehentliche Auslösung vermeiden möchten. Da nichts passiert, bis die Taste losgelassen wird, können Benutzer ihre Meinung während des Drückens ändern!

COM6
Send
A short press is detected A long press is detected A short press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

※ Notiz:

Der Serial Monitor kann mehrere Kurzdruck-Erkennungen während Langdruck-Versuchen anzeigen. Das ist das normale Verhalten von Tasten aufgrund des "Prellphänomens" - winzige elektrische Sprünge, die in den mechanischen Kontakten der Taste auftreten. Keine Sorge! Das ist völlig normal und erwartet. Wir werden dieses Problem im kommenden Entprellungsabschnitt vollständig lösen, wo wir professionelle Tastenhandhabung implementieren werden.

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

Dieser dynamische Ansatz bietet sofortiges Feedback in dem Moment, in dem ein Langdruck-Schwellenwert erreicht wird, während er immer noch kurze Drücke erkennt, wenn die Taste schnell losgelassen wird. Es ist, als hätte man das Beste aus beiden Welten!

/* * Dieser Arduino Mega Code wurde von newbiely.de entwickelt * Dieser Arduino Mega 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/arduino-mega/arduino-mega-button-long-press-short-press */ // constants won't change. They're used here to set pin numbers: const int BUTTON_PIN = 7; // the number of the pushbutton pin const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds // Variables will change: int lastState = LOW; // the previous state from the input pin int currentState; // the current reading from the input pin unsigned long pressedTime = 0; unsigned long releasedTime = 0; bool isPressing = false; bool isLongDetected = false; void setup() { Serial.begin(9600); pinMode(BUTTON_PIN, INPUT_PULLUP); } void loop() { // read the state of the switch/button: currentState = digitalRead(BUTTON_PIN); if(lastState == HIGH && currentState == LOW) { // button is pressed pressedTime = millis(); isPressing = true; isLongDetected = false; } else if(lastState == LOW && currentState == HIGH) { // button is released isPressing = false; releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); } if(isPressing == true && isLongDetected == false) { long pressDuration = millis() - pressedTime; if( pressDuration > LONG_PRESS_TIME ) { Serial.println("A long press is detected"); isLongDetected = true; } } // save the the last state lastState = currentState; }

Schnelle Schritte

  • Echtzeit-Antwort erleben: Laden Sie diesen Code hoch und spüren Sie den Unterschied in der Responsivität. Lange Drücke werden sofort erkannt, während kurze Drücke beim Loslassen erfasst werden.
  • Das Timing üben: Probieren Sie verschiedene Druckdauern aus, um zu verstehen, wie das System reagiert. Sie werden bemerken, dass Langdruck-Feedback sofort erfolgt, während Kurzdruck-Feedback auf das Loslassen wartet.
  • Die Raffinesse schätzen: Dieser Ansatz schafft eine sehr professionelle Benutzererfahrung mit sofortigem visuellem oder akustischem Feedback für lange Drücke.

Profi-Tipp: Diese Methode ist ausgezeichnet für Projekte, bei denen Langdruck-Aktionen sofortige Bestätigung oder Feedback benötigen, wie "halten zum Aktivieren" Szenarien, wo Benutzer wissen müssen, dass ihr Befehl verarbeitet wird.

COM6
Send
A long press is detected A short press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

※ Notiz:

Sie könnten einige zusätzliche Kurzdruck-Erkennungen während Langdruck-Operationen bemerken. Das ist völlig normales Tastenverhalten, genannt das "Prellphänomen". Denken Sie daran als die mechanischen Kontakte der Taste, die leicht springen, wenn sie Verbindung herstellen oder unterbrechen. Die gute Nachricht? Wir werden das im nächsten Abschnitt mit professionellen Entprellungstechniken vollständig beheben!

Langer und kurzer Druck mit Entprellung

Hier verwandeln wir Ihre Tastenhandhabung von Lernbeispielen in professionellen, produktionsreifen Code! Entprellung ist absolut entscheidend für reale Anwendungen - es ist der Unterschied zwischen einem Hobby-Projekt und einem zuverlässigen, kommerziellen Gerät.

Tasten-Entprellung mag kompliziert klingen, aber denken Sie daran, Ihrem Arduino beizubringen, "aufmerksam zuzuhören", anstatt auf jedes winzige elektrische Rauschen zu reagieren. Wenn Sie eine physische Taste drücken, stellen die Metallkontakte nicht sofort eine perfekte, saubere Verbindung her. Stattdessen "springen" sie - sie stellen und unterbrechen schnell die Verbindung für ein paar Millisekunden. Ohne Entprellung könnte Ihr Arduino einen Tastendruck als mehrere Drücke interpretieren, was zu frustrierendem und unvorhersagbarem Verhalten führt.

Die gute Nachricht ist, dass Entprellung nicht überwältigend sein muss, besonders bei der Verwendung mehrerer Tasten oder komplexer Timing-Szenarien. Um das für Anfänger (und auch erfahrene Entwickler!) viel einfacher zu machen, verwenden wir eine fantastische Bibliothek namens ezButton. Diese Bibliothek übernimmt das gesamte komplizierte Timing und Zustandsmanagement im Hintergrund, sodass Sie sich darauf konzentrieren können, fantastische Projekte zu bauen, anstatt mit Low-Level-Tastenmechanik zu kämpfen.

Denken Sie an die ezButton-Bibliothek als Ihren geschickten Assistenten, der jeden Tastendruck perfekt interpretiert, das elektrische Rauschen herausfiltert und nur die sauberen, beabsichtigten Benutzerinteraktionen liefert, auf die Sie tatsächlich reagieren möchten. Es ist, als hätten Sie einen professionellen Übersetzer, der sicherstellt, dass bei der Kommunikation nichts verloren geht!

Kurzer und langer Druck mit Entprellung nach dem Loslassen

Diese Implementierung bietet felsenfeste Zuverlässigkeit, indem sie auf vollständige Benutzerinteraktion wartet, bevor sie Entscheidungen trifft, kombiniert mit professioneller Entprellung für perfekte Genauigkeit jedes Mal.

/* * Dieser Arduino Mega Code wurde von newbiely.de entwickelt * Dieser Arduino Mega 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/arduino-mega/arduino-mega-button-long-press-short-press */ #include <ezButton.h> const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds ezButton button(7); // create ezButton object that attach to pin 7; unsigned long pressedTime = 0; unsigned long releasedTime = 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()) pressedTime = millis(); if(button.isReleased()) { releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); if( pressDuration > LONG_PRESS_TIME ) Serial.println("A long press is detected"); } }

Schnelle Schritte

  • ezButton-Bibliothek installieren: Installieren Sie zuerst die ezButton-Bibliothek in Ihrer Arduino IDE. Siehe die detaillierte Installationsanleitung, falls Sie Hilfe bei der Bibliotheksinstallation benötigen - keine Sorge, es ist einfach!
  • Hochladen und Zuverlässigkeit testen: Laden Sie den obigen Code hoch und bemerken Sie sofort den Unterschied! Keine falschen Erkennungen oder unregelmäßiges Verhalten mehr - jeder Tastendruck wird genau so interpretiert, wie Sie es beabsichtigt haben.
  • Professionelle Qualität erleben: Probieren Sie schnelle Drücke, sanfte Berührungen und feste Haltevorgänge aus. Die entprellte Version behandelt alles reibungslos und vorhersagbar.

Profi-Tipp: Sobald Sie entprellte Tastenhandhabung erleben, werden Sie nie wieder zu grundlegenden Erkennungsmethoden zurückkehren wollen. Das ist die Grundlage professioneller Arduino-Projektentwicklung!

COM6
Send
A short press is detected A long press is detected A short press is detected A long press is detected
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

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

Diese erweiterte Implementierung kombiniert Echtzeit-Langdruck-Erkennung mit kugelsicherer Entprellung und schafft die responsivste und zuverlässigste Tasten-Schnittstelle, die möglich ist.

/* * Dieser Arduino Mega Code wurde von newbiely.de entwickelt * Dieser Arduino Mega 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/arduino-mega/arduino-mega-button-long-press-short-press */ #include <ezButton.h> const int SHORT_PRESS_TIME = 1000; // 1000 milliseconds const int LONG_PRESS_TIME = 1000; // 1000 milliseconds ezButton button(7); // create ezButton object that attach to pin 7; unsigned long pressedTime = 0; unsigned long releasedTime = 0; bool isPressing = false; bool isLongDetected = 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()){ pressedTime = millis(); isPressing = true; isLongDetected = false; } if(button.isReleased()) { isPressing = false; releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration < SHORT_PRESS_TIME ) Serial.println("A short press is detected"); } if(isPressing == true && isLongDetected == false) { long pressDuration = millis() - pressedTime; if( pressDuration > LONG_PRESS_TIME ) { Serial.println("A long press is detected"); isLongDetected = true; } } }

Schnelle Schritte

  • Bibliotheksinstallation sicherstellen: Stellen Sie sicher, dass Sie die ezButton-Bibliothek installiert haben. Überprüfen Sie die Installationsanleitung, falls nötig - Sie schaffen das!
  • Hochladen und den Unterschied spüren: Laden Sie diesen Code hoch und erleben Sie das Ultimative in Tasten-Responsivität. Lange Drücke bieten sofortiges Feedback bei perfekter Genauigkeit.
  • Umfassend testen: Probieren Sie alle Arten von Tasten-Interaktionen aus - schnelle Berührungen, lange Haltevorgänge, unterschiedlichen Druck. Jetzt funktioniert alles einwandfrei!

Profi-Tipp: Das ist der Goldstandard für interaktive Arduino-Projekte.

※ 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!