Taster Modul (KY-004) + ESP32 Tutorial

Übersicht – Taster Modul KY-004 + ESP32

Bevor wir mit dem Verkabeln und Programmieren deines Projekts starten, werfen wir einen Blick darauf, was du für dieses Tutorial benötigst. Das Taster Modul KY-004 ist ein einfaches, aber vielseitiges Bauteil, das perfekt ist, um digitale Eingänge am ESP32 zu verstehen. Da ein Taster allein nicht viel ausrichtet, kombinieren wir ihn für eine sinnvolle Anwendung.

Was du brauchst:

1x ESP32 (Mikrocontroller)
1x Taster Modul KY-004 – Der eigentliche Sensor, der uns ein digitales Signal liefert (gedrückt/nicht gedrückt).
3x Verbindungskabel (Dupont-Kabel)

Pinout – Taster Modul KY-004

Das Taster Modul KY-004 ist denkbar einfach aufgebaut. Es verfügt über drei Anschlusspins, die für die grundlegende Funktion mit deinem ESP32 notwendig sind. Du musst lediglich wissen, welcher Pin für die Stromversorgung, die Masse und das eigentliche digitale Signal des Tasters zuständig ist.

Das Modul besitzt die folgenden drei Pins, die du mit dem ESP32 verbinden musst:
– (Masse/GND): Wird mit dem GND-Pin des ESP32 verbunden.
+ (Spannung/VCC): Wird mit der 3.3V- oder 5V-Stromversorgung (je nach Tasterversion, 3.3V ist sicherer für den ESP32) des ESP32 verbunden.
S (Signal): Der digitale Signal-Pin, der den Zustand des Tasters (gedrückt/nicht gedrückt) an einen digitalen GPIO-Pin des ESP32 sendet.

Hardware Aufbau / Verkabelung / Schaltungsaufbau

Der Aufbau der Schaltung zwischen dem Taster Modul KY-004 und deinem ESP32 ist denkbar einfach und schnell erledigt. Du stellst insgesamt drei Verbindungen her: Zuerst verbindest du den GND-Pin deines ESP32 mit dem Minus-Pin (-) des Moduls. Dann versorgst du das Modul mit Strom, indem du den 3,3V-Pin deines ESP32 mit dem Plus-Pin (+) des Taster Modul KY-004 verbindest. Schließlich leitest du das digitale Signal vom Modul an den digitalen Pin D15 des ESP32, indem du den Signal-Pin (S) des Tasters mit D15 verbindest.

ESP32 GND → KY-004 GND-Pin

ESP32 3,3V → KY-004 VCC-Pin

ESP32 D15 → KY-004 Signal-Pin

Eine sorgfältige und korrekte Verdrahtung ist entscheidend, damit dein ESP32 die Signale des Taster Modul KY-004 ordnungsgemäß erfassen kann.
Sobald du diese Verbindungen erfolgreich hergestellt hast, bist du bereit, mit der Programmierung fortzufahren. Im nächsten Abschnitt gehen wir ausführlich darauf ein, wie du den Code für das Taster Modul KY-004 auf deinem ESP32 programmierst.

Software / Code / Programmierung

Sobald du den Hardware-Aufbau erfolgreich abgeschlossen hast, wenden wir uns der Programmierung für den ESP32 zu. In diesem Abschnitt behandeln wir die essenziellen Schritte zur Code-Erstellung und erklären dir die Schlüsselfunktionen, die wir für das Taster Modul KY-004 verwenden werden.

Schritt 1: IDE Projekt
Zuerst geht’s ans Öffnen der Arduino-IDE und das Erstellen eines neuen Projekts.
Um mit der Arduino-IDE arbeiten zu können, musst du die Anwendung auf deinem Computer starten. Falls du die IDE noch nicht installiert hast, findest du unter folgendem Link eine Anleitung hierzu:
[Hier Link zur Installationsanleitung einfügen]
Nach dem Start der Arduino-IDE erstellst du ein neues Projekt. Klicke dazu auf „Datei“ und wähle „Neu“ aus. Dies öffnet ein neues Sketch-Fenster, in das du später deinen Code eingeben kannst.

// Hier kommt dein Code
void setup()
{
  // Initialisierung
}

void loop()
{
  // Schleife
}

Schritt 2: Bibliothek einbinden
Um die Daten des Taster Modul KY-004 auszulesen, ist es oft notwendig, Bibliotheken einzubinden.
Glücklicherweise benötigt das Taster Modul KY-004 keine spezielle Bibliothek, da wir den Zustand direkt über digitale Ein- und Ausgänge (GPIOs) des ESP32 auslesen können.

Schritt 3: Initialisierung
Vor der setup()-Funktion definieren wir Konstanten und Variablen, die im gesamten Programm verwendet werden. Mit #define S_PIN 15 legen wir fest, dass der Signal-Pin des Taster Modul KY-004 an den GPIO 15 des ESP32 angeschlossen ist – das macht den Code lesbarer. Zusätzlich deklarieren wir die Integer-Variable value, die später den ausgelesenen Zustand des Tasters speichern wird.

#define S_PIN 15 // Pin S an Pin 15
int value; // Temporäre Variable

Schritt 4: Void Setup
Die void setup()-Funktion wird nur einmal beim Start deines ESP32 ausgeführt. Hier initialisieren wir die serielle Kommunikation (Serial.begin(9600)), damit wir die Ergebnisse später am PC überwachen können. Der wichtigste Schritt ist pinMode(S_PIN, INPUT), der den GPIO 15 als Eingang konfiguriert, um das Signal des Taster Modul KY-004 zu empfangen. Abschließend aktivieren wir mit digitalWrite(S_PIN, HIGH) den internen Pull-up-Widerstand des ESP32, was bei einem Tastermodul die Schaltung vereinfacht.

void setup() {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  
  pinMode(S_PIN, INPUT); // Signal-Pin als Input deklarieren
  digitalWrite(S_PIN, HIGH); // Aktivierung interner Pull-up-Widerstand
}

Schritt 5: Loop Setup
Die void loop()-Funktion läuft nach dem setup() unendlich oft durch. Im ersten Schritt lesen wir mit digitalRead(S_PIN) den aktuellen Zustand des Taster-Pins aus und speichern ihn in der Variable value. Anschließend folgt eine if-Bedingung: Wenn der ausgelesene Wert LOW ist (was bei einem Pull-up-Widerstand bedeutet, dass der Taster gedrückt wurde), geben wir die Meldung „Taster gedrückt“ über die serielle Schnittstelle aus. Eine kleine Verzögerung von 300 Millisekunden (delay(300)) verhindert, dass der Taster einmaliges Drücken als mehrfaches Drücken registriert (sogenanntes „Bouncing“).

void loop() {
  value = digitalRead(S_PIN); // Signal am Sensor ausgelesen
  
  if (value == LOW) { //Wenn Signal erkannt
    Serial.println("Taster gedrückt");
    delay(300); // Verzögerung zur Stabilität
  }
}

Gesamter Code – Taster Modul KY-004

Hier siehst du noch einmal zur Übersicht den gesamten Programmier-Code für das Taster Modul KY-004 und den ESP32 aufgeführt. Du kannst diesen Code direkt in deine Arduino-IDE kopieren, auf deinen ESP32 hochladen und anschließend über den seriellen Monitor testen.

#define S_PIN 15 // Pin S an Pin 15
int value; // Temporäre Variable
  
void setup() {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  
  pinMode(S_PIN, INPUT); // Signal-Pin als Input deklarieren
  digitalWrite(S_PIN, HIGH); // Aktivierung interner Pull-up-Widerstand
}
  
void loop() {
  value = digitalRead(S_PIN); // Signal am Sensor ausgelesen
  
  if (value == LOW) { //Wenn Signal erkannt
    Serial.println("Taster gedrückt");
    delay(300); // Verzögerung zur Stabilität
  }
}

Ausführung / Anwendung

Nachdem du den Code in die IDE eingegeben hast, muss dieser nun ausgeführt und auf deinen ESP32 übertragen werden. Der Prozess ist unkompliziert und lässt sich in wenigen Schritten durchführen:
Anleitung zur Code-Übertragung
Schritt 1: Kompilieren (Haken-Symbol): Klicke auf das Haken-Symbol (Überprüfen) in der Arduino-IDE. Dies prüft deinen Code auf Fehler und bereitet ihn für den ESP32 vor.
Schritt 2: Hochladen (Pfeil-Symbol): Klicke anschließend auf das Pfeil-Symbol (Hochladen). Der kompilierte Code wird nun über das USB-Kabel auf deinen ESP32 übertragen.
Schritt 3: Serieller Monitor öffnen: Öffne den Seriellen Monitor (meist über das Lupen-Symbol oben rechts), um die Ausgaben deines ESP32 zu sehen. Stelle sicher, dass die Baudrate auf 9600 eingestellt ist, wie im Code festgelegt.
Schritt 4: Taste drücken: Drücke das Taster Modul KY-004. Auf dem Seriellen Monitor sollte nun die Meldung „Taster gedrückt“ erscheinen, was bestätigt, dass der ESP32 das Signal korrekt vom Sensor Modul empfängt.

Weitere Themen

BME280 – ESP32

DHT11 – ESP32

OLED Display – ESP32