Leuchtdiode & Taster

Einfaches Eingabeelement zur Benutzerinteraktion und Ereignisauslösung.

• Übersicht
• Technische Daten
• Pinbelegung & Anschluss
  • Anschlussschema
  • Hinweise zur Verdrahtung
• Funktionsweise
• Beispielcode
  • MicroPython
  • C (Arduino Framework)
  • C (Arduino mit Interrupt)
• Anwendungsbeispiele
  • Taster mit LED kombinieren
  • Toggle-Funktion
  • Langer vs. kurzer Tastendruck
• Tipps & häufige Fehler
• Weiterführende Links

#Übersicht

Ein Taster ist ein mechanischer Schalter, der bei Betätigung einen Stromkreis schließt oder öffnet. Taster eignen sich für Benutzereingaben, Menünavigation, Spielsteuerung und das Auslösen von Aktionen. Der Taster auf diesem Lernboard ist High-aktiv konfiguriert, d.h. bei Betätigung liegt ein HIGH-Signal (3.3V) am GPIO an.

#Technische Daten

#Pinbelegung & Anschluss

#Anschlussschema

#Hinweise zur Verdrahtung

• High-aktiv: Bei gedrücktem Taster liegt 3.3V am GPIO an (HIGH)
• Pull-down: Ein Pull-down-Widerstand sorgt für definiertes LOW-Signal im Ruhezustand
• Bei Lernboards: Pull-down-Widerstand ist oft bereits integriert

#Funktionsweise

Der Taster auf dem Lernboard ist High-aktiv beschaltet:

    3.3V
     |
     |
   [Taster]
     |
     +----> GPIO3
     |
    [R] Pull-down (z.B. 10kΩ)
     |
    GND

    
    
    
    Copy

• Taster offen: Der Pull-down-Widerstand zieht den GPIO auf GND → LOW (0)
• Taster gedrückt: 3.3V wird direkt mit dem GPIO verbunden → HIGH (1)

Prellen: Mechanische Taster prellen beim Betätigen, d.h. der Kontakt öffnet und schließt mehrfach in kurzer Zeit. Dies muss in der Software behandelt werden (Entprellung/Debouncing).

#Beispielcode

#MicroPython

from machine import Pin
from time import sleep, sleep_ms, ticks_ms, ticks_diff

# Taster an GPIO3 (High-aktiv)
BUTTON_PIN = 3

# ===== Einfaches Auslesen =====

button = Pin(BUTTON_PIN, Pin.IN)

print("Einfaches Auslesen (5 Sekunden)...")
for _ in range(50):
    state = button.value()
    print(f"Taster: {'GEDRÜCKT' if state else 'offen'}")
    sleep(0.1)


# ===== Mit Software-Entprellung =====

class DebouncedButton:
    def __init__(self, pin, debounce_ms=50):
        self.pin = Pin(pin, Pin.IN)
        self.debounce_ms = debounce_ms
        self.last_state = self.pin.value()
        self.last_change = ticks_ms()
        self.stable_state = self.last_state
    
    def read(self):
        """Liest entprellten Tasterzustand."""
        current = self.pin.value()
        now = ticks_ms()
        
        if current != self.last_state:
            self.last_change = now
            self.last_state = current
        
        if ticks_diff(now, self.last_change) > self.debounce_ms:
            self.stable_state = current
        
        return self.stable_state
    
    def is_pressed(self):
        """Gibt True zurück, wenn Taster gedrückt ist."""
        return self.read() == 1
    
    def was_pressed(self):
        """Gibt True zurück bei Flanke (losgelassen -> gedrückt)."""
        old_state = self.stable_state
        new_state = self.read()
        return old_state == 0 and new_state == 1


button = DebouncedButton(BUTTON_PIN)

print("Entprelltes Auslesen...")
press_count = 0
while True:
    if button.was_pressed():
        press_count += 1
        print(f"Tastendruck #{press_count} erkannt!")
    sleep_ms(10)


# ===== Mit Interrupt =====

button_pressed = False

def button_handler(pin):
    global button_pressed
    button_pressed = True

button = Pin(BUTTON_PIN, Pin.IN)
button.irq(trigger=Pin.IRQ_RISING, handler=button_handler)

print("Warte auf Tastendruck (Interrupt)...")
while True:
    if button_pressed:
        print("Taster wurde gedrückt!")
        button_pressed = False
        sleep_ms(200)  # Einfache Entprellung
    sleep_ms(10)

    
    
    
    Copy

#C (Arduino Framework)

// Taster an GPIO3 (High-aktiv)
#define BUTTON_PIN 3

// Entprellzeit in Millisekunden
#define DEBOUNCE_TIME 50

// Variablen für Entprellung
int lastButtonState = LOW;
int buttonState = LOW;
unsigned long lastDebounceTime = 0;;

// Zähler für Tastendrücke
int pressCount = 0;;

void setup() {
    Serial.begin(115200););
    
    // Taster als Eingang konfigurieren
    pinMode(BUTTON_PIN, INPUT);
    
    Serial.println("Taster-Test - Lernboard");
    Serial.println("Drücke den Taster...");
}

void loop() {
    // Aktuellen Zustand lesen
    int reading = digitalRead(BUTTON_PIN);
    
    // Prüfen, ob sich der Zustand geändert hat
    if (reading != lastButtonState) {
        lastDebounceTime = millis();
    }
    
    // Wenn der Zustand stabil ist (länger als Entprellzeit)
    if ((millis() - lastDebounceTime) > DEBOUNCE_TIME) {
        // Wenn sich der stabile Zustand geändert hat
        if (reading != buttonState) {
            buttonState = reading;
            
            // Bei steigender Flanke (Taster gedrückt)
            if (buttonState == HIGH) {
                pressCount++;
                Serial.printf("Tastendruck #%d erkannt!\n", pressCount);
            }
        }
    }
    
    lastButtonState = reading;
}

    
    
    
    Copy

#C (Arduino mit Interrupt)

// Taster an GPIO3 (High-aktiv)
#define BUTTON_PIN 3

// Volatile für Interrupt-Zugriff
volatile bool buttonPressed = false;
volatile unsigned long lastInterruptTime = 0;;

// Zähler für Tastendrücke
int pressCount = 0;;

// Interrupt Service Routine
void IRAM_ATTR buttonISR() {
    unsigned long interruptTime = millis();
    
    // Entprellung: Interrupts innerhalb von 200ms ignorieren
    if (interruptTime - lastInterruptTime > 200) {) {
        buttonPressed = true;
        lastInterruptTime = interruptTime;
    }
}

void setup() {
    Serial.begin(115200););
    
    // Taster als Eingang konfigurieren
    pinMode(BUTTON_PIN, INPUT);
    
    // Interrupt bei steigender Flanke (HIGH-aktiv)
    attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), buttonISR, RISING);
    
    Serial.println("Taster-Test mit Interrupt - Lernboard");
    Serial.println("Drücke den Taster...");
}

void loop() {
    if (buttonPressed) {
        pressCount++;
        Serial.printf("Tastendruck #%d erkannt!\n", pressCount);
        buttonPressed = false;
    }
    
    // Hier kann anderer Code ausgeführt werden
    delay(10););
}

    
    
    
    Copy

#Anwendungsbeispiele

#Taster mit LED kombinieren

# MicroPython - LED folgt Taster
from machine import Pin

led = Pin(2, Pin.OUT)
button = Pin(3, Pin.IN)

while True:
    # LED spiegelt Tasterzustand
    led.value(button.value())

    
    
    
    Copy

#Toggle-Funktion

# MicroPython - LED umschalten bei Tastendruck
from machine import Pin
from time import sleep_ms, ticks_ms, ticks_diff

led = Pin(2, Pin.OUT)
button = Pin(3, Pin.IN)

led_state = False
last_press = 0

while True:
    if button.value() == 1:
        now = ticks_ms()
        if ticks_diff(now, last_press) > 200:  # Entprellung
            led_state = not led_state
            led.value(led_state)
            print(f"LED: {'AN' if led_state else 'AUS'}")
            last_press = now
    sleep_ms(10)

    
    
    
    Copy

#Langer vs. kurzer Tastendruck

# MicroPython - Unterscheidung kurz/lang
from machine import Pin
from time import ticks_ms, ticks_diff, sleep_ms

button = Pin(3, Pin.IN)
LONG_PRESS_MS = 1000

press_start = 0
was_pressed = False

while True:
    if button.value() == 1 and not was_pressed:
        # Taster gerade gedrückt
        press_start = ticks_ms()
        was_pressed = True
    
    elif button.value() == 0 and was_pressed:
        # Taster losgelassen
        duration = ticks_diff(ticks_ms(), press_start)
        was_pressed = False
        
        if duration >= LONG_PRESS_MS:
            print(f"LANGER Tastendruck ({duration} ms)")
        else:
            print(f"Kurzer Tastendruck ({duration} ms)")
    
    sleep_ms(10)

    
    
    
    Copy

#Tipps & häufige Fehler

• Taster reagiert nicht: Prüfen, ob der GPIO korrekt als Eingang konfiguriert ist. Bei High-aktiver Beschaltung muss ein Pull-down vorhanden sein.

• Mehrfache Auslösung: Fehlende Entprellung. Mechanische Taster prellen und erzeugen mehrere Flanken. Software-Debouncing implementieren.

• Unerwartete Werte im Ruhezustand: Ohne Pull-down-Widerstand ist der GPIO-Pegel undefiniert (floating). Der Lernboard-Taster hat bereits einen Pull-down integriert.

• Interrupt löst mehrfach aus: Prellen kann auch Interrupts mehrfach auslösen. Zeitbasierte Entprellung in der ISR verwenden.

• Blockierendes Warten: while button.value() == 0: pass blockiert das Programm. Besser: Polling im Hauptloop oder Interrupts verwenden.

• Lange ISR: Interrupt Service Routines sollten kurz sein. Nur Flags setzen, Verarbeitung im Hauptprogramm.

#Weiterführende Links

• Taster entprellen (Mikrocontroller.net)
• ESP32 GPIO (Espressif Docs)
• Arduino Debounce Tutorial