Componenten · 14 min leestijd

Trilmotor Arduino: modulebedrading, PWM en haptische patronen

Trilmotor-Arduino-gids: ERM-muntmotor als module, transistor en diode, trilsterkte met PWM, haptische patronen, slimme stok, ESP32- en Pico-code en een noot over de DRV2605.

In trilmotor-Arduino-projecten is een kleine motor de makkelijkste manier om de gebruiker informatie te geven zonder geluid of licht. Telefoons die zoemen op stil, smartwatches die op je pols tikken en game-controllers die rommelen: ze gebruiken allemaal zulke kleine motoren. Het type dat het meest wordt gebruikt in hobbyelektronica is de ERM-trilmotor in muntvorm, 10 mm breed en slechts 2–3 mm dik. Een kale motor kun je niet rechtstreeks op een Arduino-pin aansluiten, maar een kant-en-klare trilmotormodule met een transistor en een diode erop stuurt hem aan met slechts drie draden.

In deze gids leer je hoe een ERM-motor trilt, waarom de transistor en diode in de module nodig zijn en hoeveel stroom de motor vraagt. Daarna regelen we de trilling stap voor stap met PWM en zien we waarom de motor bij laag vermogen helemaal niet draait en hoe een "kickstart" dat oplost. We schrijven code die haptische patronen afspeelt, zoals een korte tik, een dubbele tik, een hartslag en SOS, zonder delay() te gebruiken, en bouwen de logica van een slimme stok die trilt op basis van afstand. In de laatste delen vind je een voorbeeld dat trilfeedback geeft wanneer je de touch-pin van de ESP32 aanraakt, MicroPython-code voor de Raspberry Pi Pico en de DRV2605-driver voor geavanceerde haptische effecten.

Trilmotormodule
Trilmotormodule: een ERM-motor in muntvorm, een driver-transistor en een beveiligingsdiode op één print.

Wat is een trilmotor en hoe werkt hij?

ERM staat voor "Eccentric Rotating Mass" (excentrisch roterende massa). Op de motoras zit een kleine massa waarvan het zwaartepunt niet precies in het midden ligt. Terwijl de motor draait, trekt deze onevenwichtige massa de motor bij elke omwenteling in één richting, en die trek voel je als trilling. Bij muntmotoren draait de massa binnen in de platte behuizing en beweegt er aan de buitenkant niets, waardoor ze heel makkelijk vast te plakken en te gebruiken zijn. Cilindervormige ERM-motoren hebben aan de buitenkant een halvemaanvormig metalen gewicht en trillen sterker. Zowel de sterkte als de frequentie van de trilling hangen af van het toerental: als de spanning stijgt, draait de motor sneller en wordt de trilling sterker en hoger van toon. De LRA (linear resonant actuator), die steeds vaker in telefoons en game-controllers wordt gebruikt, werkt anders: hij beweegt een magneet op een veer heen en weer en werkt alleen goed met een wisselsignaal op zijn eigen resonantiefrequentie, niet met gewone gelijkspanning. De modules in Arduino-kits zijn bijna altijd ERM.

EigenschapTypische ERM-muntmotor (bijv. 1027)
Afmeting10 mm diameter, 2,7 mm dik
Nominale spanning3 V (ongeveer 2,5–3,5 V)
LooopstroomOngeveer 60–90 mA bij 3 V
AanloopstroomKortstondig 100–120 mA
ToerentalOngeveer 10.000–13.000 rpm
TrillingsfrequentieOngeveer 160–220 Hz
Minimale startspanningOngeveer 2–2,3 V; daaronder start de motor niet

Wat zit er in een trilmotormodule?

Een pin van de Arduino Uno kan maximaal 40 mA leveren en de veilige grens ligt rond 20 mA. Pins van de ESP32 en de Pico zijn nog zwakker. Een trilmotor vraagt 60–120 mA en gedraagt zich als een spoel: op het moment dat de stroom wordt onderbroken, ontstaat over de aansluitingen een hoge spanningspiek in tegengestelde richting. Daarom belast je een pin door de motor er rechtstreeks op aan te sluiten, en kan de microcontroller resetten of zelfs beschadigen. Een kant-en-klare module lost het probleem op met drie onderdelen:

  • Driver-transistor: Meestal een S8050 of een vergelijkbare kleine NPN-transistor, op sommige modules een N-kanaal-MOSFET. De Arduino-pin levert slechts enkele milliampères stuurstroom en de motorstroom loopt door de transistor. Hoe een transistor als schakelaar werkt, legden we uit in Wat is een transistor?.
  • Basisweerstand: Begrenst de stroom van de pin naar de transistor; een waarde van ongeveer 1 kΩ werkt met zowel 5V- als 3,3V-boards.
  • Vrijloopdiode: Deze diode, in sperrichting over de motor geschakeld, sluit de spanningspiek kort die ontstaat als de motor uitschakelt en beschermt de transistor. Over zijn taak lees je meer in Wat is een diode?.

De meeste modules hebben drie pins: VCC, GND en de signaalpin IN (op sommige boards S of SIG). Als je IN HIGH maakt, gaat de transistor open en draait de motor. De module zelf werkt op 3,3–5 V. Op 5 V ziet de motor na de kleine spanningsval over de transistor ongeveer 4,5 V, en dat is hoger dan de nominale waarde van een 3V-motor. Voor korte meldingen is dat prima, maar als de motor lange tijd continu draait, verlengt het beperken van het vermogen tot ongeveer 60–70 procent met PWM zijn levensduur.

Bedrading: Arduino Uno, ESP32 en Raspberry Pi Pico

De tabel hieronder toont de pins die alle sketches in dit artikel gebruiken. Op elk board moet de motorpin PWM kunnen uitsturen. Op de ESP32 en Pico is het 3,3 V-signaal naar de IN-pin genoeg om de transistor aan te sturen; je kunt de VCC-pin van de module op 5 V aansluiten voor sterkere trilling of op 3,3 V voor zachtere trilling. Welke voeding je ook kiest, de massa's moeten gemeenschappelijk zijn.

AansluitingArduino UnoESP32Raspberry Pi Pico
VCC van de module5VVIN (5 V) of 3V3VBUS (5 V) of 3V3(OUT)
GND van de moduleGNDGNDGND
IN van de moduleD5 (PWM)GPIO 25GP15
Knop (andere pootje naar GND)D2Touch-pin GPIO 4 (T0)GP14
HC-SR04 TRIG (voorbeeld slimme stok)D9--
HC-SR04 ECHO (voorbeeld slimme stok)D10--
Als je een kale motor zonder module gebruikt, sluit je hem nooit rechtstreeks op een pin aan. Sluit de ene motordraad aan op 5 V en de andere op de collector van een NPN-transistor (2N2222, BC337 of S8050); sluit de emitter aan op GND en de basis via een weerstand van 1 kΩ op de Arduino-pin. Plaats een 1N4148- of 1N5819-diode over de motor met de kathode (kant met de streep) naar 5 V. Als je de diode weglaat, kan de transistor snel kapotgaan en kan de Arduino willekeurig resetten. De basisweerstand controleer je met de tool Wet van Ohm en de stroom- en versterkingswaarden van de transistor met de tool Transistor.

Eerste sketch: aan/uit en trilsterkte met PWM

Je kunt een trilmotormodule zien als een led: digitalWrite(HIGH) laat de motor op vol vermogen draaien, terwijl analogWrite() met PWM de gemiddelde spanning en dus de sterkte van de trilling instelt. Op de Arduino Uno werken pin D5 en D6 op ongeveer 980 Hz en de andere PWM-pins op ongeveer 490 Hz. De basis van PWM behandelden we uitgebreid in Wat is PWM?. ERM-motoren hebben een belangrijke eigenschap: om een stilstaande motor te laten draaien is meer vermogen nodig dan om een draaiende motor draaiende te houden. Daarom beweegt een motor die met een lage PWM-waarde wordt gestart misschien helemaal niet. De oplossing is de motor een paar tientallen milliseconden op vol vermogen te starten en dan terug te gaan naar de gewenste waarde; dit heet een kickstart. De sketch hieronder geeft eerst een korte zoem op vol vermogen, verhoogt dan stap voor stap de sterkte en print elke stap naar de Serial 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}

Als je de code uitvoert, merk je dat de motor onder een bepaalde PWM-waarde helemaal niet of nauwelijks trilt. Met een 5V-voeding ligt deze drempel meestal tussen 70 en 110; de exacte waarde hangt af van de motor en de module. Noteer de waarde in de Serial Monitor waarbij je de motor voor het eerst duidelijk voelt en gebruik die als minimaal vermogen in je project. Dankzij de kickstart kunnen ook waarden iets onder deze drempel werken, omdat de motor, eenmaal draaiend, met minder vermogen blijft draaien.

PWM-waarde (5V-voeding)Gemiddelde spanningTrilling die je voelt
0–600–1,2 VGeen, de motor draait niet
70–1101,4–2,2 VDrempelzone; kickstart kan nodig zijn
120–1702,4–3,3 VLichte tot gemiddelde trilling, ideaal voor lange meldingen
180–2553,5–4,5 VSterke trilling, voor korte, aandachttrekkende meldingen

Haptische patronen: korte tik, dubbele tik, hartslag en SOS

Eén soort trilling zegt alleen "er is iets gebeurd". Verschillende patronen vertellen de gebruiker ook wat er gebeurd is: een korte tik kan een bevestiging zijn, twee korte tikken een waarschuwing, een lange zoem een alarm en een hartslagachtig ritme een herinnering. De menselijke hand voelt trillingen korter dan 20–30 ms nauwelijks, en een ERM-motor heeft ongeveer 30–50 ms nodig om op toeren te komen. Houd de kortste zoem in een patroon dus op 40–60 ms en de pauze tussen twee zoemen op minstens 80–100 ms. In de sketch hieronder is elk patroon een array van {vermogen, duur}-paren. De patroonspeler werkt met millis(), zodat loop() andere taken kan doen terwijl een patroon wordt afgespeeld. Elke druk op de knop op D2 speelt het volgende patroon af.

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}

Om de patronen te wijzigen hoef je alleen de arrays aan te passen; de afspeelfunctie blijft hetzelfde. In het SOS-patroon duren de korte zoemen 100 ms, de lange 350 ms en de pauze tussen letters 300 ms; deze verhoudingen volgen de indeling "punt, streep" van morsecode. Houd patronen duidelijk verschillend, zodat gebruikers ze niet door elkaar halen: gebruik verschillende aantallen (één, twee, drie zoemen) of duidelijk verschillende duren. Voordat je patronen aan een project toevoegt, probeer je ze op een paar mensen uit en vraag je hun te raden wat elk patroon betekent; bij haptisch ontwerp is dat de beste test.

Wearable-meldingen en de slimme stok

Een trilmotor komt tot zijn recht waar geluid hinderlijk is of niet te horen. In wearable-projecten plaats je de motor in een polsband, handschoen of riem, dicht bij de huid. De binnenkant van de pols, de handpalm en de vingertoppen zijn de gebieden die het gevoeligst zijn voor trilling. De motor vastplakken op een hard oppervlak, bijvoorbeeld de binnenwand van een 3D-geprinte behuizing met dubbelzijdig tape, geeft de trilling beter door dan hem losjes aan stof vastnaaien. In slimme-stokprojecten voor slechtzienden komt de motor in het deel van de handgreep recht onder de duim, en wordt de afstand tot een obstakel omgezet in de snelheid en sterkte van de trilling: naarmate het obstakel dichterbij komt, volgen de zoemen sneller en sterker op elkaar en gaan ze over in continue trilling als het heel dichtbij is. De sketch hieronder toont deze logica met een HC-SR04-afstandssensor.

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}

Om het eenvoudig te houden gebruikt deze sketch delay() en doet hij geen nieuwe metingen terwijl hij wacht; in een echte stok reageert een structuur op basis van millis(), zoals in het vorige deel, beter. We houden het minimale vermogen op 150, zodat de motor voor verre obstakels niet onder zijn drempel blijft en niet draait. Voor een compleet project met plasdetectie, valdetectie, SOS en batterijberekeningen zie je Slimme stok met Arduino, en voor details over de sensor de gids over de HC-SR04-afstandssensor.

Stroom, voeding en batterijduur

Een muntmotor vraagt 60–90 mA tijdens het draaien en kortstondig meer dan 100 mA bij het starten. Dat kan de 5V-pin van de Arduino Uno via USB gemakkelijk leveren. Problemen ontstaan meestal in schakelingen op batterijen waarvan de spanning al krap is, of in projecten met meerdere motoren die tegelijk draaien: als de motor start, zakt de spanning even in en reset het board. Om dit te voorkomen plaats je een elco van 47–100 µF tussen de VCC- en GND-pin van de module, en als je meer dan één motor gebruikt, start je ze een paar milliseconden na elkaar in plaats van tegelijk. Bedenk bij het berekenen van de batterijduur dat de motor in korte uitbarstingen draait, niet continu: een motor van 80 mA die in totaal 3 seconden per minuut draait, heeft bijvoorbeeld een gemiddelde stroom van slechts 4 mA. Gebruik de tool Batterijduur met de waarden van je eigen project om te zien hoeveel uur het meegaat.

Aanraakfeedback met de ESP32

Twee voordelen van de ESP32 combineren heel goed met een trilmotor: de chip heeft capacitieve touch-pins en de LEDC-eenheid die PWM genereert, laat je de frequentie vrij instellen. De sketch hieronder geeft een korte "klik"-zoem, zoals bij een telefoonscherm, wanneer een draad of stukje koperfolie dat op GPIO 4 (T0) is aangesloten wordt aangeraakt; als de aanraking langer dan 1 seconde duurt, bevestigt hij met een lange zoem. We stellen de PWM-frequentie in op 20 kHz, dat op de grens van het menselijk gehoor ligt, zodat ook een zwak gepiep van de motordriver verdwijnt. De code compileert met zowel de 2.x- als de 3.x-versie van de ESP32 Arduino-core, omdat de LEDC-functienamen per versie verschillen.

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}

Op de ESP32 ligt de waarde van de touch-pin meestal rond 50–80 zonder aanraking en daalt hij duidelijk bij aanraking met een vinger; daarom meet de code bij het opstarten de gemiddelde waarde en berekent hij de drempel automatisch. Op de ESP32-S2 en S3 gaan de touchwaarden echter de andere kant op en stijgen ze bij aanraking; op die boards moet je de vergelijking omkeren. Als je de VCC-pin van de module op de VIN-pin van de ESP32 aansluit, trilt de motor sterker op 5 V; het 3,3 V-signaal op de IN-pin is genoeg om de transistor aan te sturen. Door dit te combineren met Wi-Fi of Bluetooth kun je een polsband bouwen die zoemt als je telefoon een melding krijgt, of een meldingsapparaat dat je via ESP32 BLE bestuurt.

Trilmotor met de Raspberry Pi Pico en MicroPython

Op de Raspberry Pi Pico kan elke GPIO-pin PWM genereren. In MicroPython neemt de functie duty_u16() van de klasse PWM een waarde tussen 0 en 65535; 65535 betekent vol vermogen. De code hieronder speelt een hartslagpatroon af telkens als de knop op GP14 wordt ingedrukt. Net als in het Arduino-voorbeeld is het patroon een lijst van paren vermogen en duur. Je kunt de VCC-pin van de module aansluiten op VBUS (de 5 V van USB) voor sterkere trilling of op 3V3(OUT) voor zachtere trilling.

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)

De pins van de Pico werken op 3,3 V en het wordt afgeraden om meer dan ongeveer 12 mA uit één pin te halen, dus ook met de Pico gebruik je de transistormodule en geen kale motor. De knop wordt niet gelezen terwijl een patroon wordt afgespeeld; als je meerdere dingen tegelijk wilt doen, kun je het millis()-patroon van Arduino bouwen met time.ticks_ms() of de patroonstappen laten doorlopen met een Timer-interrupt. Als je net begint met MicroPython, is het artikel MicroPython-basis een goede start.

DRV2605 haptische driver: professionele trileffecten

Een transistormodule schakelt de motor alleen aan en uit of maakt hem met PWM sterker of zwakker. De scherpe "klik" die je op een telefoon voelt, komt van het heel snel starten en stoppen van de motor: de motor wordt eerst versneld met een puls boven zijn nominale spanning (overdrive) en als de trilling eindigt, wordt hij afgeremd met een korte spanning in tegengestelde richting. De DRV2605L-chip van Texas Instruments doet dit zelf. Hij verbindt via I2C (adres 0x5A), kan zowel ERM- als LRA-motoren aansturen en bevat 123 ingebouwde effecten zoals klikken, dubbele klikken, zoemen en zachte bonzen. Hij leert de eigenschappen van de motor via autokalibratie en kan een audio-ingang omzetten in trilling. Met de Adafruit DRV2605-bibliotheek kost het maar een paar regels; op de Uno sluit je SDA aan op A4 en SCL op A5, en de motor steek je rechtstreeks in de motoruitgang van het DRV2605-board.

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}

De DRV2605 kan in één reeks maximaal 8 effecten achter elkaar afspelen; je vult slot 0 tot 7 met setWaveform() en markeert het einde van de reeks met 0. Als je een LRA-motor gebruikt, roep je useLRA() aan en kies je LRA-bibliotheeknummer 6. Voor eenvoudige meldingen is een transistormodule meer dan genoeg; als je een wearable, een game-controller of een aanraakinterface ontwerpt, verbetert de DRV2605 het gevoel merkbaar.

Projectideeën met een trilmotor

  • Stille timerpolsband: Bouw een pomodoro-timer die op je pols zoemt als de les of studiesessie afloopt, zonder de klas te storen.
  • Slimme stok voor slechtzienden: Volg de gids over de slimme stok voor een compleet project dat de afstand tot obstakels omzet in een trilritme.
  • Stille deurbel: Laat een apparaatje in je zak zoemen wanneer een PIR-bewegingssensor bij de deur iemand detecteert.
  • Game-controller: Voeg rumble bij botsingen toe aan een game-controller gebouwd met een joystickmodule.
  • Houdingsherinnering: Meet de hoek van je rug met een MPU6050 en geef een korte zoem als je te lang gebogen zit.
  • Trilling in plaats van geluid: Plaats in een alarm voor 's nachts een trilmotor onder het kussen in plaats van een buzzer.

Veelgemaakte fouten en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
De motor draait helemaal nietPWM-waarde onder de startdrempel of geen gemeenschappelijke GNDProbeer eerst 255, voeg een kickstart toe en verbind de massa's
De Arduino reset als de motor draaitDe aanloopstroom laat de voeding instorten of er is geen diodeGebruik een kant-en-klare module en plaats een condensator van 47–100 µF tussen VCC en GND
De trilling is heel zwakDe module werkt op 3,3 V of de motor ligt op een zacht oppervlakSluit VCC aan op 5 V en plak de motor op een hard oppervlak
De motor wordt warmHij draait lange tijd op vol vermogen op 5 VBeperk het vermogen tot 60–70% met PWM en gebruik korte pulsen in plaats van continue trilling
Er komt een zwak gepiep uit de motorDe PWM-frequentie ligt in het hoorbare bereikStel de LEDC-frequentie op de ESP32 in op 20 kHz; gebruik korte zoemen op de Uno
Fout "ledcSetup niet gevonden" op de ESP32ESP32-core versie 3.xGebruik de #if ESP_ARDUINO_VERSION_MAJOR-schakelaar uit dit artikel
Een pin werkt niet meer na het aansluiten van een kale motorDe motor was rechtstreeks op de pin aangesloten en heeft hem beschadigdGebruik een andere pin en stuur de motor altijd aan via een transistor en diode
De patronen voelen hetzelfde aanDe zoemen zijn te kort of de pauzes te kortMaak de kortste zoem 40–60 ms en de pauze minstens 100 ms
Test de trilling op de plek waar hij echt gebruikt wordt, niet op je bureau. Een motor op een tafel laat het hout trillen en voelt sterker aan dan hij is; in een polsband of een stokhandvat kan dezelfde motor veel zwakker aanvoelen. Bevestig de motor stevig op een hard oppervlak, zet de draden vast zodat ze niet onder spanning staan en meet de PWM-drempelwaarde opnieuw na de eindmontage.

Een trilmotor is de goedkoopste manier om naast schermen en geluid ook het gevoel van aanraking aan je projecten toe te voegen. Nu je weet wat de transistor en diode in de module doen, hoe je de sterkte met PWM instelt en wat de kickstart en haptische patronen zijn, kun je zowel stille meldingen als hulpmiddelen voor slechtzienden ontwerpen. In de BlueGrays-app kun je projecten zoals een buzzer, een HC-SR04-parkeersensor en PWM-vermogensregeling verkennen met stapsgewijze schakelschema's en kant-en-klare code, en je eigen ideeën ontwikkelen door er een trilmotor aan toe te voegen.

Veelgestelde vragen

Hoe sluit ik een trilmotor aan op een Arduino?

Sluit de VCC-pin van de kant-en-klare trilmotormodule aan op 5V, GND op GND en IN op een PWM-pin zoals D5. De transistor op de module voert de motorstroom en de diode beschermt de Arduino. Als je een kale motor gebruikt, moet je een NPN-transistor, een basisweerstand van 1 kΩ en een diode toevoegen.

Op welke spanning werkt een trilmotor?

De meeste ERM-trilmotoren in muntvorm hebben een nominale spanning van 3 V en werken tussen ongeveer 2,5 en 3,5 V. Kant-en-klare modules kunnen worden gevoed met 3,3–5 V; op 5 V trilt de motor sterker, maar bij langdurig gebruik verlengt het beperken van het vermogen met PWM zijn levensduur. Onder ongeveer 2 V start de motor niet.

Hoeveel stroom vraagt een trilmotor?

Een typische trilmotor in muntvorm vraagt 60–90 mA tijdens het draaien en kortstondig 100–120 mA bij het starten. Dat is een veelvoud van de stroom die een Arduino-pin veilig kan leveren. De motor moet dus worden aangestuurd via een transistor of een kant-en-klare module.

Hoe regel ik de sterkte van een trilmotor?

De sterkte stel je in met PWM, dus met analogWrite(pin, 0–255) op de Arduino; hoe hoger de waarde, hoe sneller de motor draait en hoe sterker hij trilt. Omdat de motor onder een bepaalde drempel niet draait, werkt het goed om bij laag vermogen eerst 20–30 ms vol vermogen te geven en dan terug te gaan naar de doelwaarde. Op de ESP32 doet ledcWrite() en op de Pico duty_u16() hetzelfde.

Wat is het verschil tussen ERM- en LRA-trilmotoren?

Een ERM-motor trilt doordat een onevenwichtige massa op zijn as draait en werkt op gewone gelijkspanning. Een LRA beweegt een magneet op een veer heen en weer, werkt alleen met een wisselsignaal op zijn resonantiefrequentie en reageert scherper en sneller. Voor het aansturen van een LRA is een haptische driver zoals de DRV2605 nodig.

Waarom heeft een trilmotor een diode nodig?

Omdat de motor een spoel bevat, ontstaat op het moment dat de stroom wordt onderbroken een hoge spanningspiek in tegengestelde richting over de aansluitingen. Een diode die in sperrichting over de motor is geschakeld, sluit deze piek kort en voorkomt dat de transistor en de microcontroller beschadigd raken. Op kant-en-klare modules zit deze diode al op de print.

Alle projecten bekijken
Een buzzer gebruiken
AR-13Beginner

Een buzzer gebruiken

Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

4.7(92)
170
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
Parkeersensor met HC-SR04
AR-28Gemiddeld
Premium

Parkeersensor met HC-SR04

Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

4.8(64)
86
ESP32-led dimmen met PWM
ES-8Beginner

ESP32-led dimmen met PWM

De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

4.8(36)
55
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32
ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
ES-38Gevorderd
Premium

ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)

De ESP32-versie van een parkeersensor voor auto's! De HC-SR04-ultrasoonsensor meet de afstand tot het voorwerp ervoor. Naarmate je dichterbij komt, vult een balk van 5 leds zich (groen → geel → rood) en piept de buzzer sneller. Heel dichtbij (onder 10 cm) klinkt een continu alarm en branden alle leds. Het SSD1306 OLED-display toont de live afstand in cm in grote tekst, plus een statusbericht.

14
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4