Klopf-Sensor (KY-031) + ESP32 Tutorial

Übersicht – KY-031 und ESP32

Um dein KY-031 Klopfsensor-Projekt mit dem ESP32 zu starten, brauchst du nur wenige Komponenten. Der Klopfsensor ist ein digitales Modul. Der ESP32 bietet uns dabei die nötige Rechenleistung und WLAN-Fähigkeit für spannende Anwendungen.

Hier ist eine kurze Übersicht über die benötigten Teile:

1x ESP32 (Mikrocontroller)
1x KY-031 Modul (Klopfsensor)
3x Verbindungskabel (Dupont-Kabel)

Pinout – KY-031

Das KY-031 Modul, unser Klopfsensor, ist denkbar einfach aufgebaut. Es verfügt über insgesamt 3 Pins, die für die Stromversorgung und die Datenübertragung zuständig sind. Der Sensor gibt ein digitales Signal aus, sobald eine Vibration erkannt wird.

Die Pins sind wie folgt belegt:
– (GND): Hier schließt du die gemeinsame Masse (Ground) an.
+ (VCC): Das ist der positive Anschluss für die Stromversorgung.
S (Signal): Über diesen digitalen Pin erhältst du das Signal (LOW oder HIGH), sobald der Sensor eine Vibration registriert.

Hardware Aufbau / Verkabelung / Schaltungsaufbau

Die Verbindung zwischen deinem ESP32 und dem KY-031 Klopfsensor ist schnell erledigt, da nur drei Verbindungen nötig sind. Du musst lediglich die Stromversorgung und den Signal-Pin miteinander verkabeln. Verbinde dazu den GND-Pin deines ESP32 mit dem -Pin des KY-031 und den 3,3V-Pin des ESP32 mit dem +Pin des Sensors. Das digitale Signal des Klopf-Sensors S-Pins führst du auf den GPIO-Pin D15 deines ESP32.

ESP32 GND → KY-031 -Pin

ESP32 3,3V→ KY-031 +Pin

ESP32 D15 → KY-031 S-Pin

Die korrekte und sorgfältige Verdrahtung ist entscheidend, damit der ESP32 die Signale des KY-031 ordnungsgemäß erfassen kann.
Nachdem 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 den Kopf-Sensor programmieren kannst.

Software / Code / Programmierung

Sobald der erfolgreiche Hardware-Aufbau abgeschlossen ist, können wir uns nun der Programmierung des ESP32 zuwenden. In diesem Abschnitt werden wir ausführlich die essentiellen Schritte zur Codeerstellung behandeln und die Schlüsselfunktionen, die du verwenden wirst, im Detail erläutern.

Schritt 1: IDE Projekt
Beginne damit, die Arduino-IDE zu öffnen und ein neues Projekt zu erstellen.
Um mit der Arduino-IDE zu arbeiten, öffne zuerst die Anwendung auf deinem Computer. Falls du die Arduino-IDE noch nicht installiert hast, kannst du unter folgendem Link eine Anleitung hierzu finden.
>
Nachdem du die Arduino-IDE geöffnet hast, erstellst du ein neues Projekt, indem du auf „Datei“ und anschließend auf „Neu“ klickst. Dadurch wird ein neues Sketch-Fenster geöffnet, in dem du deinen Code eingeben kannst.

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

void loop(){
  // Schleife
}

Schritt 2: Bibliothek einbinden
Um die Daten des KY-031 auszulesen, benötigst du fkeine zusätzliche Bibliothek. Wir können direkt mit den Standardfunktionen arbeiten, da das Modul ein einfaches digitales HIGH/LOW-Signal liefert.

Schritt 3: Initialisierung
Der Abschnitt vor der setup()-Funktion ist der globale Deklarationsbereich. Hier definierst du alle Variablen, die im gesamten Code verwendet werden sollen, und weist ihnen gegebenenfalls Startwerte zu. Für unser Projekt legen wir hier fest, mit welchem GPIO-Pin des ESP32 der KY-031 verbunden ist (data_pin = 15) und deklarieren eine temporäre Variable (sensor_signal) vom Typ int, um den aktuellen Zustand des Sensorsignals zu speichern.

#define data_pin 15 //D15
int sensor_signal; // Temporäre Variable

Schritt 4: Void Setup
In der void setup()-Funktion wird der Code platziert, der nur einmal beim Start des ESP32 ausgeführt werden soll. Zuerst initialisierst du die serielle Kommunikation (Serial.begin(9600)), damit du später die Ergebnisse auf deinem Computer auslesen kannst. Anschließend wird der Daten-Pin des Sensors als EINGANG (pinMode(data_pin, INPUT)) definiert, da wir hier Signale vom Sensor empfangen.

void setup () {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  delay(500); // 500ms Pause
  pinMode(data_pin, INPUT); // Initialisierung des Daten-Pins
  Serial.println("Initialisierung abgeschlossen");
}

Schritt 5: Loop Setup
Die void loop()-Funktion ist das Herzstück deines Programms und wird in einer Endlosschleife ausgeführt. Zuerst liest du hier kontinuierlich das Signal vom definierten Pin aus und speicherst es in der Variable sensor_signal (digitalRead()). Anschließend prüfst du in einer if-Abfrage, ob der Sensor ein Klopfen erkannt hat, was beim KY-031 durch ein LOW-Signal ausgelöst wird. Bei Erkennung gibst du eine Nachricht auf der seriellen Konsole aus und fügst eine kurze Verzögerung ein, um Entprellung (Debouncing) zu ermöglichen und Mehrfachauslösungen zu vermeiden.

void loop () {
  sensor_signal = digitalRead(data_pin); // Signal am Sensor auslesen
 
  // Wenn ein Signal erkannt wird
  if (sensor_signal == LOW) {
    Serial.println("Klopfen erkannt");
    delay(200); // 200ms Pause
  }
}

Gesamter Code – KY-031

Nach der detaillierten Erklärung der einzelnen Code-Abschnitte zeigen wir dir hier noch einmal zur Übersicht den gesamten Programmier-Code auf, den du für den KY-031 Klopfsensor mit dem ESP32 verwenden kannst.

#define data_pin 15 //D15
int sensor_signal; // Temporäre Variable

void setup () {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  delay(500); // 500ms Pause
  pinMode(data_pin, INPUT); // Initialisierung des Daten-Pins
  Serial.println("Initialisierung abgeschlossen");
}

void loop () {
  sensor_signal = digitalRead(data_pin); // Signal am Sensor auslesen
 
  // Wenn ein Signal erkannt wird
  if (sensor_signal == LOW) {
    Serial.println("Klopfen erkannt");
    delay(200); // 200ms Pause
  }
}

Ausführung / Anwendung

Nachdem der Code nun in die IDE eingegeben ist, muss dieser noch ausgeführt und auf den ESP32 übertragen werden.
Um dein Klopfsensor-Projekt zu starten und die Ergebnisse zu sehen, folge diesen einfachen Schritten in der Arduino IDE:
Schritt 1: Kompilieren (Haken)
Klicke auf das Haken-Symbol oben links in der IDE. Dies kompiliert deinen Code und prüft ihn auf Fehler, bevor er auf den ESP32 übertragen wird.

Schritt 2: Hochladen (Pfeil)
Klicke anschließend auf das Pfeil-Symbol (rechts neben dem Haken). Dadurch wird der kompilierte Code auf deinen angeschlossenen ESP32 übertragen.

Schritt 3: Serieller Monitor öffnen
Nachdem der Upload abgeschlossen ist, öffne den Seriellen Monitor (meist das Lupen-Symbol oben rechts in der IDE) und stelle die Baudrate auf 9600 ein.

Schritt 4: Klopfen erkennen
Wenn du nun auf deinen KY-031 Sensor klopfst oder ihn erschütterst, wird dir im Seriellen Monitor die Nachricht „Klopfen erkannt“ angezeigt, was die erfolgreiche Funktion deines ESP32 und des Sensors bestätigt.

Weitere Themen

DHT11 + ESP32

OLED Display + ESP32

Taster Modul + ESP32