Arduino Grundlagen Teil 10: Taster an Arduino anschließen

Taster an Arduino anschließen

Heute befassen wir uns mit einer Art Grundübung: wir werden ein bzw. zwei Taster an unseren Arduino anschließen. Dafür sind die digitalen Eingänge eines Arduinos sehr gut geeignet. Natürlich ist auch die Nutzung der analogen Eingänge für Taster möglich. Ein Arduino verfügt allerdings über weit mehr digitale als analoge Eingänge, weswegen man mit ihnen sparsam umgehen sollte.

Was haben wir vor?

Wir wollen einen Taster an einen Arduino anschließen und diesen auslesen. Dafür stehen uns verschiedene Varianten und deren Kombinationen zur Verfügung. Bei der Arbeit mit Tastern, bzw. digitalen Eingängen im Allgemeinen, trifft man auf folgende Begriffe, die wir uns in diesem Zuge direkt mit anschauen wollen:

  • Interne Widerstände
  • Externe Widerstände
  • Pull-Up Widerstand
  • Pull-Down Widerstand

Den Taster (bzw. die Taster) nutzen wir in diesem Beispiel, um mehrere LEDs an- und auszuschalten.

Komponenten-Liste

Für die Umsetzung brauchen wir folgende Komponenten:

In aller Kürze

Die von mir am häufigsten verwendete Schaltung für einen Taster bzw. Push-Button siehst Du in Abbildung 1. Als Widerstand R1 nehme ich eine Größe zwischen 10k-100kOhm, die ich gerade zur Hand habe. Wenn ich die Wahl habe, möglichst eher Richtung 100kOhm oder sogar noch größer.

Arduino Grundlagen Teil 10: Arduino Taster

Abb. 1: Einfache Taster-Schaltung

Code-Snippets

Um den Taster auslesen zu können, werden im Programm drei Dinge benötigt.

Deklaration des Eingangs

Der angeschlossene digitale Eingang muss deklariert werden. Normalerweise geschieht das noch vor dem Setup. Angenommen der Taster ist am digitalen Pin D7 angeschlossen, können beispielsweise die Zeilen:

const int in_button = 7;

oder

#define in_button 7

zur Deklaration genutzt werden.

Initialisierung als Eingang

Durch die Zeile:

pinMode(in_button, INPUT);

wird der digitale Pin D7 als Eingang konfiguriert. Dies geschieht normalerweise in der Setup() Funktion.

Abfrage des Status

Die eigentliche Abfrage des Status, bzw. das Auslesen des Tasters, wird über die Funktion:

int i_buttonState = digitalRead(in_button);

gemacht.

Prinzipiell ist nicht mehr nötig, um einen Taster mit einem Arduino nutzen zu können.

Da wir ja wieder verstehen wollen wieso ein Taster so funktioniert und warum man den Widerstand braucht, schauen wir uns die Schaltung und deren Variationen nun ausführlich an.

Schaltung mit Pull-Down Widerstand

Der Widerstand R1 entscheidet über das Potential des Eingangs im offenen und geschlossenen Zustand des Tasters. Am einfachsten ist der Unterschied von Pull-Up und Pull-Down Widerständen zu erklären, wenn wir uns direkt eine entsprechende Schaltung anschauen.

Die Schaltung mit einem Pull-Down Widerstand auf dem Breadboard sieht wie in Abbildung 2 aus. Da wir gleich noch LEDs ansteuern wollen, lassen wir die zwei LEDs aus den vorangegangenen Beispielen direkt auf dem Breadboard.

Abbildung 2: Breadboard mit Schaltung für einen Taster mit Pull-Down Widerstand

Abb. 2: Breadboard mit Schaltung für einen Taster mit Pull-Down Widerstand

Achtung!
Der Taster hat vier Beinchen. Die beiden Beinchen in Reihe 45 und die beiden Beinchen in Reihe 47 sind im Taster durchkontaktiert. Die grüne Leitung hätte also auch oberhalb des Tasters in Reihe 45 gesteckt werden können.
Wird der Taster betätigt, wird eine Verbindung zwischen den Reihen 45 und 47 hergestellt.

Taster offen (nicht gedrückt)

In Abbildung 3 ist der Taster nicht betätigt. Über den Widerstand R1 ist der Eingang des Arduinos mit der Masse verbunden.

Abb. 3: Taster offen

Abb. 3: Taster offen

Der Widerstand R1 „zieht das Potential des Eingangs auf Masse“. Das bedeutet, dass am Eingang des Arduinos eine Spannung von 0V gegenüber Masse anliegt. In diesem Fall wird der Widerstand R1 auch Pull-Down Widerstand genannt, da er das Potential „runter zieht“. Der Eingang ist somit „LOW“ geschaltet.

Wir haben also ein wunderbar definiertes und sauberes Potential am Eingang (von 0V) und können damit sehr gut arbeiten.

Taster geschlossen (gedrückt)

Wird der Taster betätigt (siehe Abbildung 4), liegt auf einmal eine Spannung von 5V gegenüber Masse am Eingang des Arduinos an. Hier spricht man auch davon, dass der Eingang „HIGH“ geschaltet ist.

Abb. 4: Taster geschlossen

Abb. 4: Taster geschlossen

 

Größe des Widerstands R1

Jetzt wird auch klar, warum der Widerstand R1 einen Wert von 10k-100kOhm haben kann. Es soll ein möglichst kleiner (bis gar kein) Strom durch den Widerstand fließen, da wir nur das unterschiedliche Potential messen wollen. Laut Ohm’schen Gesetz fließt bei einem 100kOhm Widerstand ein Strom von:

I = U / R = 5V / 100kOhm = 0,05mA = 50µA

50µA sollten für unsere Zwecke klein genug sein. Bei anderen Anwendungsfällen für Pull-Down oder Pull-Up Widerstände musst Du den Widerstand ggf. anpassen.

 

Das Programm

Wir wollen beim Betätigen des Tasters (also wenn der Eingang des Arduinos HIGH ist) die LED am Ausgang D3 leuchten lassen. Für die Fallunterscheidung benötigen wir eine IF-Abfrage.

const int in_button1 = 7;     // An den Pin D7 ist der Taster angeschlossen.
const int out_LED1 =  3;      // Die LED ist am Pin D3 angeschlossen.

int i_buttonState1 = 0;      // In dieser Variablen speichern wir den Status des Eingangs.

void setup() {     
  pinMode(in_button1, INPUT); // Der Pin des Tasters wird als Eingang initialisiert.
  pinMode(out_LED1, OUTPUT);  // Der Pin der LED wird als Ausgang initialisiert.   
}

void loop(){
  // Wir lesen den Status des Eingangs aus und 
  // speichern den Wert in der Variablen
  i_buttonState1 = digitalRead(in_button1);

  if (i_buttonState1 == HIGH) {      // Ist der Taster gedrückt,
    digitalWrite(out_LED1, HIGH);    // dann schalte die LED an.
  } 
  else {                             // Ansonsten
    digitalWrite(out_LED1, LOW);     // schalte die LED wieder aus.
  }
  delay(50);                         // Eine kleine Pause von 50ms kann sicher nicht schaden.
}

Nach dem obligatorischen Hochladen des Programms können wir den Taster betätigen und die LED leuchtet.

Hier der Taster mit Pull-Down Widerstand:

 

Schaltung mit Pull-Up Widerstand

Was könnte nun eine Schaltung mit einem Pull-Up Widerstand sein? Richtig, wir tauschen einfach den Taster und den Widerstand R1.

Damit wir einen direkten Vergleich zur Schaltung mit dem Pull-Down Widerstand haben, fügen wir die neue Schaltung einfach mit hinzu. Die Änderungen bzw. Neuerungen siehst Du in Abbildung 5.

Abb. 5: Breadboard Taster PullUp_Steckplatine

Abb. 5: Breadboard mit Schaltung für einen Taster mit Pull-Up Widerstand

Wie verhält sich jetzt die Schaltung, wenn der Taster betätigt wird?

 

Taster offen (nicht gedrückt)

Wird der Taster nicht betätigt, sieht die Schaltung wie in Abbildung 6 aus.

Abb. 6: Taster offen

Abb. 6: Taster offen

Durch den Pull-Up Widerstand wird das Potential des Eingangs auf 5V gegenüber Masse hoch gezogen. Der Arduino misst also kontinuierlich eine Spannung von 5V, was bekanntlich einem HIGH Signal entspricht.

 

Taster geschlossen (gedrückt)

Sobald der Taster gedrückt wird, fällt die Spannung am Eingang des Arduinos auf 0V ab. Wir haben also ein sauberes LOW Signal.

Abb. 7: Taster geschlossen

Abb. 7: Taster geschlossen

Das Programm

Damit wir den Unterschied der zwei Schaltungs-Varianten besser erkennen, nehmen wir das Programm aus dem Pull-Down Widerstand Beispiel und kopieren möglichst viele Zeilen davon.

const int in_button1 = 7;          // An den Pin D7 ist der Taster angeschlossen.
const int out_LED1 =  3;           // Die LED ist am Pin D3 angeschlossen.

const int in_button2 = 8;          // Der neue Taster ist an Pin D8 angeschlossen.
const int out_LED2 =  5;           // Die zweite LED ist immernoch am Pin D5 angeschlossen.

int i_buttonState1 = 0;            // In dieser Variablen speichern wir den Status des Eingangs.
int i_buttonState2 = 0;            // Natürlich wollen wir auch den Status des zweiten Tasters speichern.

void setup() {     
  pinMode(in_button1, INPUT);      // Der Pin des ersten Tasters wird als Eingang initialisiert.
  pinMode(out_LED1, OUTPUT);       // Der Pin der ersten LED wird als Ausgang initialisiert. 
  
  pinMode(in_button2, INPUT);      // Dasselbe machen wir mit dem zweiten Eingang
  pinMode(out_LED2, OUTPUT);       // und mit der zweiten LED.   
}

void loop(){
  // Wir lesen den Status des Taster-Eingangs aus und speichern den Wert in der Variablen
  i_buttonState1 = digitalRead(in_button1);

  if (i_buttonState1 == HIGH) {     // Ist der Taster gedrückt,
    digitalWrite(out_LED1, HIGH);   // dann schalte die LED an.
  } 
  else {                           // Ansonsten
    digitalWrite(out_LED1, LOW);   // schalte die LED wieder aus.
  }
  
  // Auch der Wert des zweiten Tasters wird ausgelesen und in seiner Variablen gespeichert
  i_buttonState2 = digitalRead(in_button2);

  if (i_buttonState2 == HIGH) {    // Ist der zweite Taster NICHT gedrückt,
    digitalWrite(out_LED2, HIGH);  // dann schalte die LED an.
  } 
  else {                           // Ansonsten
    digitalWrite(out_LED2, LOW);   // schalte die LED aus.
  }
  delay(50);  // Wir wollen ja nicht hetzen und warten 50ms.
}

Wenn wir das Programm nun hochladen, wird die zweite LED dauerhaft leuchten. Erst wenn wir auf den Taster drücken, geht die LED aus. Die erste LED verhält sich genau anders herum. Das ist der Unterschied zwischen Pull-Up und Pull-Down Widerständen.

Das Video zeigt nun einen Taster mit Pull-Down Widerstand und einen zweiten Taster mit Pull-Up Widerstand:

 

Interne Pull-Up Widerstände

Arduinos, besser gesagt die auf ihnen verbauten Atmel Mikro-Controller, haben auch integrierte Pull-Up Widerstände mit 20kOhm. Bisher habe ich mit ihnen gemischte Erfahrungen gemacht, weswegen ich möglichst auf externe Pull-Up und Pull-Down Widerstände zurückgreife.

Die internen Pull-Up Widerstände sind ebenfalls mit der Versorgungs-Spannung des Arduinos verbunden. Sie ziehen den Eingang also auf die bekannten 5V hoch.

Zum Aktivieren der internen Pull-Up Widerstände muss lediglich die Initialisierung des Eingangs verändert werden. Die Befehlszeile heißt dann:

pinMode(in_button, INPUT_PULLUP);

Mehr ist nicht nötig, um den externen zusätzlichen Widerstand weglassen zu können. Die entsprechende Schaltung ist dann natürlich beliebig einfach. Richtig, es muss lediglich der letzte Widerstand und eine 5V-Leitung entfernt werden.

Achtung!

Es gibt lediglich interne Pull-Up Widerstände. Möchtest Du einen Pull-Down Widerstand nutzen, musst Du ihn immer extern anschließen.

Abb. 8: Breadboard mit Schaltung für einen internen Pull-Up Widerstand

Abb. 8: Breadboard mit Schaltung für einen internen Pull-Up Widerstand

Langsam wird es richtig interessant. Jetzt können wir also schon digitale Eingänge eines Arduinos auslesen und nutzen. Als nächstes schauen wir uns analoge Eingänge genauer an.


Arduino Grundlagen Kurs im Überblick:

>> Teil 1: Der Arduino im Detail
>> Teil 2: Die Bauteile des Arduino
>>Teil 3: Ein Programm auf einen Arduino laden
>> Teil 4: Eine LED blinken lassen!
>> Teil 5: Eine externe LED blinken lassen
>> Teil 6: Die LED Schaltung im Detail
>> Teil 7: Mehrere LEDs ansteuern & blinken lassen
>> Teil 8: Eine LED dimmen
>> Teil 9: Mehrere LEDs dimmen
>> Teil 10: Taster an Arduino anschließen
>> Teil 11: Serielle Schnittstelle
>> Teil 12: Softwareserial Library

2 Kommentare zu "Arduino Grundlagen Teil 10: Taster an Arduino anschließen"

  1. Sind beim Bild 4 wirklich die roten Werte korrekt?

    • Hallo Uli,
      die Werte sind korrekt. Zwischen 5V und dem Eingang befindet sich kein Widerstand, da der Taster geschlossen ist (die Übergangswiderstände innerhalb eines Tasters können normalerweise vernachlässigt werden). Dadurch gibt es keinen Potential-Unterschied zwischen den beiden. Aber zwischen dem Eingang und 5V gegenüber der Masse/GND befindet sich ein Widerstand. In diesem fällt somit die gesamte Spannung von 5V ab.
      Viele Grüße, Micha

Hinterlasse einen Kommentar

E-Mail Adresse wird nicht veröffentlicht.


*


*