Componentes · 14 min de lectura

Motor vibrador Arduino: módulo, PWM y patrones hápticos

Motor vibrador Arduino: módulo ERM tipo moneda, transistor y diodo, intensidad por PWM, patrones hápticos, bastón inteligente, código ESP32 y Pico, DRV2605.

En los proyectos con motor vibrador y Arduino, un pequeño motor es la forma más sencilla de avisar al usuario sin sonido ni luz. Los móviles en silencio, los relojes inteligentes que te dan toques en la muñeca y los mandos de consola que tiemblan usan estos diminutos motores. El tipo más usado en electrónica de aficionado es el motor ERM tipo moneda, de 10 mm de diámetro y solo 2–3 mm de grosor. Un motor suelto no se puede conectar directamente a un pin de Arduino, pero un módulo de motor vibrador ya montado, con transistor y diodo, funciona con solo tres cables.

En esta guía aprenderás cómo vibra un motor ERM, por qué hacen falta el transistor y el diodo del módulo y cuánta corriente consume el motor. Después ajustaremos la vibración por pasos con PWM y veremos por qué el motor no llega a girar con poca potencia y cómo lo soluciona un "impulso de arranque". Escribiremos código que reproduce patrones hápticos como un toque corto, un doble toque, un latido o SOS sin usar delay(), y montaremos la lógica de un bastón inteligente que vibra según la distancia. En las últimas secciones hay un ejemplo que da respuesta vibratoria al tocar el pin táctil del ESP32, código MicroPython para la Raspberry Pi Pico y el driver DRV2605 para efectos hápticos avanzados.

Módulo de motor vibrador
Módulo de motor vibrador: motor ERM tipo moneda, transistor de control y diodo de protección en una sola placa.

¿Qué es un motor vibrador y cómo funciona?

ERM viene del inglés "Eccentric Rotating Mass", es decir, masa giratoria excéntrica. El eje del motor lleva una pequeña masa cuyo centro de gravedad no está justo en el centro. Al girar el motor, esa masa desequilibrada tira de él hacia un lado en cada vuelta, y ese tirón es lo que sientes como vibración. En los motores tipo moneda la masa gira dentro de la carcasa plana y por fuera no se mueve nada, por eso es muy fácil pegarlos y usarlos. Los motores ERM cilíndricos llevan un contrapeso metálico en forma de media luna por fuera y vibran con más fuerza. Tanto la intensidad como la frecuencia de la vibración dependen de la velocidad del motor: al subir la tensión el motor gira más rápido y la vibración se vuelve más fuerte y más aguda. El LRA (actuador lineal resonante), cada vez más usado en móviles y mandos, funciona de otra forma: mueve un imán sobre un muelle adelante y atrás y solo funciona bien con una señal alterna a su propia frecuencia de resonancia, no con corriente continua. Los módulos de los kits de Arduino son casi siempre ERM.

CaracterísticaMotor ERM tipo moneda típico (p. ej. 1027)
Tamaño10 mm de diámetro, 2,7 mm de grosor
Tensión nominal3 V (aprox. 2,5–3,5 V)
Corriente de trabajoUnos 60–90 mA a 3 V
Corriente de arranqueBrevemente 100–120 mA
VelocidadUnas 10 000–13 000 rpm
Frecuencia de vibraciónUnos 160–220 Hz
Tensión mínima de arranqueUnos 2–2,3 V; por debajo el motor no arranca

¿Qué lleva dentro un módulo de motor vibrador?

Un pin del Arduino Uno da como máximo 40 mA, y el límite seguro ronda los 20 mA. Los pines del ESP32 y de la Pico son todavía más débiles. Un motor vibrador, en cambio, consume 60–120 mA y se comporta como una bobina: en el instante en que se corta su corriente aparece entre sus terminales un pico de tensión inversa elevado. Por eso conectar el motor directamente a un pin fuerza el pin y puede reiniciar o incluso dañar el microcontrolador. Un módulo ya montado resuelve el problema con tres piezas:

  • Transistor de control: Normalmente un S8050 u otro NPN pequeño parecido; algunos módulos llevan un MOSFET de canal N. El pin de Arduino solo aporta unos pocos miliamperios de control y la corriente del motor pasa por el transistor. Explicamos cómo funciona un transistor como interruptor en ¿Qué es un transistor?.
  • Resistencia de base: Limita la corriente del pin al transistor; un valor de unos 1 kΩ funciona tanto con placas de 5 V como de 3,3 V.
  • Diodo de rueda libre (flyback): Conectado en antiparalelo con el motor, cortocircuita el pico de tensión que se produce al apagarlo y protege el transistor. Tienes su función explicada en ¿Qué es un diodo?.

La mayoría de los módulos tienen tres pines: VCC, GND y el pin de señal IN (S o SIG en algunas placas). Al poner IN en HIGH, el transistor conduce y el motor gira. El módulo funciona con 3,3–5 V. Alimentado a 5 V, el motor recibe unos 4,5 V tras la pequeña caída del transistor, más de lo que marca un motor de 3 V. Para avisos cortos no pasa nada, pero si el motor va a funcionar mucho rato seguido, limitar la potencia con PWM a un 60–70 por ciento alarga su vida.

Conexión: Arduino Uno, ESP32 y Raspberry Pi Pico

La tabla de abajo recoge los pines que usan todos los programas de este artículo. En cada placa, el pin del motor debe poder dar PWM. En el ESP32 y la Pico, la señal de 3,3 V en el pin IN basta para activar el transistor; el pin VCC del módulo puedes conectarlo a 5 V para una vibración más fuerte o a 3,3 V para una más suave. Elijas la alimentación que elijas, las masas (GND) deben ser comunes.

ConexiónArduino UnoESP32Raspberry Pi Pico
VCC del módulo5VVIN (5 V) o 3V3VBUS (5 V) o 3V3(OUT)
GND del móduloGNDGNDGND
IN del móduloD5 (PWM)GPIO 25GP15
Pulsador (la otra pata a GND)D2Pin táctil GPIO 4 (T0)GP14
HC-SR04 TRIG (ejemplo del bastón)D9--
HC-SR04 ECHO (ejemplo del bastón)D10--
Si usas un motor suelto sin módulo, no lo conectes nunca directamente a un pin. Une un terminal del motor a 5 V y el otro al colector de un transistor NPN (2N2222, BC337 o S8050); el emisor a GND y la base al pin de Arduino a través de una resistencia de 1 kΩ. Pon un diodo 1N4148 o 1N5819 entre los terminales del motor, con el cátodo (lado de la franja) hacia los 5 V. Si olvidas el diodo, el transistor puede estropearse pronto y el Arduino reiniciarse al azar. Puedes comprobar la resistencia de base con la herramienta Ley de Ohm y los valores de corriente y ganancia del transistor con la herramienta Transistores.

Primer programa: encendido, apagado e intensidad con PWM

Puedes pensar en el módulo de motor vibrador como en un LED: digitalWrite(HIGH) hace girar el motor a plena potencia y analogWrite() ajusta con PWM la tensión media y, por tanto, la intensidad de la vibración. En el Arduino Uno los pines D5 y D6 trabajan a unos 980 Hz y el resto de pines PWM a unos 490 Hz. Explicamos las bases del PWM en ¿Qué es PWM?. Los motores ERM tienen una característica importante: poner en marcha un motor parado exige más potencia que mantener uno que ya gira. Por eso un motor arrancado con un valor PWM bajo puede no moverse en absoluto. La solución es arrancar el motor unas decenas de milisegundos a plena potencia y bajar después al valor deseado; esto se llama impulso de arranque (kick-start). El programa de abajo da primero una vibración corta a plena potencia, después sube la intensidad por pasos y muestra cada paso en el Monitor Serie.

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}

Al ejecutarlo verás que, por debajo de cierto valor PWM, el motor no vibra o vibra muy poco. Con 5 V de alimentación este umbral suele estar entre 70 y 110; el valor exacto depende del motor y del módulo. Apunta en el Monitor Serie el valor en el que notas el motor con claridad por primera vez y úsalo como potencia mínima en tu proyecto. Gracias al impulso de arranque, valores algo por debajo del umbral también pueden funcionar, porque un motor que ya gira sigue girando con menos potencia.

Valor PWM (alimentación de 5 V)Tensión mediaVibración que se nota
0–600–1,2 VNinguna, el motor no gira
70–1101,4–2,2 VZona umbral; puede necesitar impulso de arranque
120–1702,4–3,3 VVibración suave o media, ideal para avisos largos
180–2553,5–4,5 VVibración fuerte, para avisos cortos y llamativos

Patrones hápticos: toque corto, doble toque, latido y SOS

Una vibración siempre igual solo dice "ha pasado algo". Los patrones distintos dicen además qué ha pasado: un toque corto puede ser una confirmación, dos toques cortos un aviso, una vibración larga una alarma y un ritmo parecido a un latido un recordatorio. La mano humana apenas nota vibraciones de menos de 20–30 ms, y un motor ERM necesita unos 30–50 ms para coger velocidad. Así que deja la vibración más corta de un patrón en 40–60 ms y la pausa entre dos vibraciones en 80–100 ms como mínimo. En el programa de abajo cada patrón es un array de pares {potencia, duración}. El reproductor de patrones funciona con millis(), así que loop() puede hacer otras cosas mientras suena un patrón. Cada pulsación del botón de D2 reproduce el patrón siguiente.

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}

Para cambiar los patrones solo tienes que editar los arrays; la función reproductora no cambia. En el patrón SOS las vibraciones cortas duran 100 ms, las largas 350 ms y la pausa entre letras 300 ms; estas proporciones siguen el esquema de "punto, raya" del código Morse. Haz que los patrones se distingan bien para que nadie los confunda: con número distinto de vibraciones (una, dos, tres) o con duraciones claramente diferentes. Antes de usarlos en un proyecto, pruébalos con varias personas y pídeles que adivinen qué significa cada uno; en diseño háptico es la mejor prueba.

Avisos vestibles y bastón inteligente

El motor vibrador destaca allí donde el sonido molesta o no se oye. En los proyectos vestibles, coloca el motor dentro de una pulsera, un guante o un cinturón, cerca de la piel. La cara interna de la muñeca, la palma y las yemas de los dedos son las zonas más sensibles a la vibración. Pegar el motor a una superficie dura, por ejemplo a la pared interior de una caja impresa en 3D con cinta de doble cara, transmite mejor la vibración que coserlo suelto a la tela. En los bastones inteligentes para personas con discapacidad visual, el motor va en la parte del mango que queda justo bajo el pulgar, y la distancia al obstáculo se traduce en la frecuencia y la intensidad de la vibración: cuanto más cerca está el obstáculo, más seguidas y fuertes son las vibraciones, hasta volverse continuas cuando está muy cerca. El programa de abajo muestra esta lógica con un sensor de distancia 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}

Para que sea sencillo, este programa usa delay() y no mide mientras espera; en un bastón de verdad responde mejor una estructura basada en millis() como la de la sección anterior. Mantenemos la potencia mínima en 150 para que, con obstáculos lejanos, el motor no se quede por debajo de su umbral sin girar. Para un proyecto completo con aviso de charcos, detección de caídas, SOS y cálculo de batería, mira el proyecto de bastón inteligente con Arduino, y para los detalles del sensor la guía del sensor de distancia HC-SR04.

Corriente, alimentación y duración de la batería

Un motor tipo moneda consume 60–90 mA en marcha y, al arrancar, algo más de 100 mA durante un instante. El pin 5V del Arduino Uno da eso sin problema desde el USB. Los problemas suelen aparecer en circuitos con batería cuya tensión ya va justa, o en proyectos con varios motores funcionando a la vez: al arrancar el motor la tensión cae un momento y la placa se reinicia. Para evitarlo, pon un condensador electrolítico de 47–100 µF entre VCC y GND del módulo y, si usas varios motores, arráncalos con unos milisegundos de diferencia y no a la vez. Al calcular la batería, ten en cuenta que el motor funciona a ráfagas cortas y no de forma continua: por ejemplo, un motor de 80 mA que funciona 3 segundos en total por minuto tiene una corriente media de solo 4 mA. Con los valores de tu proyecto puedes calcular cuántas horas durará en la herramienta Duración de la batería.

Respuesta táctil con el ESP32

Dos ventajas del ESP32 encajan muy bien con un motor vibrador: el chip tiene pines táctiles capacitivos y la unidad LEDC, que genera el PWM, permite elegir la frecuencia libremente. El programa de abajo da un "clic" corto, como la pantalla de un móvil, al tocar un cable o un trozo de lámina de cobre conectado al GPIO 4 (T0); si el toque dura más de 1 segundo, lo confirma con una vibración larga. Hemos puesto la frecuencia PWM en 20 kHz, en el límite del oído humano, para que desaparezca también cualquier zumbido fino del driver del motor. El código compila con las versiones 2.x y 3.x del núcleo Arduino del ESP32, porque los nombres de las funciones LEDC cambian entre ambas.

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}

En el ESP32, el valor del pin táctil suele rondar 50–80 sin tocar y baja claramente al tocarlo con el dedo; por eso el código mide la media al arrancar y calcula el umbral solo. En el ESP32-S2 y el S3, en cambio, los valores táctiles suben al tocar; en esas placas tienes que invertir la comparación. Si conectas el VCC del módulo al pin VIN del ESP32, el motor vibra con más fuerza a 5 V; la señal de 3,3 V del pin IN basta para el transistor. Combinándolo con WiFi o Bluetooth puedes hacer una pulsera que vibre al llegarte una notificación al móvil o un dispositivo de aviso controlado por BLE del ESP32.

Motor vibrador con la Raspberry Pi Pico y MicroPython

En la Raspberry Pi Pico cualquier pin GPIO puede generar PWM. En MicroPython, la función duty_u16() de la clase PWM recibe un valor entre 0 y 65535; 65535 es plena potencia. El código de abajo reproduce un patrón de latido cada vez que se pulsa el botón de GP14. Igual que en el ejemplo de Arduino, el patrón es una lista de pares de potencia y duración. Puedes conectar el VCC del módulo a VBUS (los 5 V del USB) para una vibración más fuerte o a 3V3(OUT) para una más suave.

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)

Los pines de la Pico trabajan a 3,3 V y no se recomienda sacar más de unos 12 mA de un solo pin, así que con la Pico también debes usar el módulo con transistor y no un motor suelto. Mientras suena un patrón no se lee el botón; si necesitas hacer varias cosas a la vez, puedes montar el esquema de millis() de Arduino con time.ticks_ms() o avanzar los pasos del patrón con una interrupción de Timer. Si estás empezando con MicroPython, el artículo fundamentos de MicroPython es un buen punto de partida.

Driver háptico DRV2605: efectos de vibración profesionales

Un módulo con transistor solo enciende y apaga el motor o lo hace más fuerte o más débil con PWM. El "clic" nítido que notas en un móvil se consigue arrancando y parando el motor muy deprisa: primero se acelera con un impulso por encima de su tensión nominal (overdrive) y, cuando acaba la vibración, se frena con una breve tensión inversa. El chip DRV2605L de Texas Instruments hace esto por sí solo. Se conecta por I2C (dirección 0x5A), puede manejar motores ERM y LRA e incluye 123 efectos de serie, como clics, dobles clics, zumbidos y golpes suaves. Aprende las características del motor con una autocalibración y puede convertir una entrada de audio en vibración. Con la librería Adafruit DRV2605 se usa en pocas líneas; en el Uno conectas SDA a A4 y SCL a A5, y el motor va directamente a la salida de motor de la placa 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}

El DRV2605 puede reproducir hasta 8 efectos seguidos en una secuencia; rellenas los huecos 0 a 7 con setWaveform() y marcas el final de la secuencia con 0. Si usas un motor LRA, llama a useLRA() y elige la librería LRA número 6. Para avisos sencillos, un módulo con transistor es más que suficiente; si diseñas un producto vestible, un mando de juego o una interfaz táctil, el DRV2605 mejora claramente la sensación.

Ideas de proyectos con motor vibrador

  • Pulsera temporizador silenciosa: Haz un temporizador pomodoro que vibre en tu muñeca al acabar el tiempo de estudio o de clase, sin molestar a nadie.
  • Bastón inteligente para personas ciegas: Sigue la guía del bastón inteligente para un proyecto completo que convierte la distancia al obstáculo en un ritmo de vibración.
  • Timbre silencioso: Haz que un aparato en tu bolsillo vibre cuando un sensor de movimiento PIR en la puerta detecte a alguien.
  • Mando de juego: Añade vibración en los choques a un mando hecho con un módulo joystick.
  • Avisador de postura: Mide la inclinación de tu espalda con un MPU6050 y avisa con una vibración corta cuando pases mucho rato encorvado.
  • Vibración en lugar de sonido: En un despertador nocturno, pon un motor vibrador bajo la almohada en lugar de un zumbador.

Errores frecuentes y soluciones

SíntomaCausa probableSolución
El motor no gira nadaValor PWM por debajo del umbral de arranque o GND no comúnPrueba primero con 255, añade el impulso de arranque y une las masas
El Arduino se reinicia cuando funciona el motorLa corriente de arranque hunde la alimentación o falta el diodoUsa un módulo montado y pon 47–100 µF entre VCC y GND
La vibración es muy débilEl módulo va a 3,3 V o el motor está sobre una superficie blandaConecta VCC a 5 V y pega el motor a una superficie dura
El motor se calientaFunciona mucho tiempo a plena potencia con 5 VLimita la potencia al 60–70 % con PWM y usa pulsos cortos en vez de vibración continua
El motor emite un zumbido finoLa frecuencia PWM está en el rango audibleEn el ESP32 pon la frecuencia LEDC a 20 kHz; en el Uno usa vibraciones cortas
Error de ledcSetup no encontrado en el ESP32Núcleo ESP32 versión 3.xUsa la separación #if ESP_ARDUINO_VERSION_MAJOR de este artículo
Un pin dejó de funcionar tras conectar un motor sueltoEl motor iba directo al pin y lo dañóUsa otro pin y controla siempre el motor con transistor y diodo
Los patrones se notan igualesVibraciones demasiado cortas o pausas demasiado brevesDeja la vibración más corta en 40–60 ms y la pausa en 100 ms como mínimo
Prueba la vibración donde se va a usar de verdad, no sobre la mesa. Un motor apoyado en la mesa hace vibrar la madera y parece más fuerte de lo que es; dentro de una pulsera o del mango de un bastón, el mismo motor puede notarse mucho más flojo. Sujeta bien el motor a una superficie dura, fija los cables para que no queden tirantes y vuelve a medir el valor PWM umbral después del montaje final.

El motor vibrador es la forma más barata de sumar el sentido del tacto a tus proyectos, junto a pantallas y sonidos. Ahora que conoces el transistor y el diodo del módulo, el ajuste de intensidad con PWM, el impulso de arranque y los patrones hápticos, puedes diseñar tanto avisos silenciosos como ayudas para personas con discapacidad visual. En la app BlueGrays puedes explorar proyectos como el zumbador, el sensor de aparcamiento con HC-SR04 y el control de potencia con PWM, con esquemas paso a paso y código listo para usar, y llevar tus propias ideas más lejos añadiéndoles un motor vibrador.

Preguntas frecuentes

¿Cómo se conecta un motor vibrador a Arduino?

Conecta el pin VCC del módulo de motor vibrador a 5V, GND a GND e IN a un pin PWM como D5. El transistor del módulo lleva la corriente del motor y el diodo protege al Arduino. Si usas un motor suelto, tienes que añadir un transistor NPN, una resistencia de base de 1 kΩ y un diodo.

¿A qué tensión funciona un motor vibrador?

La mayoría de los motores vibradores ERM tipo moneda tienen una tensión nominal de 3 V y funcionan entre unos 2,5 y 3,5 V. Los módulos se pueden alimentar con 3,3–5 V; a 5 V el motor vibra con más fuerza, pero en uso prolongado limitar la potencia con PWM alarga su vida. Por debajo de unos 2 V el motor no arranca.

¿Cuánta corriente consume un motor vibrador?

Un motor vibrador tipo moneda típico consume 60–90 mA en marcha y 100–120 mA durante un instante al arrancar. Eso es varias veces lo que un pin de Arduino puede dar con seguridad. Por eso el motor debe controlarse a través de un transistor o de un módulo ya montado.

¿Cómo se regula la intensidad de un motor vibrador?

La intensidad se regula con PWM, es decir, con analogWrite(pin, 0–255) en Arduino; cuanto mayor el valor, más rápido gira el motor y más fuerte vibra. Como el motor no arranca por debajo de cierto umbral, con poca potencia funciona bien dar primero 20–30 ms a tope y bajar luego al valor deseado. En el ESP32 lo hace ledcWrite() y en la Pico duty_u16().

¿Qué diferencia hay entre un motor vibrador ERM y uno LRA?

El ERM vibra haciendo girar una masa desequilibrada en su eje y funciona con corriente continua. El LRA mueve un imán sobre un muelle adelante y atrás, solo funciona con una señal alterna a su frecuencia de resonancia y responde de forma más nítida y rápida. Para manejar un LRA hace falta un driver háptico como el DRV2605.

¿Por qué un motor vibrador necesita un diodo?

Como el motor tiene una bobina, en el instante en que se corta su corriente aparece un pico de tensión inversa elevado entre sus terminales. Un diodo en antiparalelo con el motor cortocircuita ese pico y evita que se dañen el transistor y el microcontrolador. Los módulos ya montados llevan este diodo en la placa.

Ver todos los proyectos
Uso del zumbador
AR-13Principiante

Uso del zumbador

¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

4.7(92)
170
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

HC-SR04 Medición de distancia (pantalla en serie)

El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

4.6(50)
82
Encender un LED con pulsador (Push)
AR-9Principiante

Encender un LED con pulsador (Push)

Como un timbre: la luz se enciende mientras pulsas y se apaga cuando sueltas. El Arduino escucha el botón todo el rato; mientras está pulsado enciende el LED, y en cuanto levantas el dedo lo apaga.

4.8(114)
253
Sensor de aparcamiento con HC-SR04
AR-28Intermedio
Premium

Sensor de aparcamiento con HC-SR04

Una versión en miniatura del sensor de aparcamiento de los coches: cuanto más se acerca algo, más rápidos son los pitidos.

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

ESP32 LED Fade con PWM

Cambiar el brillo del LED suavemente de 0 a max, de max a 0. Controlamos PWM con analogWrite() como en Arduino - la misma sintaxis con ESP32 Arduino Core 3.0+ funciona sin problemas. Pin definición + pinMode + analogWrite es suficiente.

4.8(36)
55
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)

En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

4.5(19)
32
Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)
ES-38Avanzado
Premium

Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)

¡La versión ESP32 de un sensor de aparcamiento! El sensor ultrasónico HC-SR04 mide la distancia al objeto que tiene delante. Cuanto más cerca está, más se llena una barra de 5 LED (verde → amarillo → rojo) y más rápido pita el zumbador. Muy cerca (por debajo de 10 cm) suena una alarma continua y se encienden todos los LED. La OLED SSD1306 muestra los cm en tiempo real con letra grande y un texto de estado.

14
Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
PI-14Principiante

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)

¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.

4