Programmieren einer Taste in Arduino. Anschließen eines Buttons an Arduino. Anschließen eines Tasters über eine Pull-Up-Widerstandsschaltung

Wird sehr häufig in der Elektronik verwendet. Auf den ersten Blick birgt die Zusammenarbeit mit ihnen keine Überraschungen, doch auch hier gibt es Fallstricke.

Obwohl der Knopf vier Beine hat, kann er tatsächlich als zwei Stromkreisabschnitte betrachtet werden, die oben abschließen. Stellen Sie sicher, dass der Anschluss korrekt ist, damit die Schaltung korrekt ist.

Lassen Sie uns den Knopf anschließen, ohne einen Controller zu verwenden, indem wir Strom leiten 5V. Wenn Sie die Taste drücken, wird der Stromkreis geschlossen und die LED leuchtet auf. Nichts Unerwartetes.

In Wirklichkeit müssen wir das Signal des Knopfes lesen und darauf reagieren. Versuchen wir daher, das Schema zu ändern. Verbinden wir einen Pin des Knopfes mit der Stromversorgung und Pin 3 auf der Platine. Von Pin 3 lesen wir Informationen: logische Null oder logische Eins. Wenn Sie die Taste drücken, wird der Stromkreis geschlossen, Pin 3 hat eine logische Eins und wir schalten die LED ein.

Int buttonPin = 12; int ledPin = 3; void setup() ( pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT); ) void loop() ( bool val = digitalRead(buttonPin); digitalWrite(ledPin, val); )

Der Code funktioniert einwandfrei, wenn auf die Schaltfläche geklickt wird. Und wenn wir den Knopf loslassen und den Stromkreis unterbrechen, entsteht ein Problem. Pin 12 wird frei und bleibt im Modus in einem unbestimmten Zustand hängen EINGANG(Erinnern Sie sich an die Lektion über digitale Ausgänge). Als Ergebnis erhalten wir zufällige Werte und die LED schaltet sich aufgrund von Störungen ein und aus.

Um dieses Problem zu vermeiden, können Sie einen Widerstand von 10 bis 100 kOhm hinzufügen und den Knopf auf Masse drücken. In diesem Fall bleibt der Stromkreis auch beim Loslassen der Taste geschlossen. In diesem Fall wird der Widerstand als Pull-Down bezeichnet. Dies ist ein Arbeitsdiagramm, das im Lehrplan verwendet werden kann.

Trotz der funktionierenden Schaltung mit Pull-Down-Widerstand bekommen wir bei der Arbeit an einem komplexen Projekt ein Problem. Tatsache ist, dass es möglich ist, dass viele Geräte im Stromkreis unterschiedliche Leistungswerte verwenden. Und dann müssen Sie jede Taste des Geräts mit einem eigenen separaten Pulldown-Widerstand versorgen. In der Praxis ist es üblich, nicht an die Stromversorgung, sondern an die Masse anzuschließen, die immer gleich und gleich 0 ist. In diesem Fall sollte der Widerstand selbst an die Stromversorgung angeschlossen werden – hochgezogen. Der Widerstand ist in diesem Fall ein Pull-up. Es tritt jedoch ein weiteres Problem auf: Das Verhalten der LED hat sich in die entgegengesetzte Richtung geändert. Beim Drücken erlischt die LED, beim Loslassen schaltet sie sich ein. Das Problem kann einfach durch die Änderung einer Codezeile gelöst werden.

DigitalWrite(ledPin, !val);

Wir ändern einfach den Wert der Variablen in das Gegenteil. Dies ist der Standardansatz beim Arbeiten mit einer Schaltfläche. Jetzt wird es für Sie einfacher, die Beispiele aus der Arduino IDE zu verstehen.

Es ist erwähnenswert, dass die Pins des Arduino-Boards bereits über integrierte Pull-up-Widerstände verfügen (außer Pin 13) und wir den externen Widerstand entfernen können. Dann müssen Sie die Verwendung dieses Widerstands aber auch explizit per Code mit dem Parameter angeben INPUT_PULLUP.

Int buttonPin = 12; int ledPin = 3; void setup() ( pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT_PULLUP); ) void loop() ( bool val = digitalRead(buttonPin); digitalWrite(ledPin, !val); delay(100); )

01.Grundlagen: DigitalReadSerial

Schauen wir uns ein Beispiel an DigitalReadSerial aus Datei | Beispiele | 01.Grundlagen.

Wir haben gelernt, wie man einen Knopf richtig anschließt und können die eingebauten Beispiele studieren. Wir werden das Signal lesen, das vom digitalen Ausgang kommt, wenn die Taste gedrückt wird.

Ein grob zusammengesetztes Diagramm könnte so aussehen:

Ich werde dieses Schema kurz in Worten beschreiben. Wir stecken einen Knopf in die Mitte des Steckbretts, sodass die Steckbrettnut zwischen den beiden Beinen verläuft. Als nächstes schließen Sie das Netzteil mit Jumpern an 5V und Land GND auf einem Arduino mit Schienen auf einem Steckbrett. Dann verbinden wir den digitalen Pin Nummer 2 am Arduino mit einem Jumper mit einem Bein des Knopfes auf dem Steckbrett. Wir verbinden das gleiche Bein des Knopfes, aber auf der anderen Seite mit einem Widerstand, der die Rolle spielt Pull-Down-Widerstand. Danach verbinden wir den Widerstand selbst mit Masse. Wir verbinden den dritten Schenkel des Knopfes mit der positiven Schiene auf dem Steckbrett. Jetzt müssen nur noch die Seitenschienen auf dem Steckbrett miteinander verbunden werden, und schon sind wir bereit, ein neues Beispiel zu studieren.

Der Knopf erfüllt eine sehr wichtige Funktion – er schließt den Stromkreis, wenn er gedrückt wird. Wenn die Taste nicht gedrückt ist, fließt kein Strom zwischen den Beinen der Taste und wir können das Signal vom digitalen Pin Nr. 2 nicht empfangen. Daher wird der Status des Pins vom System als bestimmt NIEDRIG oder 0. Wenn die Taste gedrückt wird, werden ihre beiden Beine verbunden, sodass Strom von der Stromversorgung zum digitalen Pin 2 fließen kann und das System das Durchgangssignal als liest HOCH oder 1.

Lassen Sie uns den Code Stück für Stück aufschlüsseln

// Der zweite Pin ist mit der Schaltfläche verknüpft int pushButton = 2; void setup() ( Serial.begin(9600); pinMode(pushButton, INPUT); ) void loop() ( int buttonState = digitalRead(pushButton); Serial.println(buttonState); delay(1); // Verzögerung für Stabilität )

In Funktion aufstellen() Wir stellen die Kommunikation mit dem Port her, um Daten mit einer Geschwindigkeit von 9600 bps vom Arduino auf Ihren Computer zu lesen: Serial.begin(9600).

Die zweite Zeile ist uns bereits bekannt, der Parameter kommt hier nun zum Einsatz EINGANG- Wir stellen den zweiten digitalen Ausgang so ein, dass er die von der Taste kommenden Daten liest: pinMode(pushButton, INPUT);

In der Schleife lesen wir die eingehenden Informationen. Zuerst brauchen wir eine neue Variable buttonState, das die von der Funktion kommenden Werte 0 oder 1 enthält digitalRead().

Damit wir die eingehenden Informationen sehen können, müssen wir die erhaltenen Ergebnisse mit dem Befehl im Fenster „Serial Monitor“ anzeigen println().

Für mehr Stabilität beim Lesen der Daten stellen wir die Mindestverzögerung ein.

Wenn Sie das Programm jetzt ausführen und auch das Fenster öffnen Serieller Monitor(Speisekarte Werkzeuge | Serieller Monitor), dann sehen Sie endlose Nullen auf dem Bildschirm. Das Programm fragt ständig den Zustand unserer Struktur ab und zeigt das Ergebnis an – kein Strom. Wenn Sie die Taste drücken und gedrückt halten, sehen Sie, dass sich die Zahlen von 0 auf 1 ändern. Dies bedeutet, dass in unserem Stromkreis Strom aufgetaucht ist und sich die Informationen geändert haben.

02.Digital: Taste

Auch das Arbeiten mit einer Schaltfläche wird im Beispiel besprochen Datei | Beispiele | 02.Digital | Taste. Der Taster ist an Pin 2 angeschlossen und die LED ist an Pin 13 angeschlossen. Der Taster sollte außerdem über einen 10K-Widerstand mit Strom und Masse verbunden sein. Das Funktionsprinzip selbst bleibt unverändert. Nur werden wir dieses Mal keine Informationen über den Zustand der Taste auf dem Bildschirm anzeigen, sondern die LED einschalten. Diese Option ist visueller. Wenn Sie die Taste drücken und wieder loslassen, sollte die eingebaute LED aufleuchten oder erlöschen.

Const int buttonPin = 2; // Ausgabe für den Button const int ledPin = 13; // Ausgabe für LED int buttonState = 0; // Tastenstatus – gedrückt oder losgelassen void setup() ( // Ausgabemodus für die LED pinMode(ledPin, OUTPUT); // Eingabemodus für die Taste pinMode(buttonPin, INPUT); ) void loop() ( // read der Zustand der Schaltfläche buttonState = digitalRead(buttonPin); // wenn die Schaltfläche gedrückt wird, dann ist ihr Zustand HIGH: if (buttonState == HIGH) ( // die LED einschalten digitalWrite(ledPin, HIGH); ) else ( // andernfalls die LED ausschalten digitalWrite(ledPin, LOW ); ) )

Nehmen wir an, wir möchten das Verhalten ändern: Wenn die Taste nicht gedrückt wird, leuchtet die LED, und wenn sie gedrückt wird, leuchtet die LED nicht. Es reicht aus, eine Codezeile zu ändern.

Wenn (buttonState == LOW)

Und jetzt das Rätsel! Sie haben die erste Version der Skizze auf die Pinnwand hochgeladen und plötzlich stürzte Ihr Computer ab. Sie können die Skizze nicht bearbeiten, um die zweite Option zu verwenden. Wie kommt man aus dieser Situation heraus?

Sie müssen die Polarität des Stromkreises ändern! Der Draht vom Widerstand, der an Masse geht, muss an 5 V angeschlossen werden, und der Draht, der von 5 V zum Knopf geht, muss an Masse angeschlossen werden. Beim Einschalten fließt der Strom störungsfrei vom Netzteil zu Pin 2 und der Wert wird ermittelt HOCH. Wenn Sie die Taste drücken, wird ein weiterer Stromkreis erstellt und Pin 2 bleibt ohne Strom.

02.Digital: StateChangeDetection

Im Beispiel Datei | Beispiele | 02.Digital | StateChangeDetection Es gibt eine Zählung der Schaltflächenklicks und den Status der Schaltfläche (ein oder aus). Das Schema bleibt gleich. Die Taste ist mit Pin 2 verbunden und die LED ist mit Pin 13 verbunden (Sie können die eingebaute verwenden). Der Taster sollte außerdem an die Stromversorgung und über einen 10K-Pulldown-Widerstand an Masse angeschlossen sein.

Const int buttonPin = 2; // Taste auf Pin 2 const int ledPin = 13; // LED an Pin 13 int buttonPushCounter = 0; // Tastendruckzähler int buttonState = 0; // aktueller Zustand der Schaltfläche int lastButtonState = 0; // Vorheriger Zustand des Buttons void setup() ( // Eingabemodus für den Button festlegen pinMode(buttonPin, INPUT); // Ausgabemodus für die LED festlegen pinMode(ledPin, OUTPUT); // serielle Datenübertragung aktivieren Serial.begin(9600) ; ) void loop() ( // liest die Messwerte vom Button-Ausgang buttonState = digitalRead(buttonPin); // vergleiche den Zustand mit dem vorherigen Zustand if (buttonState != lastButtonState) ( // if the Status hat sich geändert, Zähler erhöhen if (buttonState == HIGH ) ( // wenn der aktuelle Status HIGH ist, dann ist der Button eingeschaltet buttonPushCounter++; Serial.println("on"); Serial.print("Anzahl der Tastendrücke: "); Serial.println(buttonPushCounter); ) else ( // wenn der aktuelle Zustand NIEDRIG ist, was bedeutet, dass die Schaltfläche ausgeschaltet ist Serial.println("off"); ) // eine kleine Verzögerung, um die Verzögerung des Bounce-Effekts zu beseitigen( 50); ) // den aktuellen Zustand als letzten Zustand für das nächste Mal speichern lastButtonState = buttonState; // die LED bei jedem vierten Drücken einschalten und die Division durch den Rest des Druckzählers prüfen if (buttonPushCounter % 4 == 0) ( digitalWrite(ledPin, HIGH); ) else ( digitalWrite(ledPin, LOW); ) )

02.Digital: Debounce

Tasten haben einen Effekt, der „Blinken“ genannt wird. Beim Schließen und Öffnen zwischen den Platten des Knopfes entstehen Mikrofunken, die in wenigen Millisekunden bis zu ein Dutzend Schalter auslösen. Das Phänomen wird als Bounce bezeichnet. Dies muss berücksichtigt werden, wenn „Klicks“ erfasst werden müssen. Daher kann man primären Zeugenaussagen nicht trauen. Aus diesem Grund verzögern sie die Skizzen oft kurz und lesen die Lesungen erst dann. Im Normalzustand, wenn wir die Taste nicht drücken oder gedrückt halten, gibt es keinen Prelleffekt. Manchmal wird die Funktion für diese Zwecke in Bildungsbeispielen verwendet Verzögerung(), aber in der Praxis sollten Sie die Funktion verwenden millis(), wie im Beispiel Datei | Beispiele | 02.Digital | Entprellen. Der Anschlussplan bleibt unverändert.

Const int buttonPin = 2; // Taste auf Pin 2 const int ledPin = 13; // LED an Pin 13 int ledState = HIGH; // aktueller Zustand der LED int buttonState; // aktueller Ausgabestatus für die Schaltfläche int lastButtonState = LOW; // Vorheriger Ausgabestatus für die Schaltfläche // Typ ohne Vorzeichen verwenden, um große Zahlen zu verwenden unsigned long lastDebounceTime = 0; // kürzlich unsigned long debounceDelay = 50; // verzögern, ggf. erhöhen void setup() ( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); digitalWrite(ledPin, ledState); ) void loop() ( // den Zustand des Buttons lesen int reading = digitalRead( buttonPin); // wenn die Taste gedrückt wird, // dann warten wir ein wenig, um den Bounce zu beseitigen // wenn sich der Zustand geändert hat (bounce oder drücken) if (reading != lastButtonState) ( // den Timer zurücksetzen lastDebounceTime = millis(); ) if (( millis() - lastDebounceTime) > debounceDelay) ( // was auch immer der Messwert ist, er ist schon länger da als die Entprellungsverzögerung //, also nimm ihn als den tatsächlichen aktuellen Zustand: / / wenn sich der Tastenzustand geändert hat if (reading != buttonState) ( buttonState = reading; // LED schalten, wenn der neue Tastenzustand HIGH ist if (buttonState == HIGH) ( ledState = !ledState; ) ) ) // gesetzt die LED digitalWrite(ledPin, ledState); // den Zustand der Schaltfläche speichern. Beim nächsten Mal in der Schleife wird dies zum Wert von lastButtonState: lastButtonState = reading; )

02.Digital: DigitalInputPullup (Eingebauter Pull-Up-Widerstand)

Die digitalen Pins verfügen bereits über 20-kOhm-Widerstände, die als Pull-Ups beim Arbeiten mit Knöpfen verwendet werden können. Schauen wir uns ein Beispiel an Datei | Beispiele | 02.Digital | DigitalInputPullup.

Anschlussplan: Verbinden Sie den ersten Pin des Tasters mit Pin 2 auf der Platine und den zweiten Pin des Tasters mit Pin GND. Während die Skizze läuft, lesen wir die Messwerte des zweiten Pins ab.

Void setup() ( Serial.begin(9600); // Pin 2 auf Eingabemodus setzen und den eingebauten Pull-up-Widerstand einschalten pinMode(2, INPUT_PULLUP); pinMode(13, OUTPUT); // LED ) void loop() ( // Nimm die Tastenwerte int sensorVal = digitalRead(2); // Ausgabe an Serial Monitor Serial.println(sensorVal); // Denken Sie daran, dass bei Verwendung eines Power-Pull-up-Widerstands der Tastenzustand invertiert ist / / Wenn die Taste nicht gedrückt wird, hat sie den Wert HIGH, und wenn sie gedrückt wird, LOW. // Wenn Sie die Taste drücken, schalten Sie die LED ein, wenn Sie sie loslassen, schalten Sie sie aus, wenn (sensorVal == HIGH) ( digitalWrite(13, LOW); ) else ( digitalWrite(13, HIGH); ) )

Wenn wir die Skizze ausführen, werden wir sehen, dass die Zahlen 1 auf dem Monitor angezeigt werden ( HOCH). Wenn Sie die Taste drücken, ändern sich die Werte auf 0 ( NIEDRIG).

UND Arduino Dies ist keine Ausnahme. Nachdem die LED blinkt, wird versucht, die Taste anzuschließen und damit das Blinken dieser LED zu steuern. Hier gibt es nichts besonders Kompliziertes, aber es gibt eine Nuance namens „Contact Bounce“. So schließen Sie einen Knopf richtig an Arduino Was „Contact Bounce“ ist, wie sich dieser Effekt äußert und Methoden zu seiner Bekämpfung werden heute besprochen.

Das einfachste Diagramm zum Anschließen einer Taste an einen Mikrocontroller sieht folgendermaßen aus:

Wenn der Schlüssel S 1 geöffnet ist (Taste wird losgelassen), dann am digitalen Eingang D in Mikrocontroller haben wir eine Spannung von 5V, was einer logischen Eins entspricht. Wenn die Taste gedrückt wird, geben Sie ein D in wird mit Masse verbunden, was dem logischen Nullpegel entspricht und die gesamte Spannung am Widerstand abfällt R 1, dessen Wert auf der Grundlage der Tatsache gewählt wird, dass beim Drücken der Taste nicht zu viel Strom durch sie fließt (normalerweise etwa 10–100 kOhm).

Wenn Sie einfach einen Taster zwischen dem digitalen Eingang und Masse anschließen (ohne Widerstand). R 1, verbunden mit +5V) oder zwischen dem Eingang und +5V, dann liegt in der Position, in der die Taste nicht gedrückt wird, eine undefinierte Spannung am digitalen Eingang des Mikrocontrollers an (kann dem Pegel 0 oder vielleicht 1 entsprechen) und wir würden zufällige Zustände lesen. Daher wird ein Widerstand verwendet R 1, der den Eingang beim Loslassen der Taste auf +5 V „hochziehen“ soll.

Durch das Auslesen des Zustands des digitalen Eingangs des Mikrocontrollers können wir feststellen, ob die Taste gedrückt ist (Zustand logisch 0) oder nicht (am Eingang erhalten wir eine logische Eins).

Anschließen einer Taste an Arduino

Mikrocontroller Atmel AVR ATmega(auf deren Grundlage es aufgebaut ist Arduino) verfügen über integrierte, softwaregesteuerte Lastwiderstände R n 20 kOhm und wir können sie nutzen, indem wir den Anschlussplan vereinfachen.

Der interne Lastwiderstand wird angeschlossen, indem eine logische Eins in das erforderliche Bit des Ports geschrieben wird.

Skizzenbeispiel Arduino, der über einen internen Lastwiderstand die eingebaute LED an Pin 13 ein- und ausschaltet, je nachdem, ob der am zweiten Pin angeschlossene Taster gedrückt oder losgelassen wird:

void setup() ( pinMode(13, OUTPUT); //LED an Pin 13 pinMode(2, INPUT); //2 Pins sind im Eingabemodus. Der Button ist mit Masse verbunden. digitalWrite(2, HIGH); // Schließen Sie den Pull-Up-Widerstand an.) void loop() (digitalWrite(13, !digitalRead(2)); // Lesen Sie den Tastenzustand und schalten Sie die LED.

Hier invertieren wir den vom Eingabeport gelesenen Wert mithilfe eines Booleschen Werts NICHT, gekennzeichnet durch ein Ausrufezeichen vor der Funktion digitalRead, da wir beim Drücken der Taste 0 lesen und um die LED am Port einzuschalten, müssen wir 1 senden.

Kontaktabsprung

Alles wäre gut, wenn wir in einer idealen Welt mit perfekten Knöpfen leben würden. Echte mechanische Kontakte, die in Knöpfen vorhanden sind, schließen oder öffnen sich nie sofort. Über einen kurzen Zeitraum werden die Kontakte der Taste (Taste) immer wieder geschlossen und geöffnet, wodurch am Eingang des Mikrocontrollers kein einziger Spannungsabfall, sondern ein ganzes Impulspaket empfangen wird. Dieses Phänomen wird „Contact Bounce“ genannt.

Als wir im obigen Beispiel die LED einfach per Knopfdruck ein- und ausschalteten, bemerkten wir dies nicht, da das Ein-/Ausschalten der LED im Moment des „Bouncens“ sehr schnell ging und wir es bei unserem einfach nicht gesehen haben Augen.

Diese Bibliothek umfasst die folgenden Methoden:

• prallen()— Initialisierung des Bounce-Objekts
• Void-Intervall (vorzeichenloses langes Intervall)– Legt die Anti-Bounce-Zeit in Millisekunden fest
• Void Attach (int Pin)— Legt den Pin fest, an den die Taste angeschlossen ist, und verbindet den eingebauten Pull-up-Widerstand mit diesem Pin
• int update()- weil das Prallen nicht verwendet, „aktualisieren“ Sie das Objekt, bevor Sie seinen Status lesen, und dies muss ständig erfolgen (z. B. im Inneren). Schleife). Methode aktualisieren aktualisiert das Objekt und gibt zurück WAHR(1), wenn sich der Zustand des Pins geändert hat (die Taste wurde gedrückt oder umgekehrt losgelassen) und FALSCH(0) sonst. Aufrufen einer Methode aktualisieren innen Schleife muss nur einmal durchgeführt werden.
• int read()– gibt den aktualisierten Status des Pins zurück

Standardmäßig verwendet die Bounce-Bibliothek ein Stabilisierungsintervall ( stabiles Intervall), um Anti-Bounce zu implementieren. Dies ist einfacher zu verstehen und macht die Kenntnis der Dauer des Chatters überflüssig.

Parameter stabiles Intervall Bounce-Bibliotheken

Nachdem ich mich entschieden habe

#define BOUNCE_LOCK-OUT

im Ordner Bounce.h Sie können eine alternative Anti-Battering-Methode aktivieren. Mit dieser Methode können Sie schneller auf Änderungen im Status der Schaltfläche reagieren. Sie erfordert jedoch die Einstellung der Dauer des Absprungs. Wie oben erwähnt, erhöht sich dieser Wert mit der Zeit, was bedeutet, dass Sie Änderungen daran vornehmen müssen Code ändern oder einen bewusst größeren Wert festlegen.

Hier ist ein Beispiel für die Verwendung dieser Bibliothek:

#enthalten Bounce bouncer = Bounce(); void setup() ( pinMode(2 ,INPUT); // Button auf Pin 2 digitalWrite(2 ,HIGH); bouncer .attach(2); // setze den Button bouncer .interval(5); Serial.begin(9600) ; //die serielle Schnittstelle auf 9600 bps einstellen) void loop() ( if (bouncer.update()) ( //wenn ein Ereignis auftritt if (bouncer.read()==0) ( //wenn die Taste gedrückt wird Serial .println("pressed"); //eine Meldung über das Drücken anzeigen) else Serial.println("released"); //eine Meldung über das Loslassen anzeigen) )

Und noch ein kleines praktisch nützliches Beispiel. Nehmen wir eine Taste, die, wenn sie weniger als 2 Sekunden lang gedrückt wird, eine Variable ändert aktueller Modus, das den aktuellen Betriebsmodus eines Geräts speichert. In diesem Beispiel ändert sich der Modus von 0 auf 5. Einmal gedrückt – der Modus ist Nummer 1. Erneut gedrückt – 2. Und so weiter bis fünf. Nach fünf wird beim nächsten Drücken der aktuelle Modus zum ersten und wieder im Kreis. Wenn Sie die Taste länger als 2 Sekunden gedrückt halten, wird die Variable aktueller Modus erhält den Wert 0.

#enthalten #define press_long 2000 // langes Drücken = 2 Sekunden #define num_modes 5 // maximale Modusnummer short int max_mode = num_modes + 1; // Hilfsvariable Bounce bouncer = Bounce(); //Erstelle eine Instanz der Bounce-Klasse unsigned longpressed_moment; // Moment des Tastendrucks int current_mode = 0; // aktueller Modus void setup() ( pinMode(2 ,INPUT); // Taste an Pin 2 digitalWrite(2 ,HIGH); // den eingebauten Pull-up-Widerstands-Bouncer anschließen .attach(2); // installieren the button bouncer .interval( 5); // setze den Parameter Stable Interval = 5 ms Serial.begin(9600); // setze den seriellen Port auf 9600 bps) void loop() ( if (bouncer.update()) ( //wenn es passiert ist event if (bouncer.read()==0) ( //wenn die Taste gedrückt wird press_moment = millis(); // den Zeitpunkt des Drückens merken ) else ( // die Taste wird losgelassen if(( millis() - pressed_moment)< pressed_long) { // если кнопка была нажата кратковременно current_mode++; // увеличиваем счетчик текушего режима current_mode %= max_mode; // остаток от целочисленного деления if (current_mode == 0) current_mode = 1; // режим меняется от 1 до num_modes } else { // кнопка удерживалась долго current_mode = 0; pressed_moment = 0; // обнуляем момент нажатия } Serial.println("Current mode:"); Serial.println(current_mode); // выводим сообщение о текущем режиме } } }

/*
* ArduinoKit-Experimentierset
* Programmcode für Experiment Nr. 5: Skizze 05
*
* TASTEN
*
* Für die Website http://site geschrieben
*
*
* Hilfe von der Arduino-Community.
* Besuchen Sie http://www.arduino.cc
*
* Kommentar zum Programm verfasst von
* 22. Januar 2014
* speziell für http://site
*/

TASTEN.

Verwendung von Tasten an digitalen Eingängen.

Früher haben wir analoge Ports (Pins) für die Dateneingabe verwendet, aber jetzt schauen wir uns digitale Ports in Aktion an. Da digitale Ports nur zwei Signalpegel kennen – hoch „+5“ und niedrig „0“ – eignen sie sich ideal für die Interaktion mit Tasten und Schaltern, die ebenfalls nur zwei Positionen haben, „Ein“ und „Aus“.

Wir verbinden einen Pin des Knopfes mit einem Kabel mit Masse und den anderen Pin mit dem digitalen Port. Wenn Sie die Taste drücken, wird der Stromkreis geschlossen und das Erdungsende „-“ wird mit dem digitalen Port verbunden, sodass das empfangene Signal vom Arduino als „niedrig“ betrachtet wird.

Aber Moment – ​​was passiert, wenn die Taste nicht gedrückt wird? In diesem Zustand ist der Port von allem getrennt, das heißt, er hängt in der Luft, und wir nennen diesen unverständlichen Zustand „undefiniert“ oder schwebend. Das heißt, wir können nicht mit Sicherheit sagen, wie Arduino auf einen solchen Zustand reagieren wird. Abhängig von verschiedenen Umgebungsbedingungen kann dies von ihr entweder als HOCH („HIGH“ +5 Volt) oder NIEDRIG („LOW“ – logische Null) wahrgenommen werden.

Um Unstimmigkeiten zu vermeiden und der Mikrocontroller genau weiß, was gerade an seinem Eingang anliegt, verbinden wir zusätzlich den Arduino-Port über einen Begrenzungswiderstand (jeder mit einer Nennleistung von 1 KOhm – 10 KOhm reicht aus) mit dem +5-Volt-Bus. Dieser „Pull-Up“ garantiert das Vorhandensein eines konstanten HIGH +5V-Signals, und wenn Sie die Taste drücken, schließt der Schaltkreis an Masse – „0“, was bedeutet, dass für Arduino das Eingangssignal von HIGH auf LOW wechselt , d.h. von HIGH +5V auf LOW „0“.

(Zusätzlich: Sobald Sie sich an die Widerstände gewöhnt haben und wissen, wann sie benötigt werden, können Sie die internen Pull-up-Widerstände im ATmega-Prozessor selbst aktivieren. Weitere Informationen finden Sie unter http://arduino.cc/en/Tutorial/ DigitalPins).

Geräteanschluss:

Die Tasten verfügen über zwei Kontakte; wird die Taste gedrückt, ist der Kontakt geschlossen; wird sie nicht gedrückt, ist der Kontakt geöffnet.

Bei den Knöpfen werden wir sowohl zwei als auch vier Kontakte verwenden, aber es sollte beachtet werden, dass bei den Knöpfen, die wir jetzt verwenden werden, zwei Kontakte parallel geschaltet sind.

Der einfachste Weg, einen Taster anzuschließen, besteht darin, die Drähte schräg (diagonal) an die Klemmen anzuschließen.

Verbinden Sie einen beliebigen Pin von Taste 1 mit Masse (GND).
Verbinden Sie den anderen Tastenstift mit dem digitalen Anschluss 2.

Verbinden Sie einen beliebigen Pin von Taste 2 mit Masse (GND).
Verbinden Sie den anderen Tastenstift mit dem digitalen Anschluss 3.

Schließen Sie an den Beinen der Tasten, die zu den digitalen Anschlüssen 2 und 3 führen, „Pull-up“-Widerstände von 10 K (braun/schwarz/rot) an und verbinden Sie die zweiten Anschlüsse dieser Widerstände mit dem gemeinsamen „-“ (GND). Diese Widerstände stellen sicher, dass der Eingang entweder +5 V (die Taste ist nicht gedrückt) oder „0“ beträgt, wenn sie gedrückt wird, und sonst nichts. (Und vergessen Sie nicht, dass digitale Eingänge im Gegensatz zu analogen Eingängen nur zwei Zustände haben: HIGH und LOW.)

Leuchtdiode:

Auf den meisten Arduino-Boards, einschließlich UNO, ist bereits eine LED mit einem Strombegrenzungswiderstand installiert, der an Port 13 angeschlossen ist. Und Sie müssen keine eigene installieren.

Aber wenn Sie sich entscheiden, Ihr eigenes Gerät anzuschließen, um weitere Informationen zu erhalten, wird es nicht schlimmer sein.

Verbinden Sie das Pluskabel der LED mit dem Arduino-Digitalanschluss Nr. 13
Verbinden Sie die Minusleitung der LED mit einem 330-Ohm-Widerstand.
Verbinden Sie den anderen Anschluss des Widerstands mit GND „-“.

// Zuerst erstellen wir Konstanten, d.h. Geben wir den künftigen Schaltflächen Namen
// bleiben bis zum Ende des Programmcodes unverändert und binden diese Namen an die Arduino-Ports.
// Dies erleichtert das Verständnis und die Arbeit mit dem Programmcode und ermöglicht auch
// Verweisen Sie namentlich auf den Port.

const int button1Pin = 2; // Taste Nummer 1 - Port 2
const int button2Pin = 3; // Taste Nummer 2 - Port 3
const int ledPin = 13; // Port 13, für LED

void setup()
{
// Schaltflächen-Ports als eingehend festlegen:
pinMode(button1Pin, INPUT);
pinMode(button2Pin, INPUT);

// Den LED-Port als ausgehend festlegen:
pinMode(ledPin, OUTPUT);
}

Leere Schleife()
{
int button1State, button2State; // Variablen zum Speichern des Zustands der Schaltflächen

// Da Tasten nur zwei Zustände haben (gedrückt und nicht gedrückt), werden wir das tun
// mit ihnen über digitale Eingangsports arbeiten. Um zu lesen
// Informationen verwenden wir die Funktion digitalRead(). Diese Funktion ermöglicht
// einen Parameter vom digitalen Port empfangen und entweder HIGH (+5V) zurückgeben,
// oder LOW („0“).

// Hier lesen wir den aktuellen Zustand der Schaltflächen und geben ihren Wert ein
// in zwei Variablen:

button1State = digitalRead(button1Pin);
button2State = digitalRead(button2Pin);

// Denken Sie daran, wenn die Taste gedrückt wird, wird der Port mit Masse verbunden („-“).
// Wenn die Taste nicht gedrückt wird, wird der Port über einen Pull-up-Widerstand mit +5 Volt verbunden.

// Der Portstatus wird also LOW sein, wenn die Taste gedrückt wird,
// und HIGH (hoch), wenn es nicht gedrückt wird.

// Jetzt verwenden wir den Status der Ports, um die LED zu steuern.

// Was wir tun wollen, Bedingung:
// „Wenn eine beliebige Taste gedrückt wird, leuchtet die LED“
// „Aber wenn beide Tasten gedrückt werden, leuchtet die LED nicht“
// Lassen Sie uns dies in Code übersetzen.

// Arduino verfügt über spezielle logische Operatoren und Vergleichsoperatoren.
// die häufig bei der Überprüfung von Bedingungen verwendet werden, insbesondere:

// "==" (Gleichheit) – True, wenn beide Seiten gleich sind
// Beispiel:
// if (x == y) (
// Bedingungskörper
//}

// „&&“ (logisches UND) – Nur wahr, wenn beide Bedingungen erfüllt sind
// Beispiel:
// True, wenn beide Ausdrücke True sind
// wenn (x > 0 && x< 5) {
// Bedingungskörper
//}

// "!" (logisches NICHT)
// Wahr, wenn der Operator falsch ist
// Beispiel:
//if (!x) (
// Bedingungskörper
//}

// "||" (logisches ODER) – Wahr, wenn mindestens eine der Bedingungen wahr ist
// Beispiel:
//if (x > 0 || y > 0) (
// Bedingungskörper
// }

// In diesem Fall verwenden wir das „if“-Konstrukt, um alles zu übersetzen
// das Obige in die logischen Ketten des Programms einfügen.
// (Vergessen Sie nicht, LOW bedeutet, dass die Taste gedrückt ist)

// „Wird eine der Tasten gedrückt, leuchtet die LED“
// es wird sich herausstellen:
// if ((button1State == LOW) || (button2State == LOW)) // die LED leuchten lassen

// „Wenn beide Tasten gedrückt werden, leuchtet die LED nicht“
// es wird sich herausstellen:
// if ((button1State == LOW) && (button2State == LOW)) // die LED nicht leuchten lassen

// Jetzt verwenden wir die oben genannten Funktionen und kombinieren sie in einer Anweisung:

if (((button1State == LOW) || (button2State == LOW)) // vergleichen, ob einer der Buttons gedrückt ist
&& ! // und wenn nicht
((button1State == LOW) && (button2State == LOW))) // vergleichen, ob beide Tasten gedrückt sind
// Dann…
{
digitalWrite(ledPin, HIGH); // schalte die LED ein
}
sonst // sonst
{
digitalWrite(ledPin, LOW); // schalte die LED aus
}

// Wie Sie vielleicht bemerkt haben, können Operatoren kombiniert werden
// zur Lösung komplexer Probleme

// Nicht vergessen: Sie können beim Vergleichen von Werten stattdessen nicht den Operator „=" verwenden
// "==" weil der Operator "=" Variablen einen Wert zuweist!
}

Im nächsten Artikel werden wir den Code für Lektion Nr. 5 als Archiv veröffentlichen.

Wir haben über die Grundlagen der Arduino-Programmierung gesprochen. Heute werden wir über Arduino GPIO- und PWM-Signale sprechen. Wir verwenden Tasten und steuern die Helligkeit der LED über ein PWM-Signal. Wir werden auch Funktionen in der Arduino-Programmierumgebung verwenden.

Versuchen wir zunächst, die LED über einen Knopf zu steuern.

Wir brauchen:

1. Widerstand Nennwert ca. 100-400 Ohm. Um den durch die LED fließenden Strom zu begrenzen, damit sie nicht durchbrennt.
2. Widerstand Nennwert ca. 10 Zimmer Zum Hochziehen von Logikpegeln am Arduino-Eingang. Wenn Sie es nicht installieren, funktioniert unser Button sehr instabil, weil... Anstelle eines Nutzsignals tritt am Arduino-Eingang Rauschen auf.
3. Leuchtdiode AL307 oder irgendjemand, den du magst. Eigentlich werden wir es anzünden.
4. Takttaster IT-1102 oder irgend ein anderer. Wird zur Steuerung der LED verwendet.

Jetzt ist es an der Zeit, eine einfache Schaltung zusammenzubauen. Sie können dies mit der BreadBoard-Debugplatine oder mit einem Lötkolben und Drähten tun.

LeuchtdiodeÜber einen 200-Ohm-Strombegrenzungswiderstand an Ausgang 10 des Arduino angeschlossen, kann der Widerstandswert auf 200 Ohm – 500 Ohm eingestellt werden, dadurch ändert sich der durch die LED fließende Strom und dementsprechend ihre Helligkeit. Wenn Sie eine LED direkt anschließen, endet sie schlecht, es fließt ein großer Strom durch die LED, wodurch entweder die LED selbst oder der Arduino-Ausgang ausfällt. Es muss auch berücksichtigt werden, dass eine LED schließlich eine Diode ist und eine Polarität hat!

Wenn Sie die LED falsch anschließen, leuchtet sie nicht, da kein Strom durch sie fließt (sie wird einfach geschlossen). Es ist einfach, die Polarität der LED zu bestimmen; der kurze Zweig der LED ist negativ (d. h. Null oder GND), der lange Zweig ist negativ +.

Taste so angeschlossen, dass er im Moment des Drückens +5 Volt auf den Eingang Nr. 10 des Arduino schaltet, was der logischen Einheit des Arduino-Digitaleingangs entspricht. In dem Moment, in dem die Taste nicht gedrückt wird, zieht unser 10-kOhm-Widerstand den Arduino-Eingang auf GND (d. h. auf Null) und der Arduino-Eingang bleibt konstant logisch Null. Wenn Sie diesen Pull-up-Widerstand nicht verwenden, kann es durchaus zu Fehlalarmen kommen. Dies liegt daran, dass am Arduino-Eingang kein Pull-up-Widerstand vorhanden ist und dementsprechend keine Spannung anliegt Null, es wird sich chaotisch ändern, was zum Auftreten einer falschen Logik Eins am Arduino-Eingang führt.

Es ist also an der Zeit, ein Programm für Arduino zu schreiben. Lassen Sie uns zunächst die LED so lange eingeschaltet lassen, wie die Taste gedrückt wird. Natürlich ist es sehr einfach, ein solches Problem ohne Mikrocontroller zu lösen, aber irgendwo müssen wir anfangen. Öffnen Sie die Arduino-Programmierumgebung (wie Sie Arduino programmieren, wird in Nr. 1 ausführlich beschrieben) und Beginnen wir mit dem Schreiben des Codes:

/*

Wir lassen die LED blinken.
Wir lassen die LED so lange an, wie die Taste gedrückt wird.

*/

{


}

{
if (digitalRead(switchPin) == HIGH) // Wenn der Button gedrückt wird, hat unsere Variable switchPin den Wert HIGH (logisch 1) und der folgende Code wird ausgeführt. Linie
{
digitalWrite(ledPin, HIGH); // Die LED zum Leuchten bringen, indem am Ausgang 13 Logik 1 (Pegel HIGH) gesetzt wird
}
else // Wenn die Schaltfläche nicht gedrückt wird, wird der folgende Code ausgeführt.
{
digitalWrite(ledPin, LOW); // Schalte die LED aus
}
}

Naja, was funktioniert?! :) :)

Jetzt machen wir die Aufgabe komplizierter: Stellen Sie sicher, dass die LED beim Drücken der Taste aufleuchtet und eingeschaltet bleibt, bis wir sie erneut drücken, und so weiter im Kreis.

Unser Code für diese Zwecke sieht folgendermaßen aus:

/*
Lektion 2. GPIO, Tasten und PWM auf Arduino

Wir schalten die LED nach dem Drücken der Taste ein und nach dem zweiten Drücken wieder aus.
Dieser Democode wurde von www.site heruntergeladen
*/

int switchPin = 10; // Legen Sie der Einfachheit halber den Namen „switchPin“ für Pin 10 fest
int ledPin = 13; // Der Einfachheit halber legen Sie den Namen „ledPin“ für Pin 13 fest


void setup() // Der „Setup“-Block wird beim Start des Arduino nur einmal ausgeführt, er wird zur Initialisierung benötigt.
{
pinMode(switchPin, INPUT); // Arduino-Pin 10 als Eingang konfigurieren. Weil Wir werden den Status der Schaltfläche lesen.
pinMode(ledPin, OUTPUT); // Arduino-Pin 13 als Ausgang konfigurieren. Damit schalten wir die LED ein.
}

void loop() // Der „loop“-Block ist eine Schleife, d.h. Code, der immer und immer wieder funktioniert
{
if (digitalRead(switchPin) == HIGH && lastButton == LOW) // Wenn die Taste gedrückt ist und der letzte Tastenzustand „nicht gedrückt“ war, dann führen Sie den folgenden Code aus
{

lastButton = HIGH; // Ändere den Wert von lastButton auf logisch Eins
}
anders
{
lastButton = digitalRead(switchPin); // Setzen Sie die lastButton-Variable auf denselben Wert wie die switchPin-Variable
}

}

Na, wie funktioniert das?! Hmm... Seltsam... Manchmal funktioniert bei uns alles wie erwartet, und manchmal nicht... Warum konnte das passieren? Es geht um den „Contact Bounce“-Effekt:

Wie Sie in diesem Oszillogramm sehen können, funktioniert unser Knopf tatsächlich nicht perfekt... Und wenn wir den Knopf mit hoher Frequenz abfragen, können wir im Übergangsmoment sowohl Eins als auch Null zählen. Es wäre besser, Hardwarelösungen für das Problem zu verwenden, aber jetzt sprechen wir über unseren Code. Um dieses Klappern zu vermeiden, müssen wir das Programm einfach ändern eingeben Zeitverzögerung:

/*
Lektion 2. GPIO, Tasten und PWM auf Arduino
Schalten Sie die LED ein/aus.
Wir schalten die LED nach dem Drücken der Taste ein und nach dem zweiten Drücken aus und verhindern so das Prellen der Tasten.
Dieser Democode wurde von www.site heruntergeladen

int switchPin = 10; // Legen Sie der Einfachheit halber den Namen „switchPin“ für Pin 10 fest
int ledPin = 13; // Der Einfachheit halber legen Sie den Namen „ledPin“ für Pin 13 fest
boolean lastButton = LOW; // In dieser Variablen speichern wir den Zustand der Schaltfläche während der vorherigen Verarbeitung unserer Schleife und setzen ihn auch auf Null.
boolean ledOn = false; // In dieser Variablen speichern wir den Zustand der LED, damit wir sie umschalten können

void setup() // Der „Setup“-Block wird beim Start des Arduino nur einmal ausgeführt, er wird zur Initialisierung benötigt.
{
pinMode(switchPin, INPUT); // Arduino-Pin 10 als Eingang konfigurieren. Weil Wir werden den Status der Schaltfläche lesen.
pinMode(ledPin, OUTPUT); // Arduino-Pin 13 als Ausgang konfigurieren. Damit schalten wir die LED ein.
}

{


{


}

}

void loop() // Der „loop“-Block ist eine Schleife, d.h. Code, der immer und immer wieder funktioniert

{


{
ledOn = !ledOn; // Den ledOn-Wert in das Gegenteil ändern
}

digitalWrite(ledPin, ledOn); // Tatsächlich wird diese Zeile die LED ein- und ausschalten
}

Ich denke, jetzt hat bei allen alles wie vorgesehen funktioniert ;)

Jetzt ist es an der Zeit, unser Programm so zu ändern, dass sich nach jedem Tastendruck die Helligkeit der LED ändert. Dazu verwenden wir ein PWM-Signal oder wie es auch PWM genannt wird. Wenn Sie mehr über PWM erfahren möchten, können Sie es auf WIKI nachlesen. Aber für uns reicht es im Moment aus, nur zu wissen, dass man durch Ändern der logischen Werte 0 und 1 in einer bestimmten Reihenfolge die LED anders leuchten lassen kann, aber im Wesentlichen blinkt sie einfach anders, aber seit der Blinkfrequenz Wenn die Helligkeit hoch ist, scheint es für das Auge so, als würde sich nur die Helligkeit ändern.

Aber leider unterstützen nicht alle Arduino-Ausgänge PWM. Die PWM-Unterstützung wird durch das ~-Symbol neben der Pin-Nummer auf dem Arduino-Siebdruck angezeigt. Einer dieser Pins ist Pin Nr. 11, und unser aktueller Pin Nr. 13 unterstützt kein PWM, daher müssen wir das Anschlussdiagramm wie folgt ändern:

Und nehmen Sie auch Änderungen am Programmcode vor, nämlich Sie müssen die Kontaktnummer ändern und Fügen Sie die Verwendung von PWM hinzu:

/*
Lektion 2. GPIO, Tasten und PWM auf Arduino
Ändern Sie die Helligkeit der LED.
Wir ändern die Helligkeit der LED nach jedem Tastendruck.
Dieser Democode wurde von www.site heruntergeladen
*/

int switchPin = 10; // Legen Sie der Einfachheit halber den Namen „switchPin“ für Pin 10 fest
int ledPin = 11; // Der Einfachheit halber legen Sie den Namen „ledPin“ für Pin 11 fest
boolean lastButton = LOW; // In dieser Variablen speichern wir den Zustand der Schaltfläche während der vorherigen Verarbeitung unserer Schleife und setzen ihn auch auf Null.
int ledLevel = 0; // In dieser Variablen speichern wir die Helligkeit der LED, die Helligkeit kann einen Wert von 0 bis 255 haben, zum Zeitpunkt der Initialisierung setzen wir sie auf 0, damit die LED nicht leuchtet
boolean currentButton = LOW; // Variable für unsere Entprellfunktion

void setup() // Der „Setup“-Block wird beim Start des Arduino nur einmal ausgeführt, er wird zur Initialisierung benötigt.
{
pinMode(switchPin, INPUT); // Arduino-Pin 10 als Eingang konfigurieren. Weil Wir werden den Status der Schaltfläche lesen.
pinMode(ledPin, OUTPUT); // Arduino-Pin 13 als Ausgang konfigurieren. Damit schalten wir die LED ein.
}

boolean debounce(boolean last) //Funktion zum Entprellen der Tastenkontakte, gibt den vorherigen Zustand zurück
{
boolean current = digitalRead(switchPin); // Schreibe den aktuellen Status der Schaltfläche auf „Current“.
if (last != current) // Prüfen, ob sich der Button-Zustand geändert hat
{
Verzögerung(5); // Wenn ja, machen wir eine Verzögerung von 5 Millisekunden, damit der Knopf aufhört zu „rasseln“
current = digitalRead(switchPin); // Den Wert der Schaltfläche nach einer Pause lesen, jetzt sollte das Geschwätz vorbei sein
}
Rückstrom; // den stabilen Wert der Schaltfläche zurückgeben
}

void loop() // Der „loop“-Block ist eine Schleife, d.h. Code, der immer und immer wieder funktioniert
{
currentButton = debounce(lastButton); // Übergebe an currentButton das Ergebnis der Debounce-Funktion mit dem übergebenen Button-Status
if (lastButton == LOW && currentButton == HIGH) // Prüfen, ob der Button gedrückt wurde
{
ledLevel = ledLevel + 51; // Ändere den Helligkeitswert auf 51
}
lastButton = currentButton; // Setze die lastButton-Variable auf denselben Wert wie die currentButton-Variable

if (ledLevel > 255) ledLevel = 0; // Begrenzen Sie die max. Wert von 255
analogWrite(ledPin, ledLevel); // Tatsächlich wird diese Zeile die LED mit der erforderlichen Helligkeit zum Leuchten bringen
}

Ich hoffe, dass bei dir alles funktioniert hat. Dies ist das Ende der Lektion.

In den Kommentaren können Sie Fragen stellen und um Rat bitten.

Der Anschluss eines Tastensensors an ein Arduino erfordert bestimmte Kenntnisse und Fähigkeiten. In diesem Artikel werden wir darüber sprechen, was eine Takttaste ist, was Tastenprellen ist, wie man eine Taste richtig mit einem Pull-Up- und Pull-Down-Widerstand verbindet und wie man LEDs und andere Geräte mit einer Taste steuern kann.

Ein Knopf (oder Druckknopfschalter) ist der einfachste und am besten zugängliche Sensor aller Art. Durch Anklicken sendet man ein Signal an die Steuerung, das dann einige Aktionen auslöst: LEDs leuchten auf, Geräusche ertönen, Motoren starten. In unserem Leben stoßen wir oft auf verschiedene Schalter und sind mit diesem Gerät bestens vertraut.

Takttasten und Schaltertasten

Wie üblich beginnen wir den Abschnitt mit einfachen Dingen, die nur für Anfänger interessant sind. Wenn Sie die Grundlagen kennen und mehr über die verschiedenen Möglichkeiten erfahren möchten, einen Button mit einem Arduino zu verbinden, können Sie diesen Absatz überspringen.

Was ist ein Knopf? Im Wesentlichen handelt es sich hierbei um ein recht einfaches Gerät, das das Stromnetz schließt und öffnet. Sie können dieses Schließen/Öffnen in verschiedenen Modi durchführen, mit oder ohne Fixierung Ihrer Position. Dementsprechend lassen sich alle Tasten in zwei große Gruppen einteilen:

• Schalterknöpfe mit Fixierung. Nach der Freilassung kehren sie in ihren ursprünglichen Zustand zurück. Dabei werden sie je nach Ausgangszustand in Öffner- und Öffner-Tasten unterteilt.
• Momentantasten (Takttasten). Sie sind fixiert und bleiben in der Position, in der sie belassen wurden.

Es gibt viele Optionen für verschiedene Tasten. Dies ist wirklich eine der häufigsten Arten elektronischer Komponenten.

Arduino-Tasten für einfache Projekte

In unseren Projekten werden wir mit sehr einfachen 4-beinigen Uhrknöpfen arbeiten, die in fast jedem Arduino-Kit enthalten sind. Der Taster ist ein Schalter mit zwei Kontaktpaaren. Die Kontakte in einem Paar sind miteinander verbunden, sodass es nicht möglich ist, mehr als einen Schalter im Stromkreis zu implementieren. Sie können jedoch zwei parallele Segmente gleichzeitig steuern. Dies kann nützlich sein.

Je nach Situation können Sie beide Stromkreise mit Öffner- und Schließerkontakten erstellen – Sie müssen lediglich die Verbindungen im Stromkreis entsprechend herstellen.

Um die Verwendung zu erleichtern, wird der Taktknopf normalerweise mit einer Plastikkappe in einer bestimmten Farbe geliefert; sie passt ganz offensichtlich über den Knopf und verleiht dem Projekt ein weniger Hacker-ähnliches Aussehen.

Anschließen des Arduino-Buttons

Ein- und Ausschalten der LED per Knopfdruck

Beginnen wir mit der einfachsten Möglichkeit, einen Taktknopf anzuschließen. Stellen Sie sich einen Schaltkreis mit einem Arduino als Stromquelle, einer LED, einem 220-Ohm-Begrenzungswiderstand und einem Knopf vor, der den Schaltkreis schließt und öffnet.

Beim Anschluss eines Tasters mit zwei Beinpaaren ist es wichtig, die richtigen Öffnerkontakte auszuwählen. Schauen Sie sich das Bild genau an: An den Seiten des Knopfes befinden sich Beinpaare. Der Knopf selbst ist quadratisch, aber die Abstände zwischen den Kontaktpaaren fallen optisch auf: Man kann sofort zwei auf der einen und zwei auf der anderen Seite auswählen. Der Wechsel wird also zwischen einem „Paar“ auf der Seite implementiert. Um in den Stromkreis einbezogen zu werden, verbinden wir uns mit dem einen und dem anderen Kontakt, zwischen denen ein Mindestabstand besteht. Das zweite Kontaktpaar dupliziert einfach das erste.

Wenn Sie einen anderen Schaltertyp haben, können Sie Kontakte sicher aus gegenüberliegenden Ecken auswählen (bei einigen Tasten gibt es eine spezielle Markierung in Form einer Aussparung, anhand derer Sie feststellen können, auf welcher Seite sich die gepaarten Kontakte befinden). Der zuverlässigste Weg, die richtigen Beine zu bestimmen, besteht darin, die Kontakte mit einem Tester zu testen.

Die Schaltung selbst mit Taster, LED und Arduino-Controller bedarf keiner besonderen Erklärung. Der Taster unterbricht den Stromkreis, die LED leuchtet nicht. Beim Drücken wird der Stromkreis geschlossen und die LED leuchtet auf. Wenn Sie die Kontakte vertauschen (die Tasten über geschlossene gepaarte Kontakte einschalten), funktioniert die Taste nicht, da der Stromkreis niemals geöffnet wird. Tauschen Sie einfach die Kontakte aus.

Anschluss eines Tasters mit Pull-up-Widerstand

Verbinden wir nun den Button mit dem Arduino, damit wir seinen Zustand im Sketch ablesen können. Dazu verwenden wir das folgende Diagramm.

Blinkende LED nach Tastendruck

Im vorherigen Beispiel mit LEDs haben wir einen Knopf an ein Arduino-Board angeschlossen und verstanden, wie es funktioniert. Die LED schaltete sich ein und aus, allerdings völlig passiv – der Controller selbst war hier absolut überflüssig, er hätte durch Batterien ersetzt werden können. Deshalb machen wir unser neues Projekt „intelligenter“: Wenn Sie eine Taste drücken, blinken die LEDs kontinuierlich. Mit einer herkömmlichen Schaltung mit Glühbirne und Schalter ist das nicht möglich – wir werden die Leistung unseres Mikrocontrollers nutzen, um diese zwar einfache, aber nicht triviale Aufgabe zu lösen.

Ein Ausschnitt der Schaltung mit einer LED ist uns bereits bekannt. Wir haben eine normale Bake mit einer LED und einem Begrenzungswiderstand zusammengebaut. Aber im zweiten Teil sehen wir einen bekannten Knopf und einen weiteren Widerstand. Obwohl wir nicht auf Details eingehen, bauen wir einfach die Schaltung zusammen und laden eine einfache Skizze auf den Arduino hoch. Alle Elemente der Schaltung sind in den einfachsten Arduino-Starterkits enthalten.

/* Skizze für eine Schaltung mit einem Taktknopf und einer LED. Die LED blinkt, während der Knopf gedrückt wird. Der Button wird auf den Boden gezogen, das Drücken entspricht HIGH am Eingang */ const int PIN_BUTTON = 2; const int PIN_LED = 13; void setup() ( Serial.begin(9600); pinMode(PIN_LED, OUTPUT); ) void loop() ( // Den Zustand der Schaltfläche abrufen int buttonState = digitalRead(PIN_BUTTON); Serial.println(buttonState); // Wenn die Taste wird nicht gedrückt, dann machen wir nichts if (!buttonState) ( delay(50); return; ) // Dieser Codeblock wird ausgeführt, wenn die Taste gedrückt wird // LED blinken lassen digitalWrite(PIN_LED, HIGH); Verzögerung(1000); digitalWrite(PIN_LED, LOW); Verzögerung(1000); )

Drücken und halten – die LED blinkt. Loslassen – es geht aus. Genau das, was wir wollten. Wir klatschen vor Freude in die Hände und beginnen zu analysieren, was wir getan haben.

Schauen wir uns die Skizze an. Wir sehen darin eine ziemlich einfache Logik.

1. Stellen Sie fest, ob die Taste gedrückt ist.
2. Wenn die Taste nicht gedrückt wird, verlassen wir einfach die Schleifenmethode, ohne etwas einzuschalten oder zu ändern.
3. Wenn die Taste gedrückt wird, flashen wir mit einem Fragment einer Standardskizze:
   1. Schalten Sie die LED ein, indem Sie Spannung an den gewünschten Anschluss anlegen
   2. Wir machen die nötige Pause, wenn die LED leuchtet
   3. Schalten Sie die LED aus
   4. Wir machen die nötige Pause bei ausgeschalteter LED

Die Logik hinter dem Verhalten der Schaltfläche in der Skizze hängt möglicherweise von der Verbindungsmethode mit einem Pull-up-Widerstand ab. Darüber werden wir im nächsten Artikel sprechen.

Der Arduino-Knopf klappert

Bei der Arbeit mit Tasten kann es zu einem sehr unangenehmen Phänomen namens „Button Bounce“ kommen. Wie der Name schon sagt, wird dieses Phänomen durch das Klappern der Kontakte im Drucktastenschalter verursacht. Die Metallplatten berühren sich nicht sofort (wenn auch für unsere Augen sehr schnell), sodass es im Kontaktbereich kurzzeitig zu Spannungsstößen und -einbrüchen kommt. Wenn wir das Auftreten solcher „Müll“-Signale nicht vorhersehen, werden wir jedes Mal darauf reagieren und unser Projekt zum Erfolg führen.

Um Bounce zu vermeiden, werden Software- und Hardwarelösungen eingesetzt. Kurz zusammengefasst nennen wir hier nur die wichtigsten Methoden der Chatter-Unterdrückung:

• Wir fügen in der Skizze eine Pause von 10–50 Millisekunden zwischen der Erfassung der Werte vom Arduino-Pin ein.
• Wenn wir Interrupts verwenden, kann die Softwaremethode nicht verwendet werden und wir bilden einen Hardwareschutz. Das einfachste davon ist ein RC-Filter mit Kondensator und Widerstand.
• Für eine genauere Entprellung wird ein Hardwarefilter mit Schmidt-Trigger verwendet. Mit dieser Option können Sie am Eingang des Arduino ein Signal mit nahezu idealer Form erhalten.

Nähere Informationen zum Umgang mit Chatter finden Sie hier.

Umschalten der Modi per Knopfdruck

Um festzustellen, ob eine Taste gedrückt wurde, müssen Sie lediglich die Tatsache aufzeichnen, dass sie gedrückt wurde, und das Attribut in einer speziellen Variablen speichern.

Die Tatsache des Drückens ermitteln wir mit der Funktion digitalRead(). Als Ergebnis erhalten wir HIGH (1, TRUE) oder LOW (0, FALSE), je nachdem, wie die Taste angeschlossen ist. Wenn wir die Taste über einen internen Pull-Up-Widerstand verbinden, führt das Drücken der Taste dazu, dass der Eingang auf Pegel 0 (FALSE) gesetzt wird.

Um Informationen über einen Schaltflächenklick zu speichern, können Sie eine boolesche Variable verwenden:

boolean keyPressed = digitalRead(PIN_BUTTON)==LOW;

Warum verwenden wir diese Konstruktion und machen es nicht so:

boolean keyPressed = digitalRead(PIN_BUTTON);

Die Sache ist, dass digitalRead() zwar HIGH zurückgeben kann, aber keinen Tastendruck anzeigt. Bei Verwendung einer Schaltung mit Pull-up-Widerstand bedeutet HIGH, dass die Taste im Gegenteil nicht gedrückt ist. Bei der ersten Option (digitalRead(PIN_BUTTON)==LOW) haben wir den Eingang sofort mit dem von uns benötigten Wert verglichen und festgestellt, dass die Taste gedrückt wurde, obwohl der Signalpegel am Eingang jetzt niedrig war. Und den Schaltflächenstatus in einer Variablen gespeichert. Versuchen Sie, alle von Ihnen ausgeführten logischen Operationen explizit anzugeben, um Ihren Code transparenter zu machen und unnötige dumme Fehler zu vermeiden.

Wie wechselt man den Betriebsmodus nach einem Tastendruck?

Oft kommt es vor, dass wir bei der Verwendung von Tasten berücksichtigen müssen, dass wir die Taste nicht nur drücken, sondern auch loslassen müssen. Durch Drücken und Loslassen einer Taste können wir beispielsweise das Licht einschalten oder die Betriebsart des Stromkreises umschalten. Mit anderen Worten: Wir müssen die Tatsache, dass auf die Schaltfläche geklickt wurde, irgendwie im Code aufzeichnen und die Informationen in Zukunft verwenden, auch wenn die Schaltfläche nicht mehr gedrückt wird. Mal sehen, wie das geht.

Die Logik des Programms ist sehr einfach:

• Wir erinnern uns an die Tatsache, dass wir auf eine Servicevariable geklickt haben.
• Wir warten, bis die mit dem Rasseln verbundenen Phänomene vorüber sind.
• Wir warten auf die Freigabe des Buttons.
• Wir erinnern uns an die Tatsache des Loslassens und setzen in einer separaten Variablen das Zeichen dafür, dass die Taste vollständig gedrückt wurde.
• Löschen Sie die Servicevariable.

Wie erkennt man mehrere Tastendrücke?

Sie müssen sich lediglich den Status jeder Schaltfläche in der entsprechenden Variablen oder im Arduino-Array merken. Hier gilt es vor allem zu verstehen, dass jede neue Schaltfläche ein Besetzt-Pin ist. Wenn Sie also über eine große Anzahl an Schaltflächen verfügen, kann es zu einem Mangel an freien Kontakten kommen. Eine alternative Möglichkeit besteht darin, Tasten zu verwenden, die über eine Schaltung mit Widerstandsteiler an einen analogen Pin angeschlossen sind. Darüber werden wir in den folgenden Artikeln sprechen.