Componenti · 14 min di lettura

Motore a vibrazione Arduino: modulo, PWM e pattern aptici

Motore a vibrazione Arduino: modulo con motore ERM a moneta, transistor e diodo, intensità in PWM, pattern aptici, bastone smart, codice ESP32 e Pico, DRV2605.

Nei progetti con motore a vibrazione e Arduino, un piccolo motore è il modo più semplice per informare l'utente senza suoni né luci. Gli smartphone in modalità silenziosa, gli smartwatch che ti toccano il polso e i controller che tremano usano tutti questi minuscoli motori. Il tipo più diffuso nell'elettronica hobbistica è il motore ERM a moneta (coin), largo 10 mm e spesso solo 2–3 mm. Un motore nudo non si può collegare direttamente a un pin di Arduino, ma un modulo motore a vibrazione già pronto, con transistor e diodo, funziona con soli tre cavi.

In questa guida imparerai come vibra un motore ERM, perché servono il transistor e il diodo del modulo e quanta corrente assorbe il motore. Poi regoleremo la vibrazione a passi con il PWM e vedremo perché a bassa potenza il motore non parte affatto e come lo risolve un "impulso di avvio". Scriveremo un codice che riproduce pattern aptici come un tocco breve, un doppio tocco, un battito cardiaco e un SOS senza usare delay(), e costruiremo la logica di un bastone smart che vibra in base alla distanza. Nelle ultime sezioni trovi un esempio che dà una risposta vibrante quando tocchi il pin touch dell'ESP32, il codice MicroPython per il Raspberry Pi Pico e il driver DRV2605 per effetti aptici avanzati.

Modulo motore a vibrazione
Modulo motore a vibrazione: motore ERM a moneta, transistor di pilotaggio e diodo di protezione su un'unica scheda.

Che cos'è un motore a vibrazione e come funziona?

ERM sta per "Eccentric Rotating Mass", cioè massa rotante eccentrica. Sull'albero del motore c'è una piccola massa il cui baricentro non è esattamente al centro. Mentre il motore gira, questa massa sbilanciata lo tira da un lato a ogni giro, e quella spinta è ciò che senti come vibrazione. Nei motori a moneta la massa gira dentro l'involucro piatto e all'esterno non si muove nulla, per questo sono facilissimi da incollare e usare. I motori ERM cilindrici hanno all'esterno un contrappeso metallico a mezzaluna e vibrano più forte. Sia l'intensità sia la frequenza della vibrazione dipendono dalla velocità del motore: aumentando la tensione il motore accelera e la vibrazione diventa più forte e più acuta. L'LRA (attuatore lineare risonante), sempre più usato negli smartphone e nei controller, funziona diversamente: muove avanti e indietro un magnete su una molla e lavora bene solo con un segnale alternato alla propria frequenza di risonanza, non con una tensione continua. I moduli dei kit Arduino sono quasi sempre ERM.

CaratteristicaTipico motore ERM a moneta (es. 1027)
Dimensioni10 mm di diametro, 2,7 mm di spessore
Tensione nominale3 V (circa 2,5–3,5 V)
Corrente di lavoroCirca 60–90 mA a 3 V
Corrente di avvioPer un attimo 100–120 mA
VelocitàCirca 10.000–13.000 giri/min
Frequenza di vibrazioneCirca 160–220 Hz
Tensione minima di avvioCirca 2–2,3 V; sotto il motore non parte

Che cosa c'è dentro un modulo motore a vibrazione?

Un pin di Arduino Uno fornisce al massimo 40 mA e il limite sicuro è intorno ai 20 mA. I pin di ESP32 e Pico sono ancora più deboli. Un motore a vibrazione invece assorbe 60–120 mA e si comporta come una bobina: nell'istante in cui la corrente viene interrotta, ai suoi capi compare un forte picco di tensione inversa. Per questo collegare il motore direttamente a un pin sforza il pin e può resettare o persino danneggiare il microcontrollore. Un modulo già pronto risolve il problema con tre componenti:

  • Transistor di pilotaggio: Di solito un S8050 o un piccolo NPN simile, su alcuni moduli un MOSFET a canale N. Il pin di Arduino fornisce solo pochi milliampere di comando e la corrente del motore passa nel transistor. Spieghiamo come funziona un transistor come interruttore in Che cos'è un transistor?.
  • Resistenza di base: Limita la corrente dal pin al transistor; un valore di circa 1 kΩ va bene sia con schede a 5 V sia a 3,3 V.
  • Diodo di ricircolo (flyback): Collegato in antiparallelo al motore, cortocircuita il picco di tensione che nasce allo spegnimento e protegge il transistor. Trovi il suo compito spiegato in Che cos'è un diodo?.

La maggior parte dei moduli ha tre pin: VCC, GND e il pin di segnale IN (S o SIG su alcune schede). Quando porti IN a HIGH, il transistor conduce e il motore gira. Il modulo funziona a 3,3–5 V. Alimentato a 5 V, il motore riceve circa 4,5 V dopo la piccola caduta sul transistor, più della tensione nominale di un motore da 3 V. Per avvisi brevi non è un problema, ma se il motore deve girare a lungo senza sosta, limitare la potenza al 60–70 per cento con il PWM ne allunga la vita.

Collegamento: Arduino Uno, ESP32 e Raspberry Pi Pico

La tabella qui sotto riporta i pin usati da tutti gli sketch di questo articolo. Su ogni scheda il pin del motore deve poter generare PWM. Su ESP32 e Pico il segnale a 3,3 V sul pin IN basta per pilotare il transistor; il pin VCC del modulo puoi collegarlo a 5 V per una vibrazione più forte o a 3,3 V per una più delicata. Qualunque alimentazione tu scelga, le masse (GND) devono essere in comune.

CollegamentoArduino UnoESP32Raspberry Pi Pico
VCC del modulo5VVIN (5 V) o 3V3VBUS (5 V) o 3V3(OUT)
GND del moduloGNDGNDGND
IN del moduloD5 (PWM)GPIO 25GP15
Pulsante (altro capo a GND)D2Pin touch GPIO 4 (T0)GP14
HC-SR04 TRIG (esempio del bastone)D9--
HC-SR04 ECHO (esempio del bastone)D10--
Se usi un motore nudo senza modulo, non collegarlo mai direttamente a un pin. Collega un capo del motore a 5 V e l'altro al collettore di un transistor NPN (2N2222, BC337 o S8050); l'emettitore a GND e la base al pin di Arduino tramite una resistenza da 1 kΩ. Metti un diodo 1N4148 o 1N5819 ai capi del motore, con il catodo (lato con la fascia) verso i 5 V. Senza diodo il transistor può guastarsi presto e Arduino resettarsi a caso. Puoi controllare la resistenza di base con lo strumento Legge di Ohm e corrente e guadagno del transistor con lo strumento Transistor.

Primo sketch: acceso, spento e intensità con il PWM

Puoi pensare al modulo motore a vibrazione come a un LED: digitalWrite(HIGH) fa girare il motore a piena potenza, mentre analogWrite() regola con il PWM la tensione media e quindi l'intensità della vibrazione. Su Arduino Uno i pin D5 e D6 lavorano a circa 980 Hz e gli altri pin PWM a circa 490 Hz. Abbiamo spiegato le basi del PWM in Che cos'è il PWM?. I motori ERM hanno una caratteristica importante: far partire un motore fermo richiede più potenza che mantenere in rotazione un motore già avviato. Per questo un motore avviato con un valore PWM basso potrebbe non muoversi affatto. La soluzione è avviarlo per qualche decina di millisecondi a piena potenza e poi scendere al valore desiderato; si chiama impulso di avvio (kick-start). Lo sketch qui sotto fa prima una breve vibrazione a piena potenza, poi aumenta l'intensità a passi e stampa ogni passo sul Monitor seriale.

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}

Eseguendo il codice noterai che sotto un certo valore PWM il motore non vibra affatto o vibra molto poco. Con alimentazione a 5 V questa soglia è di solito tra 70 e 110; il valore esatto dipende dal motore e dal modulo. Annota dal Monitor seriale il valore in cui senti chiaramente il motore per la prima volta e usalo come potenza minima nel tuo progetto. Grazie all'impulso di avvio funzionano anche valori un po' sotto questa soglia, perché un motore già in rotazione continua a girare con meno potenza.

Valore PWM (alimentazione 5 V)Tensione mediaVibrazione percepita
0–600–1,2 VNessuna, il motore non gira
70–1101,4–2,2 VZona di soglia; può servire l'impulso di avvio
120–1702,4–3,3 VVibrazione leggera o media, ideale per avvisi lunghi
180–2553,5–4,5 VVibrazione forte, per avvisi brevi e ben evidenti

Pattern aptici: tocco breve, doppio tocco, battito e SOS

Una vibrazione sempre uguale dice solo "è successo qualcosa". Pattern diversi dicono anche che cosa: un tocco breve può indicare una conferma, due tocchi brevi un avvertimento, una vibrazione lunga un allarme e un ritmo simile a un battito cardiaco un promemoria. La mano umana percepisce a fatica vibrazioni più brevi di 20–30 ms e un motore ERM ha bisogno di circa 30–50 ms per prendere velocità. Quindi tieni la vibrazione più breve di un pattern a 40–60 ms e la pausa tra due vibrazioni ad almeno 80–100 ms. Nello sketch qui sotto ogni pattern è un array di coppie {potenza, durata}. Il riproduttore di pattern lavora con millis(), quindi loop() può fare altro mentre un pattern è in corso. A ogni pressione del pulsante su D2 parte il pattern successivo.

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}

Per cambiare i pattern basta modificare gli array; la funzione che li riproduce resta uguale. Nel pattern SOS le vibrazioni brevi durano 100 ms, quelle lunghe 350 ms e la pausa tra le lettere 300 ms; queste proporzioni seguono lo schema "punto, linea" del codice Morse. Tieni i pattern ben distinti perché nessuno li confonda: con un numero diverso di vibrazioni (una, due, tre) o con durate nettamente diverse. Prima di inserirli in un progetto provali su qualche persona e chiedi di indovinare che cosa significa ciascuno; nel design aptico è il test migliore.

Avvisi indossabili e bastone smart

Il motore a vibrazione dà il meglio dove il suono disturba o non si sente. Nei progetti indossabili metti il motore dentro un braccialetto, un guanto o una cintura, vicino alla pelle. L'interno del polso, il palmo e i polpastrelli sono le zone più sensibili alla vibrazione. Incollare il motore su una superficie rigida, per esempio sulla parete interna di una scatola stampata in 3D con nastro biadesivo, trasmette meglio la vibrazione che cucirlo lasco sul tessuto. Nei bastoni smart per persone non vedenti il motore va nella parte dell'impugnatura proprio sotto il pollice, e la distanza dall'ostacolo diventa frequenza e intensità della vibrazione: più l'ostacolo si avvicina, più le vibrazioni sono fitte e forti, fino a diventare continue quando è vicinissimo. Lo sketch qui sotto mostra questa logica con un sensore di distanza HC-SR04.

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}

Per semplicità questo sketch usa delay() e non misura durante l'attesa; in un bastone vero una struttura basata su millis() come quella della sezione precedente risponde meglio. Teniamo la potenza minima a 150 perché, con ostacoli lontani, il motore non resti sotto la soglia senza girare. Per un progetto completo con avviso pozzanghere, rilevamento cadute, SOS e calcolo della batteria guarda il progetto bastone smart con Arduino, e per i dettagli del sensore la guida al sensore di distanza HC-SR04.

Corrente, alimentazione e durata della batteria

Un motore a moneta assorbe 60–90 mA mentre gira e, all'avvio, per un attimo poco più di 100 mA. Il pin 5V di Arduino Uno li fornisce senza problemi dall'USB. I guai nascono di solito nei circuiti a batteria con tensione già al limite, o nei progetti con più motori che girano insieme: all'avvio del motore la tensione cala per un istante e la scheda si resetta. Per evitarlo aggiungi un condensatore elettrolitico da 47–100 µF tra VCC e GND del modulo e, se usi più motori, avviali a qualche millisecondo di distanza e non nello stesso momento. Nel calcolo della batteria ricorda che il motore lavora a brevi impulsi, non di continuo: per esempio un motore da 80 mA che gira in tutto 3 secondi al minuto ha una corrente media di soli 4 mA. Con i valori del tuo progetto lo strumento Durata della batteria ti dice quante ore durerà.

Feedback tattile con l'ESP32

Due punti di forza dell'ESP32 si sposano benissimo con un motore a vibrazione: il chip ha pin touch capacitivi e l'unità LEDC che genera il PWM permette di scegliere liberamente la frequenza. Lo sketch qui sotto dà un breve "clic", come lo schermo di uno smartphone, quando tocchi un filo o un pezzo di nastro di rame collegato al GPIO 4 (T0); se il tocco dura più di 1 secondo, conferma con una vibrazione lunga. Abbiamo impostato la frequenza PWM a 20 kHz, al limite dell'udito umano, così sparisce anche l'eventuale sibilo del driver del motore. Il codice compila con le versioni 2.x e 3.x del core Arduino dell'ESP32, perché i nomi delle funzioni LEDC sono diversi tra le due.

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}

Sull'ESP32 il valore del pin touch è di solito intorno a 50–80 senza contatto e scende nettamente quando lo tocchi con un dito; per questo il codice misura la media all'avvio e calcola la soglia da solo. Su ESP32-S2 e S3, invece, i valori touch salgono al tocco; su queste schede devi invertire il confronto. Se colleghi il VCC del modulo al pin VIN dell'ESP32, il motore vibra più forte a 5 V; il segnale a 3,3 V sul pin IN basta per il transistor. Combinando tutto con Wi-Fi o Bluetooth puoi realizzare un braccialetto che vibra quando arriva una notifica sullo smartphone, oppure un dispositivo di allarme comandato via BLE dell'ESP32.

Motore a vibrazione con Raspberry Pi Pico e MicroPython

Sul Raspberry Pi Pico ogni pin GPIO può generare PWM. In MicroPython la funzione duty_u16() della classe PWM accetta un valore tra 0 e 65535; 65535 significa piena potenza. Il codice qui sotto riproduce un pattern a battito cardiaco a ogni pressione del pulsante su GP14. Come nell'esempio Arduino, il pattern è una lista di coppie potenza-durata. Puoi collegare il VCC del modulo a VBUS (i 5 V dell'USB) per una vibrazione più forte o a 3V3(OUT) per una più delicata.

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)

I pin del Pico lavorano a 3,3 V e non è consigliato prelevare più di circa 12 mA da un singolo pin; anche con il Pico, quindi, serve il modulo con transistor e non un motore nudo. Mentre un pattern è in corso il pulsante non viene letto; se devi fare più cose insieme puoi ricreare lo schema millis() di Arduino con time.ticks_ms() o far avanzare i passi del pattern con un interrupt Timer. Se stai iniziando con MicroPython, l'articolo basi di MicroPython è un buon punto di partenza.

Driver aptico DRV2605: effetti di vibrazione professionali

Un modulo a transistor si limita ad accendere e spegnere il motore o a renderlo più forte o più debole con il PWM. Il "clic" netto che senti su uno smartphone nasce invece da avvii e arresti rapidissimi: il motore viene prima accelerato con un impulso sopra la tensione nominale (overdrive) e alla fine frenato con una breve tensione inversa. Il chip DRV2605L di Texas Instruments lo fa da solo. Si collega in I2C (indirizzo 0x5A), pilota motori ERM e LRA e contiene 123 effetti integrati come clic, doppi clic, ronzii e colpi morbidi. Impara le caratteristiche del motore con l'autocalibrazione e può trasformare un ingresso audio in vibrazione. Con la libreria Adafruit DRV2605 bastano poche righe; su Uno colleghi SDA ad A4 e SCL ad A5, e il motore si collega direttamente all'uscita motore della scheda DRV2605.

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}

Il DRV2605 può riprodurre fino a 8 effetti di fila in una sequenza; riempi gli slot da 0 a 7 con setWaveform() e segni la fine della sequenza con 0. Se usi un motore LRA, chiama useLRA() e scegli la libreria LRA numero 6. Per avvisi semplici un modulo a transistor basta e avanza; se progetti un dispositivo indossabile, un controller di gioco o un'interfaccia touch, il DRV2605 migliora nettamente la sensazione.

Idee di progetto con il motore a vibrazione

  • Braccialetto timer silenzioso: Costruisci un timer pomodoro che vibra al polso quando finisce la lezione o la sessione di studio, senza disturbare nessuno.
  • Bastone smart per non vedenti: Segui la guida al bastone smart per un progetto completo che trasforma la distanza dall'ostacolo in un ritmo di vibrazione.
  • Campanello silenzioso: Fai vibrare un dispositivo in tasca quando un sensore di movimento PIR alla porta rileva qualcuno.
  • Controller di gioco: Aggiungi la vibrazione negli urti a un controller costruito con un modulo joystick.
  • Avviso di postura: Misura l'inclinazione della schiena con un MPU6050 e avvisa con una breve vibrazione quando stai troppo a lungo ingobbito.
  • Vibrazione al posto del suono: In una sveglia notturna metti un motore a vibrazione sotto il cuscino invece di un buzzer.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
Il motore non gira per nienteValore PWM sotto la soglia di avvio o GND non in comuneProva prima con 255, aggiungi l'impulso di avvio e unisci le masse
Arduino si resetta quando gira il motoreLa corrente di avvio fa crollare l'alimentazione o manca il diodoUsa un modulo già pronto e aggiungi 47–100 µF tra VCC e GND
La vibrazione è debolissimaIl modulo è alimentato a 3,3 V o il motore poggia su una superficie morbidaCollega VCC a 5 V e incolla il motore su una superficie rigida
Il motore si scaldaGira a lungo a piena potenza a 5 VLimita la potenza al 60–70 % con il PWM e usa impulsi brevi invece della vibrazione continua
Dal motore esce un sottile sibiloLa frequenza PWM è nella gamma udibileSull'ESP32 porta la frequenza LEDC a 20 kHz; su Uno usa vibrazioni brevi
Errore ledcSetup non trovato sull'ESP32Core ESP32 versione 3.xUsa lo scambio #if ESP_ARDUINO_VERSION_MAJOR di questo articolo
Un pin non funziona più dopo aver collegato un motore nudoIl motore era collegato direttamente al pin e lo ha danneggiatoUsa un altro pin e pilota sempre il motore con transistor e diodo
I pattern sembrano tutti ugualiVibrazioni troppo brevi o pause troppo stretteVibrazione più breve a 40–60 ms e pausa di almeno 100 ms
Prova la vibrazione dove verrà usata davvero, non sulla scrivania. Un motore appoggiato sul tavolo fa vibrare il legno e sembra più forte di quanto sia; dentro un braccialetto o nell'impugnatura di un bastone lo stesso motore può sembrare molto più debole. Fissa bene il motore a una superficie rigida, blocca i cavi perché non tirino e misura di nuovo il valore PWM di soglia dopo il montaggio finale.

Il motore a vibrazione è il modo più economico per aggiungere il senso del tatto ai tuoi progetti, accanto a display e suoni. Ora che conosci il transistor e il diodo del modulo, la regolazione dell'intensità con il PWM, l'impulso di avvio e i pattern aptici, puoi progettare sia avvisi silenziosi sia ausili per persone non vedenti. Nell'app BlueGrays puoi esplorare progetti come il buzzer, il sensore di parcheggio con HC-SR04 e il controllo di potenza in PWM, con schemi passo passo e codice pronto all'uso, e sviluppare le tue idee aggiungendo un motore a vibrazione.

Domande frequenti

Come si collega un motore a vibrazione ad Arduino?

Collega il pin VCC del modulo motore a vibrazione a 5V, GND a GND e IN a un pin PWM come D5. Il transistor del modulo porta la corrente del motore e il diodo protegge Arduino. Se usi un motore nudo devi aggiungere per forza un transistor NPN, una resistenza di base da 1 kΩ e un diodo.

A che tensione funziona un motore a vibrazione?

La maggior parte dei motori a vibrazione ERM a moneta ha una tensione nominale di 3 V e lavora tra circa 2,5 e 3,5 V. I moduli si possono alimentare a 3,3–5 V; a 5 V il motore vibra più forte, ma nell'uso prolungato limitare la potenza con il PWM ne allunga la vita. Sotto circa 2 V il motore non parte.

Quanta corrente assorbe un motore a vibrazione?

Un tipico motore a vibrazione a moneta assorbe 60–90 mA mentre gira e per un attimo 100–120 mA all'avvio. È molte volte la corrente che un pin di Arduino può fornire in sicurezza. Per questo il motore va pilotato tramite un transistor o un modulo già pronto.

Come si regola l'intensità di un motore a vibrazione?

L'intensità si regola con il PWM, cioè con analogWrite(pin, 0–255) su Arduino; più alto è il valore, più velocemente gira il motore e più forte vibra. Poiché il motore non parte sotto una certa soglia, a bassa potenza conviene dare prima 20–30 ms al massimo e poi scendere al valore voluto. Sull'ESP32 lo fa ledcWrite(), sul Pico duty_u16().

Che differenza c'è tra motore a vibrazione ERM e LRA?

Il motore ERM vibra facendo girare una massa sbilanciata sul suo albero e funziona in corrente continua. L'LRA muove avanti e indietro un magnete su una molla, funziona solo con un segnale alternato alla sua frequenza di risonanza e risponde in modo più netto e veloce. Per pilotare un LRA serve un driver aptico come il DRV2605.

Perché un motore a vibrazione ha bisogno di un diodo?

Poiché il motore contiene una bobina, quando la corrente viene interrotta ai suoi capi compare un forte picco di tensione inversa. Un diodo in antiparallelo al motore cortocircuita quel picco ed evita danni al transistor e al microcontrollore. I moduli già pronti hanno questo diodo sulla scheda.

Vedi tutti i progetti
Uso del cicalino
AR-13Principiante

Uso del cicalino

Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

4.7(92)
170
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

HC-SR04 Misura della distanza (display seriale)

Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

4.6(50)
82
Accendere un LED con un pulsante (Push)
AR-9Principiante

Accendere un LED con un pulsante (Push)

Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

4.8(114)
253
Sensore di parcheggio con HC-SR04
AR-28Intermedio
Premium

Sensore di parcheggio con HC-SR04

Una versione in miniatura del sensore di parcheggio delle auto: più qualcosa si avvicina, più i bip accelerano.

4.8(64)
86
Dissolvenza LED ESP32 con PWM
ES-8Principiante

Dissolvenza LED ESP32 con PWM

Modificare la luminosità del LED in modo fluido da 0 a max, da max a 0. Controlliamo il PWM con analogWrite() come in Arduino - la stessa sintassi con ESP32 Arduino Core 3.0+ funziona senza problemi. La definizione del pin + pinMode + analogWrite è sufficiente.

4.8(36)
55
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)

In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

4.5(19)
32
Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)
ES-38Avanzato
Premium

Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)

La versione ESP32 di un sensore di parcheggio! Il sensore a ultrasuoni HC-SR04 misura la distanza dall'oggetto davanti. Più si avvicina, più si riempie una barra di 5 LED (verde → giallo → rosso) e più il buzzer suona rapido. Molto vicino (sotto i 10 cm) parte un allarme continuo e si accendono tutti i LED. Il display OLED SSD1306 mostra i cm in tempo reale a caratteri grandi, insieme a un messaggio di stato.

14
Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
PI-14Principiante

Raspberry Pi Pico PWM LED Fade (Effetto Respiro)

Il LED non lampeggia più — respira! Con il PWM (modulazione di larghezza d'impulso) del Raspberry Pi Pico, la luminosità sale e scende lentamente. Impara la classe machine.PWM, duty_u16() (luminosità a 16 bit 0–65535), la frequenza PWM, i cicli range() e l'uscita quasi analogica. Base per miscelazione colori RGB, controllo motori, servo e buzzer.

4