Szenario 1

Der obige Aufbau funktioniert ohne einen Sketch und nutzt nur die elektrischen Eigenschaften der verwendeten Bauteile aus. Der Mikrocontroller dient hier „nur“ als Spannungsquelle. Drückt man den Taster, so leuchtet die LED so lange auf, wie der Taster gedrückt wird. Lässt man den Taster los, erlischt die LED.

Szenario 2

Will man die LED über den Taster zwar schalten, aber die Steuerung dem Mikrocontroller überlassen, benötigt man einen Pin, der den Zustand des Schalters liest -also einen Eingang-, und einen Pin, der die LED steuert -einen Ausgang. Im folgenden Sketch wird Pin 2 als Eingang und Pin 15 als Ausgang genutzt.

#include <Arduino.h>
/* -------------------------------------
    Praxis 7 -Szenario 2
    LED mit Taster steuern
    LED an GPIO 0, Taster an GPIO 4
    -----------------------------------*/
int ledPin = 0;
int tastPin = 4;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(tastPin, INPUT);
}

void loop() {
  if (digitalRead(tastPin)== true) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

Ist der obige Sketch auf den Mikrocontroller übertragen und der nebenstehende Aufbau richtig erstellt, leuchtet die LED zwar sicher, wenn der Taster gedrückt ist, lässt man ihn aber los, kann es sein, dass die LED weiterhin leuchtet oder auch aufflammt/erlischt, wenn man die Kabel berührt. Dies liegt daran, dass bei offenem Taster nicht klar ist, welche Spannung an Pin 2 ankommt. Ein Strom kann nicht fließen, aber die Spannung/das Potenzial des Eingangs ist offen und somit unbekannt. Der digitale Eingang von Pin 2 nutzt einen Schwellenwert, ist dieser überschritten, ist der digitale Wert „true“, sonst „false“.

Um dieses Problem zu lösen, muss man den „offenen“ Stromkreis auf ein definiertes Potenzial bringen (vgl. Logikpegel). Dies geschieht durch einen sogenannten Pullup- bzw. Pulldown-Widerstand. Dieser ist recht groß gewählt (10kΩ) damit ist sichergestellt, dass bei geschlossenem Taster das Potenzial der anderen Taster-Seite angenommen wird.

Ändert man den Aufbau in die linke untere Variante um, hat man den zweiten Widerstand als Pulldown-Widerstand eingesetzt. Dieser sorgt dafür, dass an Pin 2 Ground anliegt, wenn der Taster offen ist. Die rechte Variante zeigt den Widerstand als PullUp-Widerstand. Baut man diese Variante mit dem obigen Sketch auf, leuchtet die LED bei offenem Taster und erlischt solange der Taster gedrückt ist.

Szenario 3

Die Verwendung von PullUp- oder PullDown-Widerständen ist etwas aufwändig auf der Schaltungsseite, daher haben Mikrocontroller oft die Möglichkeit eingebaut diese Widerstände im Mikrocontroller „zwischenzuschalten“. Der ESP32 kann sowohl PullUp- als auch PullDown-Widerstände nutzen. Im Sketch nutzt man dies beim Setup des Eingangs: pinMode(tastPin, INPUT_PULLUP);

Ändert man den Sketch aus Szenario 2 die Zeile pinMode(tastPin, INPUT); entsprechend ab und nutzt den rechten Aufbau (auch ohne zweiten Widerstand), dann leuchtet die LED bei offenem Taster und erlischt bei beim Drücken des Tasters.

Szenario 4

Nun soll ausgehend von dem Aufbau in Szenario 3 die LED beim Drücken des Tasters den Schaltzustand ändern. Dies setzt einen anderen Sketch voraus, denn der Schaltzustand der LED sollte in einer boolean Variable gespeichert werden und auch der Zustand des Tasters muss gemerkt werden, damit ein langer Druck auf den Taster von zwei oder mehreren kurzen unterschieden werden kann.

#include <Arduino.h>
/* -------------------------------------
    Praxis 7 -Szenario 4
    LED mit Taster steuern
    LED an GPIO 0, Taster an GPIO 4
   -----------------------------------*/
int ledPin = 0;
int tastPin = 4;
boolean ledZust = false;
boolean lTastZust = true;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(tastPin, INPUT_PULLUP);
}
 
void loop() {
  boolean tastZust = digitalRead(tastPin);
  if (lTastZust && !tastZust) {       // Zuletzt offen, jetzt gedrückt
    ledZust = !ledZust;
    digitalWrite(ledPin, ledZust);
  }
  lTastZust = tastZust;
}

Zu beachten bei dem Sketch ist, dass bei offenem Taster digitalRead(tastPin) ein „true“ bzw. „HIGH“ zurückgibt, da PULLUP benutzt wird. Hat man den Sketch in dieser Form auf den Mikrocontroller mit dem passenden Aufbau der Schaltung geladen, funktioniert der Taster manchmal wie gewünscht, ein andermal allerdings nicht. Dies liegt daran, dass Taster „prellen“, d.h. nicht sauber von einem zu dem anderen Zustand umschalten, sondern eine sehr kurze Zeit lang zwischen den beiden Zuständen wechseln, wenn man sie betätigt oder loslässt. Dieses Problem ließe sich elektronisch durch einen Kondensator lösen, der für eine ausreichend kurze Zeit trotz des Prellens den Schaltzustand des Pins „festhält“, oder man ändert den Sketch. Für die letzte Variante gibt es verschiedene Möglichkeiten, die einfachste ist bei jeder Änderung des Tasterzustandes kurz zu warten, bis sich der Schaltzustand stabilisiert hat. Dafür genügen wenige Millisekunden. Als elegantere Varianten gibt es auch Bibliotheken, die Taster per Code entprellen.

#include <Arduino.h>
/* -------------------------------------
    Praxis 7 -Szenario 4a
    LED mit Taster steuern
    LED an GPIO 0, Taster an GPIO 4
    mit Entprellung
   -----------------------------------*/
int ledPin = 0;
int tastPin = 4;
boolean ledZust = false;
boolean lTastZust = true;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(tastPin, INPUT_PULLUP);
}
 
void loop() {
  boolean tastZust = digitalRead(tastPin);
  if (lTastZust && !tastZust) {       // Zuletzt offen, jetzt gedrückt
    ledZust = !ledZust;
    digitalWrite(ledPin, ledZust);
  }
  if (lTastZust != tastZust) {
    lTastZust = tastZust;
    delay(10);
  }
}

Bei dieser Variante merkt man vor allem bei längerem Halten des Tasters, dass auf die „erste Flanke“, d.h. beim Wechsel von Offen nach Gedrückt, geschaltet wird. Sollte das anders gewünscht sein, muss Zeile mit dem Kommentar dahingehend geändert werden, dass das Ausrufezeichen vor "lTastZust" verschoben wird.