Bauteile · 12 Min. Lesezeit

Vibrationsmotor Arduino: Modul anschließen, PWM und Haptik-Muster

Vibrationsmotor Arduino: ERM-Münzmotor-Modul, Transistor und Diode, Stärke per PWM, Haptik-Muster, smarter Blindenstock, ESP32- und Pico-Code, DRV2605-Hinweis.

In Vibrationsmotor-Arduino-Projekten ist ein kleiner Motor der einfachste Weg, dem Nutzer etwas mitzuteilen, ganz ohne Ton oder Licht. Stummgeschaltete Handys, Smartwatches, die ans Handgelenk tippen, und rüttelnde Gamecontroller nutzen alle diese winzigen Motoren. In der Hobbyelektronik am weitesten verbreitet ist der ERM-Münzmotor (Coin-Motor) mit 10 mm Durchmesser und nur 2–3 mm Dicke. Einen nackten Motor kannst du nicht direkt an einen Arduino-Pin hängen, aber ein fertiges Vibrationsmotor-Modul mit Transistor und Diode lässt sich mit drei Kabeln betreiben.

In dieser Anleitung erfährst du, wie ein ERM-Motor vibriert, wozu Transistor und Diode im Modul nötig sind und wie viel Strom der Motor zieht. Danach stellen wir die Vibration mit PWM stufenweise ein und sehen, warum der Motor bei geringer Leistung gar nicht anläuft und wie ein „Anlaufimpuls“ das Problem löst. Wir schreiben Code, der Haptik-Muster wie kurzes Tippen, Doppeltippen, Herzschlag und SOS ohne delay() abspielt, und bauen die Logik eines smarten Blindenstocks, der je nach Abstand vibriert. In den letzten Abschnitten findest du ein Beispiel mit Vibrationsrückmeldung beim Berühren des Touch-Pins am ESP32, MicroPython-Code für den Raspberry Pi Pico und den Treiber DRV2605 für fortgeschrittene Haptik-Effekte.

Vibrationsmotor-Modul
Vibrationsmotor-Modul: ERM-Münzmotor, Treibertransistor und Schutzdiode auf einer Platine.

Was ist ein Vibrationsmotor und wie funktioniert er?

ERM steht für „Eccentric Rotating Mass“, also exzentrisch rotierende Masse. Auf der Motorwelle sitzt eine kleine Masse, deren Schwerpunkt nicht genau in der Mitte liegt. Dreht sich der Motor, zieht diese Unwucht ihn bei jeder Umdrehung in eine Richtung, und genau das spürst du als Vibration. Bei Münzmotoren dreht sich die Masse im flachen Gehäuse, außen bewegt sich nichts; deshalb lassen sie sich sehr leicht aufkleben und verwenden. Zylindrische ERM-Motoren tragen außen ein halbmondförmiges Metallgewicht und vibrieren stärker. Stärke und Frequenz der Vibration hängen von der Drehzahl ab: Mit steigender Spannung dreht der Motor schneller, die Vibration wird stärker und höher. Der in Handys und Gamecontrollern immer häufigere LRA (linearer Resonanzaktor) arbeitet anders: Er bewegt einen Magneten an einer Feder hin und her und funktioniert nur mit einem Wechselsignal auf seiner eigenen Resonanzfrequenz, nicht mit reiner Gleichspannung. Die Module aus Arduino-Sets sind fast immer ERM-Motoren.

EigenschaftTypischer ERM-Münzmotor (z. B. 1027)
Größe10 mm Durchmesser, 2,7 mm dick
Nennspannung3 V (etwa 2,5–3,5 V)
BetriebsstromEtwa 60–90 mA bei 3 V
AnlaufstromKurzzeitig 100–120 mA
DrehzahlEtwa 10.000–13.000 U/min
VibrationsfrequenzEtwa 160–220 Hz
Minimale AnlaufspannungEtwa 2–2,3 V; darunter läuft der Motor nicht an

Was steckt in einem Vibrationsmotor-Modul?

Ein Pin des Arduino Uno liefert höchstens 40 mA, die sichere Grenze liegt bei etwa 20 mA. Die Pins von ESP32 und Pico sind noch schwächer. Ein Vibrationsmotor zieht dagegen 60–120 mA und verhält sich wie eine Spule: Wird sein Strom abgeschaltet, entsteht an den Anschlüssen eine hohe Gegenspannungsspitze. Deshalb belastet ein direkt angeschlossener Motor den Pin und kann den Mikrocontroller zurücksetzen oder sogar beschädigen. Ein fertiges Modul löst das mit drei Bauteilen:

  • Treibertransistor: Meist ein S8050 oder ein ähnlicher kleiner NPN-Transistor, bei manchen Modulen ein N-Kanal-MOSFET. Der Arduino-Pin liefert nur wenige Milliampere Steuerstrom, der Motorstrom fließt durch den Transistor. Wie ein Transistor als Schalter arbeitet, erklären wir in Was ist ein Transistor?.
  • Basiswiderstand: Begrenzt den Strom vom Pin zum Transistor; ein Wert um 1 kΩ funktioniert mit 5-V- und 3,3-V-Boards.
  • Freilaufdiode: Die antiparallel zum Motor geschaltete Diode schließt die Spannungsspitze beim Abschalten kurz und schützt den Transistor. Mehr dazu findest du in Was ist eine Diode?.

Die meisten Module haben drei Pins: VCC, GND und den Signalpin IN (bei manchen Platinen S oder SIG). Setzt du IN auf HIGH, schaltet der Transistor durch und der Motor dreht sich. Das Modul selbst arbeitet mit 3,3–5 V. Bei 5 V bekommt der Motor nach dem kleinen Spannungsabfall am Transistor etwa 4,5 V, also mehr als die Nennspannung eines 3-V-Motors. Für kurze Hinweise ist das kein Problem, läuft der Motor aber lange am Stück, verlängert eine Begrenzung auf etwa 60–70 Prozent per PWM seine Lebensdauer.

Anschluss: Arduino Uno, ESP32 und Raspberry Pi Pico

Die folgende Tabelle zeigt die Pins, die alle Sketches in diesem Artikel verwenden. Der Motorpin muss auf jedem Board PWM ausgeben können. Bei ESP32 und Pico reicht das 3,3-V-Signal am IN-Pin, um den Transistor anzusteuern; den VCC-Pin des Moduls kannst du für stärkere Vibration an 5 V, für sanftere an 3,3 V anschließen. Egal welche Versorgung du wählst, GND muss gemeinsam sein.

VerbindungArduino UnoESP32Raspberry Pi Pico
Modul VCC5VVIN (5 V) oder 3V3VBUS (5 V) oder 3V3(OUT)
Modul GNDGNDGNDGND
Modul IND5 (PWM)GPIO 25GP15
Taster (anderes Bein an GND)D2Touch-Pin GPIO 4 (T0)GP14
HC-SR04 TRIG (Stock-Beispiel)D9--
HC-SR04 ECHO (Stock-Beispiel)D10--
Verwendest du einen nackten Motor ohne Modul, schließe ihn niemals direkt an einen Pin an. Verbinde einen Motoranschluss mit 5 V und den anderen mit dem Kollektor eines NPN-Transistors (2N2222, BC337 oder S8050); den Emitter an GND, die Basis über einen 1-kΩ-Widerstand an den Arduino-Pin. Setze eine 1N4148 oder 1N5819 parallel zum Motor, mit der Kathode (Ring) Richtung 5 V. Fehlt die Diode, kann der Transistor schnell kaputtgehen und der Arduino zufällig neu starten. Den Basiswiderstand prüfst du mit dem Tool Ohmsches Gesetz, Strom und Verstärkung des Transistors mit dem Tool Transistor.

Erster Sketch: Ein/Aus und Vibrationsstärke per PWM

Ein Vibrationsmotor-Modul kannst du dir wie eine LED vorstellen: digitalWrite(HIGH) lässt den Motor mit voller Leistung laufen, analogWrite() stellt per PWM die mittlere Spannung und damit die Vibrationsstärke ein. Beim Arduino Uno arbeiten D5 und D6 mit etwa 980 Hz, die übrigen PWM-Pins mit etwa 490 Hz. Die PWM-Grundlagen erklären wir ausführlich in Was ist PWM?. ERM-Motoren haben eine wichtige Eigenschaft: Einen stehenden Motor in Gang zu setzen braucht mehr Leistung, als einen drehenden am Laufen zu halten. Deshalb rührt sich ein Motor, den du mit kleinem PWM-Wert startest, eventuell gar nicht. Die Lösung: den Motor einige zehn Millisekunden mit voller Leistung anlaufen lassen und dann auf den Wunschwert senken; das nennt man Anlaufimpuls (Kick-Start). Der folgende Sketch vibriert zuerst kurz mit voller Leistung, steigert dann die Stärke schrittweise und schreibt jeden Schritt in den Seriellen Monitor.

C++ (Arduino IDE)
1const int MOTOR_PIN = 5;            // PWM pini (Uno'da ~980 Hz) / PWM pin (~980 Hz on Uno)
2
3// Kalkış darbesiyle istenen güce geç / start with a kick, then go to the requested power
4void motorGuc(int guc) {
5  static int oncekiGuc = 0;
6  if (guc > 0 && oncekiGuc == 0 && guc < 200) {
7    analogWrite(MOTOR_PIN, 255);    // durgun motoru tam güçle kaldır / kick a stopped motor at full power
8    delay(30);
9  }
10  analogWrite(MOTOR_PIN, guc);      // 0-255 arası güç / power between 0 and 255
11  oncekiGuc = guc;
12}
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(MOTOR_PIN, OUTPUT);
17
18  motorGuc(255);                    // 300 ms tam güç / 300 ms at full power
19  delay(300);
20  motorGuc(0);
21  delay(1000);
22}
23
24void loop() {
25  for (int guc = 60; guc <= 255; guc += 15) {
26    Serial.print("PWM: ");
27    Serial.println(guc);
28    motorGuc(guc);
29    delay(700);
30    motorGuc(0);                    // her adım arasında dur / stop between steps
31    delay(500);
32  }
33  delay(2000);
34}

Beim Ausführen merkst du, dass der Motor unter einem bestimmten PWM-Wert gar nicht oder nur sehr schwach vibriert. Bei 5-V-Versorgung liegt diese Schwelle meist zwischen 70 und 110; der genaue Wert hängt von Motor und Modul ab. Notiere den Wert aus dem Seriellen Monitor, bei dem du den Motor zum ersten Mal deutlich spürst, und nutze ihn als Mindestleistung in deinem Projekt. Dank des Anlaufimpulses funktionieren auch Werte knapp darunter, denn ein einmal drehender Motor läuft mit weniger Leistung weiter.

PWM-Wert (5-V-Versorgung)Mittlere SpannungSpürbare Vibration
0–600–1,2 VKeine, der Motor dreht nicht
70–1101,4–2,2 VSchwellenbereich; eventuell Anlaufimpuls nötig
120–1702,4–3,3 VLeichte bis mittlere Vibration, ideal für längere Hinweise
180–2553,5–4,5 VStarke Vibration für kurze, auffällige Alarme

Haptik-Muster: kurzes Tippen, Doppeltippen, Herzschlag und SOS

Eine einheitliche Vibration sagt nur „etwas ist passiert“. Unterschiedliche Muster verraten dem Nutzer auch, was passiert ist: Ein kurzes Tippen kann eine Bestätigung bedeuten, zwei kurze eine Warnung, ein langes Brummen einen Alarm und ein herzschlagartiger Rhythmus eine Erinnerung. Die menschliche Hand spürt Vibrationen unter 20–30 ms kaum, und ein ERM-Motor braucht etwa 30–50 ms zum Hochlaufen. Halte den kürzesten Impuls eines Musters daher bei 40–60 ms und die Pause zwischen zwei Impulsen bei mindestens 80–100 ms. Im folgenden Sketch ist jedes Muster ein Array aus {Leistung, Dauer}-Paaren. Der Musterplayer arbeitet mit millis(), loop() kann also während eines Musters andere Aufgaben erledigen. Jeder Druck auf den Taster an D2 spielt das nächste Muster.

C++ (Arduino IDE)
1const int MOTOR_PIN = 5;
2const int BUTON_PIN = 2;            // diğer ucu GND / other leg to GND
3
4struct Adim { uint8_t guc; uint16_t sure; };   // güç 0-255, süre ms / power 0-255, duration ms
5
6const Adim TIK[]       = {{255, 50}};
7const Adim CIFT_TIK[]  = {{255, 50}, {0, 100}, {255, 50}};
8const Adim UZUN[]      = {{200, 600}};
9const Adim KALP[]      = {{255, 60}, {0, 120}, {180, 80}, {0, 600}, {255, 60}, {0, 120}, {180, 80}};
10const Adim SOS[]       = {{255, 100}, {0, 100}, {255, 100}, {0, 100}, {255, 100}, {0, 300},
11                          {255, 350}, {0, 100}, {255, 350}, {0, 100}, {255, 350}, {0, 300},
12                          {255, 100}, {0, 100}, {255, 100}, {0, 100}, {255, 100}};
13const Adim ARTAN[]     = {{120, 150}, {160, 150}, {200, 150}, {255, 300}};
14
15struct Desen { const Adim *adimlar; uint8_t adet; const char *ad; };
16const Desen DESENLER[] = {
17  {TIK, 1, "Tik"}, {CIFT_TIK, 3, "Cift tik / Double tap"}, {UZUN, 1, "Uzun / Long"},
18  {KALP, 7, "Kalp atisi / Heartbeat"}, {SOS, 17, "SOS"}, {ARTAN, 4, "Artan / Ramp"}
19};
20const uint8_t DESEN_SAYISI = sizeof(DESENLER) / sizeof(DESENLER[0]);
21
22const Adim *calanDesen = nullptr;   // şu an çalan desen / pattern now playing
23uint8_t calanAdet = 0, adimNo = 0;
24unsigned long adimBaslangic = 0;
25
26void desenBaslat(const Desen &d) {
27  calanDesen = d.adimlar;
28  calanAdet = d.adet;
29  adimNo = 0;
30  adimBaslangic = millis();
31  analogWrite(MOTOR_PIN, calanDesen[0].guc);
32  Serial.println(d.ad);
33}
34
35void desenGuncelle() {              // loop'ta sürekli çağır / call it continuously in loop
36  if (calanDesen == nullptr) return;
37  if (millis() - adimBaslangic < calanDesen[adimNo].sure) return;
38  adimNo++;
39  if (adimNo >= calanAdet) {        // desen bitti / pattern finished
40    analogWrite(MOTOR_PIN, 0);
41    calanDesen = nullptr;
42    return;
43  }
44  adimBaslangic = millis();
45  analogWrite(MOTOR_PIN, calanDesen[adimNo].guc);
46}
47
48void setup() {
49  Serial.begin(9600);
50  pinMode(MOTOR_PIN, OUTPUT);
51  pinMode(BUTON_PIN, INPUT_PULLUP);
52}
53
54void loop() {
55  static uint8_t siradaki = 0;
56  static bool oncekiBasili = false;
57  bool basili = (digitalRead(BUTON_PIN) == LOW);
58  if (basili && !oncekiBasili && calanDesen == nullptr) {   // yeni basış / new press
59    desenBaslat(DESENLER[siradaki]);
60    siradaki = (siradaki + 1) % DESEN_SAYISI;
61  }
62  oncekiBasili = basili;
63  desenGuncelle();
64  delay(5);                         // basit ark önleme / simple debounce
65}

Um die Muster zu ändern, bearbeitest du nur die Arrays; die Abspielfunktion bleibt gleich. Im SOS-Muster dauern kurze Impulse 100 ms, lange 350 ms und die Pause zwischen Buchstaben 300 ms; diese Verhältnisse folgen dem „Punkt, Strich“-Schema des Morsecodes. Halte die Muster deutlich unterschiedlich, damit niemand sie verwechselt: verschiedene Anzahl (ein, zwei, drei Impulse) oder klar verschiedene Dauern. Bevor du Muster in ein Projekt übernimmst, probiere sie an ein paar Leuten aus und lass sie raten, was jedes Muster bedeutet; im Haptik-Design ist das der beste Test.

Tragbare Alarme und smarter Blindenstock

Ein Vibrationsmotor spielt seine Stärken aus, wo Töne stören oder nicht zu hören sind. Platziere den Motor in Wearable-Projekten in einem Armband, Handschuh oder Gürtel nahe an der Haut. Handgelenk-Innenseite, Handfläche und Fingerspitzen reagieren am empfindlichsten auf Vibration. Klebst du den Motor mit doppelseitigem Klebeband an eine harte Fläche, etwa die Innenwand eines 3D-gedruckten Gehäuses, überträgt sich die Vibration besser als bei lose an Stoff genähten Motoren. Bei smarten Blindenstöcken für sehbehinderte Menschen sitzt der Motor im Griff genau unter dem Daumen, und der Abstand zum Hindernis wird in Häufigkeit und Stärke der Vibration übersetzt: Je näher das Hindernis, desto schneller und stärker die Impulse, bis sie sehr nah in Dauervibration übergehen. Der folgende Sketch zeigt diese Logik mit einem HC-SR04-Abstandssensor.

C++ (Arduino IDE)
1const int TRIG_PIN  = 9;
2const int ECHO_PIN  = 10;
3const int MOTOR_PIN = 5;
4const int UZAK_CM   = 150;          // bunun ötesinde titreşim yok / no vibration beyond this
5const int YAKIN_CM  = 30;           // bunun altında sürekli titreşim / continuous below this
6
7int mesafeOlc() {
8  digitalWrite(TRIG_PIN, LOW);
9  delayMicroseconds(2);
10  digitalWrite(TRIG_PIN, HIGH);
11  delayMicroseconds(10);
12  digitalWrite(TRIG_PIN, LOW);
13  unsigned long sure = pulseIn(ECHO_PIN, HIGH, 12000);   // ~2 m zaman aşımı / ~2 m timeout
14  if (sure == 0) return 999;                              // yankı yok / no echo
15  return sure / 58;                                       // cm
16}
17
18void setup() {
19  pinMode(TRIG_PIN, OUTPUT);
20  pinMode(ECHO_PIN, INPUT);
21  pinMode(MOTOR_PIN, OUTPUT);
22}
23
24void loop() {
25  int cm = mesafeOlc();
26  if (cm > UZAK_CM) {
27    analogWrite(MOTOR_PIN, 0);               // yol açık / path is clear
28    delay(60);
29  } else if (cm <= YAKIN_CM) {
30    analogWrite(MOTOR_PIN, 255);             // dur uyarısı / stop warning
31    delay(60);
32  } else {
33    int guc   = map(cm, UZAK_CM, YAKIN_CM, 150, 255);   // yaklaştıkça güçlenir / stronger when closer
34    int bosluk = map(cm, UZAK_CM, YAKIN_CM, 900, 150);  // yaklaştıkça sıklaşır / more frequent when closer
35    analogWrite(MOTOR_PIN, guc);
36    delay(80);                               // 80 ms titreşim / 80 ms buzz
37    analogWrite(MOTOR_PIN, 0);
38    delay(bosluk);
39  }
40}

Der Einfachheit halber nutzt dieser Sketch delay() und misst während des Wartens nicht neu; in einem echten Stock reagiert eine millis()-basierte Struktur wie im vorigen Abschnitt besser. Die Mindestleistung von 150 sorgt dafür, dass der Motor bei weit entfernten Hindernissen nicht unter seiner Schwelle bleibt und stehen bleibt. Ein komplettes Projekt mit Pfützenwarnung, Sturzerkennung, SOS und Akkuberechnung findest du im Smarter-Blindenstock-Projekt mit Arduino, Details zum Sensor in der Anleitung zum HC-SR04-Abstandssensor.

Strom, Stromversorgung und Akkulaufzeit

Ein Münzmotor zieht im Betrieb 60–90 mA und beim Anlaufen kurz über 100 mA. Das liefert der 5V-Pin des Arduino Uno über USB problemlos. Probleme gibt es meist in akkubetriebenen Schaltungen, deren Spannung schon knapp ist, oder in Projekten mit mehreren gleichzeitig laufenden Motoren: Beim Anlaufen bricht die Spannung kurz ein und das Board startet neu. Um das zu verhindern, setze einen 47–100-µF-Elko zwischen VCC und GND des Moduls und starte mehrere Motoren nicht gleichzeitig, sondern mit ein paar Millisekunden Abstand. Bedenke bei der Akkuberechnung, dass der Motor nur in kurzen Stößen läuft: Ein 80-mA-Motor, der pro Minute insgesamt 3 Sekunden läuft, hat einen mittleren Strom von nur 4 mA. Mit den Werten deines Projekts berechnest du im Tool Akkulaufzeit, wie viele Stunden er durchhält.

Berührungsfeedback mit dem ESP32

Zwei Stärken des ESP32 passen hervorragend zum Vibrationsmotor: Der Chip hat kapazitive Touch-Pins, und die PWM-Einheit LEDC erlaubt eine frei wählbare Frequenz. Der folgende Sketch gibt beim Berühren eines Drahts oder Kupferfolienstücks an GPIO 4 (T0) einen kurzen „Klick“, wie bei einem Handydisplay; dauert die Berührung länger als 1 Sekunde, bestätigt ein langes Brummen. Die PWM-Frequenz haben wir auf 20 kHz gesetzt, an der Grenze des menschlichen Hörens, damit auch leises Fiepen aus dem Motortreiber verschwindet. Der Code kompiliert mit Version 2.x und 3.x des ESP32-Arduino-Cores, weil sich die LEDC-Funktionsnamen zwischen beiden unterscheiden.

C++ (Arduino IDE)
1const int MOTOR_PIN   = 25;         // modül IN / module IN
2const int DOKUNMA_PIN = T0;         // GPIO 4, kapasitif dokunma / capacitive touch
3const int PWM_FREKANS = 20000;      // 20 kHz, duyulmaz / 20 kHz, inaudible
4const int PWM_BIT     = 8;          // 0-255 çözünürlük / 0-255 resolution
5const int PWM_KANAL   = 0;          // yalnız 2.x için / only for core 2.x
6
7void motorYaz(uint8_t guc) {
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9  ledcWrite(MOTOR_PIN, guc);        // 3.x: pin numarasıyla / 3.x: by pin number
10#else
11  ledcWrite(PWM_KANAL, guc);        // 2.x: kanal numarasıyla / 2.x: by channel number
12#endif
13}
14
15void titret(uint8_t guc, int ms) {
16  motorYaz(guc);
17  delay(ms);
18  motorYaz(0);
19}
20
21int esik = 0;
22
23void setup() {
24  Serial.begin(115200);
25#if ESP_ARDUINO_VERSION_MAJOR >= 3
26  ledcAttach(MOTOR_PIN, PWM_FREKANS, PWM_BIT);
27#else
28  ledcSetup(PWM_KANAL, PWM_FREKANS, PWM_BIT);
29  ledcAttachPin(MOTOR_PIN, PWM_KANAL);
30#endif
31  long toplam = 0;                  // dokunulmamış değeri ölç / measure the untouched value
32  for (int i = 0; i < 20; i++) {
33    toplam += touchRead(DOKUNMA_PIN);
34    delay(10);
35  }
36  esik = (toplam / 20) * 7 / 10;    // %70'inin altı dokunuş / below 70% means touched
37  Serial.printf("Dokunma esigi / Touch threshold: %d\n", esik);
38  titret(255, 60);                  // hazır işareti / ready signal
39}
40
41void loop() {
42  static bool dokunuyor = false;
43  static unsigned long dokunmaBasi = 0;
44  static bool uzunVerildi = false;
45  int deger = touchRead(DOKUNMA_PIN);   // dokununca değer düşer / value drops when touched
46
47  if (deger < esik && !dokunuyor) {     // dokunuş başladı / touch started
48    dokunuyor = true;
49    uzunVerildi = false;
50    dokunmaBasi = millis();
51    titret(255, 40);                    // kısa tık / short click
52  } else if (deger < esik && !uzunVerildi && millis() - dokunmaBasi > 1000) {
53    titret(200, 400);                   // uzun basış onayı / long-press confirmation
54    uzunVerildi = true;
55  } else if (deger >= esik) {
56    dokunuyor = false;
57  }
58  delay(20);
59}

Beim ESP32 liegt der Touch-Wert ohne Berührung meist bei 50–80 und sinkt bei Fingerkontakt deutlich; deshalb misst der Code beim Start den Mittelwert und berechnet die Schwelle automatisch. Bei ESP32-S2 und S3 ist es umgekehrt, dort steigt der Wert bei Berührung; auf diesen Boards musst du den Vergleich umdrehen. Schließt du VCC des Moduls an den VIN-Pin des ESP32 an, vibriert der Motor mit 5 V stärker; das 3,3-V-Signal am IN-Pin reicht für den Transistor. Kombiniert mit WLAN oder Bluetooth baust du daraus ein Armband, das bei einer Handy-Benachrichtigung vibriert, oder ein per ESP32 BLE gesteuertes Alarmgerät.

Vibrationsmotor mit Raspberry Pi Pico und MicroPython

Beim Raspberry Pi Pico kann jeder GPIO-Pin PWM erzeugen. In MicroPython nimmt die Funktion duty_u16() der Klasse PWM einen Wert zwischen 0 und 65535 an; 65535 bedeutet volle Leistung. Der folgende Code spielt bei jedem Druck auf den Taster an GP14 ein Herzschlag-Muster. Wie im Arduino-Beispiel ist das Muster eine Liste aus Leistungs- und Dauerpaaren. Den VCC-Pin des Moduls kannst du für stärkere Vibration an VBUS (die 5 V vom USB) und für sanftere an 3V3(OUT) anschließen.

MicroPython
1from machine import Pin, PWM
2import time
3
4motor = PWM(Pin(15))                   # modül IN pini / module IN pin
5motor.freq(1000)                       # 1 kHz PWM
6buton = Pin(14, Pin.IN, Pin.PULL_UP)   # diğer ucu GND / other leg to GND
7
8# (güç %, süre ms) çiftleri / (power %, duration ms) pairs
9KALP = [(100, 60), (0, 120), (70, 80), (0, 600), (100, 60), (0, 120), (70, 80)]
10CIFT_TIK = [(100, 50), (0, 100), (100, 50)]
11
12def guc_ayarla(yuzde):
13    motor.duty_u16(int(65535 * yuzde / 100))
14
15def desen_cal(desen):
16    for yuzde, sure in desen:
17        guc_ayarla(yuzde)
18        time.sleep_ms(sure)
19    guc_ayarla(0)                      # her zaman kapalı bitir / always end switched off
20
21desen_cal(CIFT_TIK)                    # açılış işareti / start-up signal
22while True:
23    if buton.value() == 0:             # basıldı / pressed
24        desen_cal(KALP)
25        while buton.value() == 0:      # bırakılmasını bekle / wait for release
26            time.sleep_ms(10)
27    time.sleep_ms(20)

Die Pins des Pico arbeiten mit 3,3 V, und mehr als etwa 12 mA pro Pin werden nicht empfohlen; auch beim Pico gehört also das Transistormodul dazwischen, kein nackter Motor. Während ein Muster läuft, wird der Taster nicht gelesen; musst du mehrere Dinge gleichzeitig erledigen, baust du mit time.ticks_ms() das millis()-Muster aus Arduino nach oder schaltest die Musterschritte mit einem Timer-Interrupt weiter. Bist du neu bei MicroPython, ist der Artikel MicroPython-Grundlagen ein guter Einstieg.

DRV2605-Haptiktreiber: professionelle Vibrationseffekte

Ein Transistormodul schaltet den Motor nur ein und aus oder macht ihn per PWM stärker oder schwächer. Das knackige „Klick“-Gefühl eines Handys entsteht dagegen durch sehr schnelles Starten und Stoppen: Der Motor wird zuerst mit einem Impuls über der Nennspannung beschleunigt (Overdrive) und am Ende mit einer kurzen Gegenspannung abgebremst. Der Chip DRV2605L von Texas Instruments erledigt das selbst. Er wird per I2C angeschlossen (Adresse 0x5A), treibt ERM- und LRA-Motoren und enthält 123 fertige Effekte wie Klicks, Doppelklicks, Brummen und sanfte Stöße. Er lernt die Motoreigenschaften per Autokalibrierung und kann einen Audioeingang in Vibration umsetzen. Mit der Bibliothek Adafruit DRV2605 sind es nur wenige Zeilen; am Uno kommt SDA an A4 und SCL an A5, der Motor wird direkt am Motorausgang der DRV2605-Platine angeschlossen.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_DRV2605.h>
3
4Adafruit_DRV2605 haptik;
5
6void setup() {
7  Serial.begin(9600);
8  if (!haptik.begin()) {               // I2C adresi 0x5A / I2C address 0x5A
9    Serial.println("DRV2605 bulunamadi / not found");
10    while (1) {}
11  }
12  haptik.selectLibrary(1);             // ERM efekt kütüphanesi / ERM effect library
13  haptik.setMode(DRV2605_MODE_INTTRIG); // go() ile tetikle / trigger with go()
14}
15
16void efektCal(uint8_t efekt) {
17  haptik.setWaveform(0, efekt);        // 1. slot: efekt / slot 1: effect
18  haptik.setWaveform(1, 0);            // 0 = dizinin sonu / 0 = end of sequence
19  haptik.go();
20}
21
22void loop() {
23  efektCal(1);                         // 1: güçlü tık / strong click
24  delay(1000);
25  efektCal(10);                        // 10: çift tık / double click
26  delay(1000);
27  efektCal(14);                        // 14: güçlü vızıltı / strong buzz
28  delay(2000);
29}

Der DRV2605 kann bis zu 8 Effekte nacheinander in einer Sequenz abspielen; mit setWaveform() belegst du die Slots 0 bis 7 und markierst das Ende der Sequenz mit 0. Nutzt du einen LRA-Motor, rufe useLRA() auf und wähle die LRA-Bibliothek Nummer 6. Für einfache Hinweise reicht ein Transistormodul völlig; entwirfst du ein Wearable, einen Gamecontroller oder eine Touch-Oberfläche, verbessert der DRV2605 das Gefühl spürbar.

Projektideen mit dem Vibrationsmotor

  • Leises Timer-Armband: Baue einen Pomodoro-Timer, der am Ende der Lern- oder Arbeitszeit am Handgelenk vibriert, ohne die Klasse zu stören.
  • Smarter Blindenstock: Folge der Anleitung zum smarten Blindenstock für ein komplettes Projekt, das den Abstand zum Hindernis in einen Vibrationsrhythmus übersetzt.
  • Lautlose Türklingel: Lass ein Gerät in deiner Tasche vibrieren, wenn ein PIR-Bewegungsmelder an der Tür jemanden erkennt.
  • Gamecontroller: Ergänze einen mit dem Joystick-Modul gebauten Controller um Rumble bei Kollisionen.
  • Haltungswarner: Miss mit einem MPU6050 die Neigung deines Rückens und warne mit einem kurzen Impuls, wenn du zu lange krumm sitzt.
  • Vibration statt Ton: Lege bei einem Nachtwecker statt eines Buzzers einen Vibrationsmotor unter das Kopfkissen.

Häufige Fehler und Lösungen

SymptomMögliche UrsacheLösung
Der Motor dreht gar nichtPWM-Wert unter der Anlaufschwelle oder kein gemeinsames GNDZuerst mit 255 testen, Anlaufimpuls ergänzen, GND verbinden
Der Arduino startet neu, wenn der Motor läuftDer Anlaufstrom lässt die Versorgung einbrechen oder die Diode fehltFertiges Modul nutzen, 47–100 µF zwischen VCC und GND setzen
Die Vibration ist sehr schwachDas Modul läuft mit 3,3 V oder der Motor liegt auf weichem UntergrundVCC an 5 V anschließen, Motor auf eine harte Fläche kleben
Der Motor wird warmEr läuft lange mit voller Leistung an 5 VLeistung per PWM auf 60–70 % begrenzen, kurze Impulse statt Dauervibration
Der Motor fiept leiseDie PWM-Frequenz liegt im hörbaren BereichBeim ESP32 die LEDC-Frequenz auf 20 kHz setzen, beim Uno kurze Impulse nutzen
Fehler „ledcSetup nicht gefunden“ beim ESP32ESP32-Core Version 3.xDie #if-ESP_ARDUINO_VERSION_MAJOR-Weiche aus diesem Artikel verwenden
Ein Pin funktioniert nach dem Anschluss eines nackten Motors nicht mehrDer Motor hing direkt am Pin und hat ihn beschädigtAnderen Pin nutzen, Motor immer über Transistor und Diode ansteuern
Die Muster fühlen sich gleich anImpulse zu kurz oder Pausen zu knappKürzester Impuls 40–60 ms, Pause mindestens 100 ms
Teste die Vibration am echten Einsatzort, nicht auf dem Schreibtisch. Ein Motor auf dem Tisch bringt die Platte zum Schwingen und fühlt sich stärker an, als er ist; im Armband oder im Griff eines Stocks kann derselbe Motor viel schwächer wirken. Befestige den Motor fest an einer harten Fläche, verlege die Kabel ohne Zug und miss die PWM-Schwelle nach dem Endaufbau erneut.

Ein Vibrationsmotor ist der günstigste Weg, deinen Projekten neben Displays und Tönen den Tastsinn hinzuzufügen. Jetzt, da du Transistor und Diode im Modul, die Stärkeregelung per PWM, den Anlaufimpuls und Haptik-Muster kennst, kannst du lautlose Alarme ebenso entwerfen wie Hilfsmittel für sehbehinderte Menschen. In der BlueGrays-App findest du Projekte wie Buzzer, HC-SR04-Einparkhilfe und PWM-Leistungsregelung mit Schritt-für-Schritt-Schaltplänen und fertigem Code und kannst sie mit einem Vibrationsmotor zu eigenen Ideen weiterentwickeln.

Häufige Fragen

Wie schließe ich einen Vibrationsmotor an den Arduino an?

Verbinde beim fertigen Vibrationsmotor-Modul VCC mit 5V, GND mit GND und IN mit einem PWM-Pin wie D5. Der Transistor auf dem Modul führt den Motorstrom, die Diode schützt den Arduino. Bei einem nackten Motor brauchst du unbedingt einen NPN-Transistor, einen 1-kΩ-Basiswiderstand und eine Diode.

Mit welcher Spannung läuft ein Vibrationsmotor?

Die meisten ERM-Münzmotoren haben 3 V Nennspannung und arbeiten zwischen etwa 2,5 und 3,5 V. Fertige Module können mit 3,3–5 V versorgt werden; bei 5 V vibriert der Motor stärker, im Dauerbetrieb verlängert eine PWM-Begrenzung aber die Lebensdauer. Unter etwa 2 V läuft der Motor nicht an.

Wie viel Strom zieht ein Vibrationsmotor?

Ein typischer Münz-Vibrationsmotor zieht im Betrieb 60–90 mA und beim Anlaufen kurz 100–120 mA. Das ist ein Vielfaches dessen, was ein Arduino-Pin sicher liefern kann. Deshalb sollte der Motor über einen Transistor oder ein fertiges Modul angesteuert werden.

Wie regle ich die Stärke eines Vibrationsmotors?

Die Stärke stellst du per PWM ein, beim Arduino mit analogWrite(pin, 0–255); je höher der Wert, desto schneller dreht der Motor und desto stärker vibriert er. Weil der Motor unter einer Schwelle nicht anläuft, hilft bei kleiner Leistung ein kurzer Vollgas-Impuls von 20–30 ms vor dem Zielwert. Beim ESP32 erledigt das ledcWrite(), beim Pico duty_u16().

Was ist der Unterschied zwischen ERM- und LRA-Vibrationsmotor?

Ein ERM-Motor vibriert, indem er eine Unwucht auf seiner Welle dreht, und läuft mit reiner Gleichspannung. Ein LRA bewegt einen Magneten an einer Feder hin und her, funktioniert nur mit einem Wechselsignal auf seiner Resonanzfrequenz und reagiert knackiger und schneller. Für einen LRA brauchst du einen Haptiktreiber wie den DRV2605.

Warum braucht ein Vibrationsmotor eine Diode?

Weil der Motor eine Spule enthält, entsteht beim Abschalten des Stroms eine hohe Gegenspannungsspitze an seinen Anschlüssen. Eine antiparallel geschaltete Diode schließt diese Spitze kurz und schützt Transistor und Mikrocontroller. Bei fertigen Modulen sitzt diese Diode bereits auf der Platine.

Alle Projekte ansehen
Verwendung des Summers
AR-13Anfänger

Verwendung des Summers

Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

4.7(92)
170
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

HC-SR04 Abstandsmessung (serielle Anzeige)

Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

4.6(50)
82
LED mit Taster schalten (Push)
AR-9Anfänger

LED mit Taster schalten (Push)

Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

4.8(114)
253
Parksensor mit HC-SR04
AR-28Mittel
Premium

Parksensor mit HC-SR04

Eine Mini-Ausgabe der Einparkhilfe im Auto: Je näher etwas kommt, desto schneller piept es.

4.8(64)
86
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

ESP32 LED-Überblendung mit PWM

Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

4.8(36)
55
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32
ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)
ES-38Fortgeschritten
Premium

ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)

Die ESP32-Version einer Einparkhilfe! Der Ultraschallsensor HC-SR04 misst den Abstand zum Objekt davor. Je näher es kommt, desto weiter füllt sich eine Leiste aus 5 LEDs (grün → gelb → rot) und desto schneller piept der Summer. Ganz nah (unter 10 cm) ertönt ein Daueralarm und alle LEDs leuchten. Das SSD1306-OLED zeigt den aktuellen Abstand in cm groß an, dazu einen Statustext.

14
Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
PI-14Anfänger

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)

Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

4