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.

¿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ística | Motor ERM tipo moneda típico (p. ej. 1027) |
|---|---|
| Tamaño | 10 mm de diámetro, 2,7 mm de grosor |
| Tensión nominal | 3 V (aprox. 2,5–3,5 V) |
| Corriente de trabajo | Unos 60–90 mA a 3 V |
| Corriente de arranque | Brevemente 100–120 mA |
| Velocidad | Unas 10 000–13 000 rpm |
| Frecuencia de vibración | Unos 160–220 Hz |
| Tensión mínima de arranque | Unos 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ón | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC del módulo | 5V | VIN (5 V) o 3V3 | VBUS (5 V) o 3V3(OUT) |
| GND del módulo | GND | GND | GND |
| IN del módulo | D5 (PWM) | GPIO 25 | GP15 |
| Pulsador (la otra pata a GND) | D2 | Pin táctil GPIO 4 (T0) | GP14 |
| HC-SR04 TRIG (ejemplo del bastón) | D9 | - | - |
| HC-SR04 ECHO (ejemplo del bastón) | D10 | - | - |
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.
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 media | Vibración que se nota |
|---|---|---|
| 0–60 | 0–1,2 V | Ninguna, el motor no gira |
| 70–110 | 1,4–2,2 V | Zona umbral; puede necesitar impulso de arranque |
| 120–170 | 2,4–3,3 V | Vibración suave o media, ideal para avisos largos |
| 180–255 | 3,5–4,5 V | Vibració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.
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.
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.
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.
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.
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íntoma | Causa probable | Solución |
|---|---|---|
| El motor no gira nada | Valor PWM por debajo del umbral de arranque o GND no común | Prueba primero con 255, añade el impulso de arranque y une las masas |
| El Arduino se reinicia cuando funciona el motor | La corriente de arranque hunde la alimentación o falta el diodo | Usa un módulo montado y pon 47–100 µF entre VCC y GND |
| La vibración es muy débil | El módulo va a 3,3 V o el motor está sobre una superficie blanda | Conecta VCC a 5 V y pega el motor a una superficie dura |
| El motor se calienta | Funciona mucho tiempo a plena potencia con 5 V | Limita la potencia al 60–70 % con PWM y usa pulsos cortos en vez de vibración continua |
| El motor emite un zumbido fino | La frecuencia PWM está en el rango audible | En el ESP32 pon la frecuencia LEDC a 20 kHz; en el Uno usa vibraciones cortas |
| Error de ledcSetup no encontrado en el ESP32 | Núcleo ESP32 versión 3.x | Usa la separación #if ESP_ARDUINO_VERSION_MAJOR de este artículo |
| Un pin dejó de funcionar tras conectar un motor suelto | El motor iba directo al pin y lo dañó | Usa otro pin y controla siempre el motor con transistor y diodo |
| Los patrones se notan iguales | Vibraciones demasiado cortas o pausas demasiado breves | Deja la vibración más corta en 40–60 ms y la pausa en 100 ms como mínimo |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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.

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.

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.

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.

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

