Vibrationsmotor + ESP32 Tutorial

Übersicht – Vibrationsmotor + ESP32

Um diesen einfachen Aufbau zu realisieren und deinen Vibrationsmotor mit dem ESP32 zum Laufen zu bringen, brauchst du nur wenige Komponenten. Der ESP32 ist ein leistungsstarker Mikrocontroller, der in der Lage ist, nicht nur den Vibrationsmotor, sondern auch gleichzeitig andere Sensoren oder Displays anzusteuern. Du kannst den ESP32 also vielseitig einsetzen. Hier siehst du, was genau du für den Start benötigst:
1x der ESP32 (Mikrocontroller)
1x Vibrationsmotor
3 x Verbindungskabel (Dupont-Kabel)

Pinout – Vibrationsmotor

Der Vibrationsmotor kommt als fertiges Modul meist mit drei Anschlüssen, was die Ansteuerung mit dem ESP32 sehr einfach macht. Du benötigst Pins für die Stromversorgung und einen Steuerungseingang. GND und VCC versorgen das Modul mit Energie, während der IN-Pin das digitale Steuersignal vom ESP32 empfängt, um die Vibration zu starten.
Hier ist eine Übersicht der 3 Pins:

GND (Ground): Der Masseanschluss.
VCC: Pin für die Spannungsversorgung des Moduls.
IN (Input / Daten-Pin): Der digitale Eingangspin, den du mit einem GPIO-Pin deines ESP32 verbindest.

Hardware Aufbau / Verkabelung / Schaltungsaufbau

Der Anschluss des Vibrationsmotors an deinen ESP32 ist unkompliziert und benötigt nur drei Kabel. Du verbindest den GND-Pin deines ESP32 mit GND des Vibrationsmotors und versorgst das Modul, indem du 3,3V des Mikrocontrollers an VCC des Motors anschließt. Die Steuerung erfolgt über den digitalen Pin D15 (GPIO 15) des ESP32, der mit dem IN-Pin des Vibrationsmotors verbunden wird.

ESP32 GND → Vibrationsmotor GND

ESP32 3,3V → Vibrationsmotor VCC-Pin

ESP32 D15 → Vibrationsmotor IN-Pin

Die sorgfältige und korrekte Verdrahtung ist von entscheidender Bedeutung, um sicherzustellen, dass der ESP32 die Signale des Vibrationsmotors ordnungsgemäß ansteuern kann.
Nachdem du diese Verbindungen erfolgreich hergestellt hast, bist du bereit, mit der Programmierung des ESP32 fortzufahren. Im nächsten Abschnitt werden wir ausführlich darauf eingehen, wie du den Code für den Vibrationsmotor programmieren kannst.

Software / Code / Programmierung

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

Schritt 1: IDE Projekt
Öffne die Arduino-IDE und erstelle ein neues Projekt.
Um mit der Arduino-IDE zu arbeiten, öffne zunächst die Anwendung auf deinem Computer. Falls du die Arduino-IDE noch nicht installiert hast, findest du online zahlreiche Anleitungen zur Installation und zur Einrichtung deines ESP32 Boards.
Nachdem du die Arduino-IDE geöffnet hast, erstellst du ein neues Projekt, indem du auf „Datei“ und dann auf „Neu“ klickst. Dadurch wird ein neuer Sketch geöffnet, in dem du den Code für den Vibrationsmotor eingeben kannst.

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

void loop()
{
  // Schleife
}

Schritt 2: Bibliothek einbinden
Für die Steuerung des Vibrationsmotors mit dem ESP32 benötigen wir keine zusätzliche Bibliothek. Die Ansteuerung ist sehr einfach, da wir nur die standardmäßig in der Arduino-IDE integrierten Funktionen zur Ansteuerung der GPIO-Pins verwenden.
Wir benötigen keine Bibliothek, da die grundlegenden Funktionen zur digitalen und analogen Ansteuerung bereits im ESP32-Framework enthalten sind. Das macht das Projekt sehr übersichtlich und schnell umsetzbar.

Schritt 3: Initialisierung
Im Initialisierungsbereich, der vor void setup() liegt, definierst du die globalen Variablen und Konstanten. Hier weisen wir den digitalen Pin D15 des ESP32 dem Namen motorPin zu. Die Verwendung einer Konstanten via #define erleichtert das spätere Ändern des angeschlossenen Pins. GPIO 15 ist der Pin, den wir in der Hardware-Sektion mit dem IN-Pin des Vibrationsmotors verbunden haben.

#define motorPin 15 //D15

Schritt 4: Void Setup
Die Funktion void setup() wird nur einmal beim Start des ESP32 ausgeführt. Hier konfigurierst du normalerweise die Pins als Ein- oder Ausgang (pinMode) oder startest serielle Kommunikationen. Da wir in diesem Beispiel lediglich den analogen Schreibbefehl (analogWrite) verwenden, ist keine explizite Pin-Konfiguration per pinMode() erforderlich. Die Funktion bleibt in unserem Fall leer, aber sie ist zwingend notwendig für den korrekten Ablauf des Sketches.

void setup()
{
    
}

Schritt 5: Loop Setup
Die Funktion void loop() wird kontinuierlich und wiederholt ausgeführt, solange der ESP32 mit Strom versorgt wird. Hier erzeugen wir durch zwei for-Schleifen eine „Auf- und Abschwellen“-Vibration des Vibrationsmotors. Wir nutzen die Funktion analogWrite(motorPin, fadeValue), um den Motor mithilfe von Pulsweitenmodulation (PWM) in der Intensität zu steuern. Die erste Schleife erhöht die Intensität von 0 (keine Vibration) auf 255 (maximale Vibration), und die zweite Schleife fährt die Intensität wieder auf 0 herunter.

void loop()
{
    // fade in: Von min (0) zu max (255) in 5er Schritten:
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5)
    {
        analogWrite(motorPin, fadeValue); // Analoger Wert. Werte von 0 bis 255
        delay(30); // 30ms Pause um den Dimming-Effekt zu sehen
    }

    // fade out: Von max (255) zu min (0) in 5er Schritten:
    for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5)
    {
        analogWrite(motorPin, fadeValue); // Analoger Wert. Werte von 0 bis 255
        delay(30); // 30ms Pause um den Dimming-Effekt zu sehen
    }
}

Gesamter Code

Hier zeigen wir dir zur besseren Übersicht den gesamten Code für die Ansteuerung des Vibrationsmotors mit dem ESP32 noch einmal komplett auf. Du kannst diesen Code direkt in deine Arduino-IDE kopieren.

#define motorPin 15 //D15

void setup()
{
    
}

void loop()
{
    // fade in: Von min (0) zu max (255) in 5er Schritten:
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5)
    {
        analogWrite(motorPin, fadeValue); // Analoger Wert. Werte von 0 bis 255
        delay(30); // 30ms Pause um den Dimming-Effekt zu sehen
    }

    // fade out: Von max (255) zu min (0) in 5er Schritten:
    for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5)
    {
        analogWrite(motorPin, fadeValue); // Analoger Wert. Werte von 0 bis 255
        delay(30); // 30ms Pause um den Dimming-Effekt zu sehen
    }
}

Ausführung / Anwendung

Nachdem du den Code in die Arduino-IDE eingegeben hast, muss dieser nur noch auf deinen ESP32 übertragen werden, damit der Vibrationsmotor seine Arbeit aufnehmen kann. Hierzu gehst du in wenigen Schritten vor:
Kompilieren (Haken): Klicke auf das Häkchen-Symbol (Überprüfen) in der Arduino-IDE, um deinen Code zu kompilieren. Die Software prüft, ob Syntaxfehler vorliegen und erstellt die ausführbare Datei.
Hochladen (Pfeil): Ist die Kompilierung erfolgreich, klicke auf das Pfeil-Symbol (Hochladen), um den Code auf deinen ESP32 zu übertragen. Achte darauf, dass dein Board korrekt über USB verbunden ist.
Vibrationsmotor beginnt zu vibrieren: Sobald der Upload abgeschlossen ist, startet die Funktion void loop(). Der Vibrationsmotor beginnt sofort, die Vibration durchzuführen. Konkret wird ein sanfter Fade-in (von 0 auf 255) und anschließend ein Fade-out (von 255 auf 0) durchgeführt.

Weitere Themen

BME280 + ESP32

OLED Display + ESP32

Laser-Modul + ESP32