Motor de vibração com Arduino: ligação do módulo, PWM e padrões táteis
Guia de motor de vibração com Arduino: módulo ERM tipo moeda, transistor e diodo, intensidade com PWM, padrões táteis, bengala inteligente, código para ESP32 e Pico e uma nota sobre o DRV2605.
Em projetos de motor de vibração com Arduino, um pequeno motor é a maneira mais fácil de informar o usuário sem som nem luz. Celulares que vibram no silencioso, relógios inteligentes que dão pequenos toques no pulso e controles de videogame que tremem dependem desses minúsculos motores. O tipo mais usado na eletrônica de hobby é o motor de vibração ERM tipo moeda, com 10 mm de diâmetro e apenas 2–3 mm de espessura. Um motor avulso não pode ser conectado diretamente a um pino do Arduino, mas um módulo de motor de vibração pronto, com transistor e diodo na placa, permite acioná-lo com apenas três fios.
Neste guia, você vai aprender como um motor ERM vibra, por que o transistor e o diodo dentro do módulo são necessários e quanta corrente o motor consome. Depois, vamos ajustar a vibração passo a passo com PWM e entender por que o motor não gira em baixa potência e como um “pulso de partida” resolve isso. Vamos escrever código que reproduz padrões táteis, como toque curto, toque duplo, batimento cardíaco e SOS, sem usar delay(), e montar a lógica de uma bengala inteligente que vibra conforme a distância. Nas últimas seções, você encontra um exemplo que dá retorno tátil ao tocar no pino sensível ao toque do ESP32, código MicroPython para o Raspberry Pi Pico e o driver DRV2605 para efeitos táteis avançados.

O que é um motor de vibração e como funciona?
ERM significa “Eccentric Rotating Mass” (massa rotativa excêntrica). O eixo do motor carrega uma pequena massa cujo centro de gravidade não fica exatamente no meio. À medida que o motor gira, essa massa desequilibrada puxa o motor em uma direção a cada volta, e você sente essa força como vibração. Nos motores tipo moeda, a massa gira dentro da carcaça achatada e nada se move do lado de fora, o que facilita muito colá-los no lugar e usá-los. Os motores ERM cilíndricos têm um peso metálico em forma de meia-lua do lado de fora e vibram com mais força. Tanto a intensidade quanto a frequência da vibração dependem da velocidade do motor: quando a tensão aumenta, o motor acelera e a vibração fica mais forte e mais aguda. O LRA (atuador ressonante linear), cada vez mais usado em celulares e controles de videogame, funciona de outra forma: move um ímã preso a uma mola para frente e para trás e só funciona corretamente com um sinal alternado na sua própria frequência de ressonância, não com tensão CC contínua. Os módulos encontrados nos kits Arduino são quase sempre ERM.
| Característica | Motor ERM tipo moeda típico (ex.: 1027) |
|---|---|
| Dimensões | 10 mm de diâmetro, 2,7 mm de espessura |
| Tensão nominal | 3 V (cerca de 2,5–3,5 V) |
| Corrente em funcionamento | Cerca de 60–90 mA a 3 V |
| Corrente de partida | 100–120 mA por um breve instante |
| Velocidade | Cerca de 10.000–13.000 rpm |
| Frequência de vibração | Cerca de 160–220 Hz |
| Tensão mínima de partida | Cerca de 2–2,3 V; abaixo disso, o motor não parte |
O que há dentro de um módulo de motor de vibração?
Um pino do Arduino Uno pode fornecer no máximo 40 mA, e o limite seguro fica em torno de 20 mA. Os pinos do ESP32 e do Pico têm uma capacidade ainda menor. Um motor de vibração consome 60–120 mA e se comporta como uma bobina: no momento em que sua corrente é cortada, surge um pico de tensão reversa elevado nos terminais. Por isso, conectar o motor diretamente a um pino sobrecarrega esse pino e pode reiniciar ou até danificar o microcontrolador. Um módulo pronto resolve o problema com três componentes:
- Transistor de acionamento: Geralmente um S8050 ou um pequeno transistor NPN semelhante; em alguns módulos, um MOSFET de canal N. O pino do Arduino fornece apenas alguns miliampères de corrente de controle, e a corrente do motor passa pelo transistor. Explicamos como um transistor funciona como chave em O que é um transistor?.
- Resistor de base: Limita a corrente do pino para o transistor; um valor em torno de 1 kΩ funciona tanto com placas de 5 V quanto de 3,3 V.
- Diodo de roda livre: Conectado em paralelo com o motor, com polaridade invertida, esse diodo curto-circuita o pico de tensão produzido quando o motor é desligado e protege o transistor. Você pode ler sobre sua função em O que é um diodo?.
A maioria dos módulos tem três pinos: VCC, GND e o pino de sinal IN (S ou SIG em algumas placas). Quando você coloca IN em HIGH, o transistor conduz e o motor gira. O módulo em si funciona com 3,3–5 V. Alimentado com 5 V, o motor recebe cerca de 4,5 V após a pequena queda no transistor, o que fica acima da tensão nominal de um motor de 3 V. Isso é aceitável para alertas curtos, mas, se o motor funcionar continuamente por muito tempo, limitar a potência a cerca de 60–70 por cento com PWM prolonga sua vida útil.
Ligações: Arduino Uno, ESP32 e Raspberry Pi Pico
A tabela abaixo lista os pinos usados em todos os sketches deste artigo. Em todas as placas, o pino do motor precisa ser capaz de gerar PWM. No ESP32 e no Pico, o sinal de 3,3 V enviado ao pino IN é suficiente para acionar o transistor; você pode conectar o pino VCC do módulo a 5 V para uma vibração mais forte ou a 3,3 V para uma vibração mais suave. Seja qual for a alimentação escolhida, os terras precisam estar conectados entre si.
| Conexão | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC do módulo | 5V | VIN (5 V) ou 3V3 | VBUS (5 V) ou 3V3(OUT) |
| GND do módulo | GND | GND | GND |
| IN do módulo | D5 (PWM) | GPIO 25 | GP15 |
| Botão (outro terminal no GND) | D2 | Pino sensível ao toque GPIO 4 (T0) | GP14 |
| TRIG do HC-SR04 (exemplo da bengala) | D9 | - | - |
| ECHO do HC-SR04 (exemplo da bengala) | D10 | - | - |
Primeiro sketch: ligar/desligar e ajustar a intensidade da vibração com PWM
Você pode pensar no módulo de motor de vibração como um LED: digitalWrite(HIGH) faz o motor funcionar com potência máxima, enquanto analogWrite() usa PWM para ajustar a tensão média e, portanto, a intensidade da vibração. No Arduino Uno, os pinos D5 e D6 funcionam a cerca de 980 Hz e os outros pinos PWM a cerca de 490 Hz. Abordamos os fundamentos do PWM em detalhes em O que é PWM?. Os motores ERM têm uma característica importante: fazer um motor parado começar a girar exige mais potência do que manter um motor já em movimento. Por isso, um motor acionado com um valor baixo de PWM pode nem se mover. A solução é ligar o motor com potência máxima por algumas dezenas de milissegundos e depois reduzir para o valor desejado; isso se chama pulso de partida. O sketch abaixo primeiro produz uma vibração curta com potência máxima, depois aumenta a intensidade gradualmente e exibe cada etapa no Monitor Serial.
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}Ao executar o código, você vai perceber que o motor não vibra ou vibra muito pouco abaixo de um determinado valor de PWM. Com alimentação de 5 V, esse limite geralmente fica entre 70 e 110; o valor exato depende do motor e do módulo. Anote o valor no Monitor Serial em que você começa a sentir claramente o motor e use-o como potência mínima no seu projeto. Graças ao pulso de partida, valores um pouco abaixo desse limite também podem funcionar, porque, depois que o motor começa a girar, ele continua com menos potência.
| Valor de PWM (alimentação de 5 V) | Tensão média | Vibração percebida |
|---|---|---|
| 0–60 | 0–1,2 V | Nenhuma, o motor não gira |
| 70–110 | 1,4–2,2 V | Zona do limite; pode precisar de um pulso de partida |
| 120–170 | 2,4–3,3 V | Vibração leve a média, ideal para alertas longos |
| 180–255 | 3,5–4,5 V | Vibração forte, para alertas curtos que chamam a atenção |
Padrões táteis: toque curto, toque duplo, batimento cardíaco e SOS
Um único tipo de vibração só informa que “algo aconteceu”. Padrões diferentes também dizem ao usuário o que aconteceu: um toque curto pode indicar confirmação, dois toques curtos um aviso, uma vibração longa um alarme e um ritmo de batimento cardíaco um lembrete. A mão humana mal percebe vibrações menores que 20–30 ms, e um motor ERM precisa de cerca de 30–50 ms para ganhar velocidade. Por isso, mantenha a vibração mais curta de um padrão em 40–60 ms e o intervalo entre duas vibrações em pelo menos 80–100 ms. No sketch abaixo, cada padrão é um array de pares {power, duration}. O reprodutor de padrões funciona com millis(), então loop() pode fazer outras tarefas enquanto um padrão está sendo reproduzido. Cada pressionamento do botão em D2 reproduz o próximo padrão.
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 mudar os padrões, basta editar os arrays; a função de reprodução continua a mesma. No padrão SOS, as vibrações curtas duram 100 ms, as longas 350 ms e o intervalo entre letras 300 ms; essas proporções seguem a estrutura de “ponto e traço” do código Morse. Mantenha os padrões claramente distintos para que os usuários não os confundam: use quantidades diferentes (uma, duas, três vibrações) ou durações bem diferentes. Antes de adicionar padrões a um projeto, teste-os com algumas pessoas e peça que adivinhem o significado de cada padrão; no design tátil, esse é o melhor teste.
Alertas vestíveis e a bengala inteligente
Um motor de vibração se destaca onde o som incomoda ou não pode ser ouvido. Em projetos vestíveis, coloque o motor dentro de uma pulseira, luva ou cinto, perto da pele. A parte interna do pulso, a palma da mão e as pontas dos dedos são as áreas mais sensíveis à vibração. Colar o motor em uma superfície rígida, por exemplo na parede interna de uma caixa impressa em 3D com fita dupla face, transmite a vibração melhor do que costurá-lo frouxamente em um tecido. Em projetos de bengala inteligente para pessoas com deficiência visual, o motor fica na parte da empunhadura logo abaixo do polegar, e a distância até um obstáculo é convertida no ritmo e na intensidade da vibração: conforme o obstáculo se aproxima, as vibrações ficam mais rápidas e fortes, tornando-se contínuas quando ele está muito perto. O sketch abaixo mostra essa lógica com um sensor de distância 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 simplificar, este sketch usa delay() e não faz novas leituras durante a espera; em uma bengala real, uma estrutura baseada em millis(), como a da seção anterior, responde melhor. Mantemos a potência mínima em 150 para que o motor não fique abaixo do seu limite e deixe de girar quando os obstáculos estiverem distantes. Para um projeto completo com aviso de poças, detecção de queda, SOS e cálculos de bateria, veja o projeto de bengala inteligente com Arduino; para detalhes do sensor, consulte o guia do sensor de distância HC-SR04.
Corrente, alimentação e autonomia da bateria
Um motor tipo moeda consome 60–90 mA em funcionamento e, por um breve instante, mais de 100 mA na partida. O pino 5V do Arduino Uno consegue fornecer isso facilmente pela USB. Os problemas geralmente aparecem em circuitos alimentados por bateria cuja tensão já está no limite, ou em projetos com vários motores funcionando ao mesmo tempo: quando o motor parte, a tensão cai por um instante e a placa reinicia. Para evitar isso, adicione um capacitor eletrolítico de 47–100 µF entre os pinos VCC e GND do módulo e, se usar mais de um motor, ligue-os com alguns milissegundos de diferença, em vez de no mesmo instante. Ao calcular a autonomia da bateria, lembre-se de que o motor funciona em pulsos curtos, não continuamente: por exemplo, um motor de 80 mA que funciona por um total de 3 segundos por minuto tem uma corrente média de apenas 4 mA. Use a ferramenta Autonomia da bateria com os valores do seu projeto para descobrir quantas horas ele vai durar.
Retorno tátil com o ESP32
Duas vantagens do ESP32 combinam muito bem com um motor de vibração: o chip tem pinos de toque capacitivo, e a unidade LEDC, que gera PWM, permite ajustar a frequência livremente. O sketch abaixo produz uma vibração curta de “clique”, como a tela de um celular, quando um fio ou pedaço de folha de cobre conectado ao GPIO 4 (T0) é tocado; se o toque durar mais de 1 segundo, ele confirma com uma vibração longa. Ajustamos a frequência PWM para 20 kHz, no limite da audição humana, para que qualquer zumbido agudo e fraco do circuito de acionamento do motor também desapareça. O código compila tanto com a versão 2.x quanto com a 3.x do core Arduino para ESP32, porque os nomes das funções LEDC diferem entre as duas.
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}No ESP32, o valor do pino sensível ao toque geralmente fica em torno de 50–80 sem contato e cai claramente quando um dedo o toca; por isso, o código mede o valor médio na inicialização e calcula o limite automaticamente. No ESP32-S2 e no S3, porém, os valores de toque variam no sentido oposto e aumentam ao tocar; nessas placas, você precisa inverter a comparação. Se conectar o pino VCC do módulo ao pino VIN do ESP32, o motor vibra com mais força a 5 V; o sinal de 3,3 V no pino IN é suficiente para acionar o transistor. Combinando isso com Wi-Fi ou Bluetooth, você pode montar uma pulseira que vibra quando o celular recebe uma notificação ou um dispositivo de alerta controlado por ESP32 BLE.
Motor de vibração com Raspberry Pi Pico e MicroPython
No Raspberry Pi Pico, todos os pinos GPIO podem gerar PWM. No MicroPython, a função duty_u16() da classe PWM recebe um valor entre 0 e 65535; 65535 significa potência máxima. O código abaixo reproduz um padrão de batimento cardíaco sempre que o botão em GP14 é pressionado. Como no exemplo com Arduino, o padrão é uma lista de pares de potência e duração. Você pode conectar o pino VCC do módulo ao VBUS (os 5 V da USB) para uma vibração mais forte ou ao 3V3(OUT) para uma vibração mais 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)Os pinos do Pico funcionam com 3,3 V, e não é recomendado consumir mais de cerca de 12 mA de um único pino; por isso, também no Pico, você deve usar o módulo com transistor, não um motor avulso. O botão não é lido enquanto um padrão é reproduzido; se precisar fazer várias coisas ao mesmo tempo, você pode implementar a estrutura de millis() do Arduino com time.ticks_ms() ou avançar as etapas do padrão com uma interrupção de Timer. Se você está começando com MicroPython, o artigo sobre fundamentos de MicroPython é um bom ponto de partida.
Driver tátil DRV2605: efeitos de vibração profissionais
Um módulo com transistor apenas liga e desliga o motor ou aumenta e diminui sua intensidade com PWM. O “clique” nítido que você sente em um celular vem de iniciar e parar o motor muito rapidamente: primeiro, o motor é acelerado com um pulso acima da sua tensão nominal (overdrive) e, quando a vibração termina, é freado com uma breve tensão reversa. O chip DRV2605L da Texas Instruments faz isso sozinho. Ele se conecta por I2C (endereço 0x5A), pode acionar motores ERM e LRA e contém 123 efeitos integrados, como cliques, cliques duplos, vibrações e impactos suaves. Ele aprende as características do motor por calibração automática e pode transformar uma entrada de áudio em vibração. Com a biblioteca Adafruit DRV2605, bastam poucas linhas; no Uno, você conecta SDA a A4 e SCL a A5, e o motor se conecta diretamente à saída de motor da 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}O DRV2605 pode reproduzir até 8 efeitos seguidos em uma sequência; você preenche as posições de 0 a 7 com setWaveform() e marca o fim da sequência com 0. Se usar um motor LRA, chame useLRA() e selecione a biblioteca LRA número 6. Para alertas simples, um módulo com transistor é mais do que suficiente; se você estiver desenvolvendo um produto vestível, um controle de videogame ou uma interface sensível ao toque, o DRV2605 melhora de forma perceptível a sensação tátil.
Ideias de projetos com um motor de vibração
- Pulseira com temporizador silencioso: Monte um temporizador pomodoro que vibra no seu pulso quando a aula ou o período de estudo termina, sem incomodar a turma.
- Bengala inteligente para pessoas com deficiência visual: Siga o guia de bengala inteligente para um projeto completo que transforma a distância de obstáculos em um ritmo de vibração.
- Campainha silenciosa: Faça um dispositivo no seu bolso vibrar quando um sensor de movimento PIR na porta detectar alguém.
- Controle de videogame: Adicione vibração nas colisões a um controle de videogame montado com um módulo joystick.
- Lembrete de postura: Meça a inclinação das costas com um MPU6050 e emita uma vibração curta quando você ficar sentado com as costas curvadas por muito tempo.
- Vibração no lugar do som: Em um alarme usado à noite, coloque um motor de vibração sob o travesseiro no lugar de um buzzer.
Erros comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| O motor não gira | Valor de PWM abaixo do limite de partida ou ausência de GND comum | Teste primeiro com 255, adicione um pulso de partida e conecte os terras |
| O Arduino reinicia quando o motor funciona | A corrente de partida derruba a tensão da alimentação ou falta o diodo | Use um módulo pronto e adicione um capacitor de 47–100 µF entre VCC e GND |
| A vibração é muito fraca | O módulo é alimentado com 3,3 V ou o motor está sobre uma superfície macia | Conecte VCC a 5 V e cole o motor em uma superfície rígida |
| O motor esquenta | Ele funciona com potência máxima a 5 V por muito tempo | Limite a potência a 60–70% com PWM e use pulsos curtos em vez de vibração contínua |
| O motor emite um zumbido agudo e fraco | A frequência PWM está na faixa audível | Ajuste a frequência LEDC para 20 kHz no ESP32; use vibrações curtas no Uno |
| Erro de ledcSetup não encontrado no ESP32 | Core do ESP32 na versão 3.x | Use a seleção condicional #if ESP_ARDUINO_VERSION_MAJOR deste artigo |
| Um pino parou de funcionar após conectar um motor avulso | O motor foi conectado diretamente ao pino e o danificou | Use outro pino e sempre acione o motor por meio de um transistor e um diodo |
| Os padrões parecem iguais ao toque | As vibrações são curtas demais ou os intervalos são pequenos demais | Faça a vibração mais curta durar 40–60 ms e o intervalo ser de pelo menos 100 ms |
Um motor de vibração é a maneira mais barata de acrescentar o sentido do tato aos seus projetos, além de telas e sons. Agora que você conhece o transistor e o diodo dentro do módulo, o ajuste de intensidade com PWM, o pulso de partida e os padrões táteis, pode desenvolver tanto alertas silenciosos quanto dispositivos assistivos para pessoas com deficiência visual. No app BlueGrays, você pode explorar projetos como buzzer, sensor de estacionamento com HC-SR04 e controle de potência com PWM, com esquemas do circuito passo a passo e código pronto, e desenvolver suas próprias ideias adicionando um motor de vibração a eles.
Perguntas frequentes
Como conectar um motor de vibração ao Arduino?
Conecte o pino VCC do módulo de motor de vibração pronto a 5V, GND a GND e IN a um pino PWM, como D5. O transistor do módulo conduz a corrente do motor, e o diodo protege o Arduino. Se você usar um motor avulso, precisa adicionar um transistor NPN, um resistor de base de 1 kΩ e um diodo.
Com que tensão um motor de vibração funciona?
A maioria dos motores de vibração ERM tipo moeda tem tensão nominal de 3 V e funciona entre cerca de 2,5 e 3,5 V. Módulos prontos podem ser alimentados com 3,3–5 V; a 5 V, o motor vibra com mais força, mas limitar a potência com PWM em usos prolongados aumenta sua vida útil. Abaixo de cerca de 2 V, o motor não parte.
Quanta corrente um motor de vibração consome?
Um motor de vibração tipo moeda típico consome 60–90 mA em funcionamento e, por um breve instante, 100–120 mA na partida. Isso é várias vezes a corrente que um pino do Arduino pode fornecer com segurança. Por isso, o motor deve ser acionado por um transistor ou um módulo pronto.
Como controlar a intensidade de um motor de vibração?
A intensidade é ajustada com PWM, ou seja, com analogWrite(pin, 0–255) no Arduino; quanto maior o valor, mais rápido o motor gira e mais forte ele vibra. Como o motor não gira abaixo de um determinado limite, aplicar potência máxima por 20–30 ms primeiro e depois reduzir para o valor desejado funciona bem em baixa potência. No ESP32, ledcWrite(), e no Pico, duty_u16(), fazem o mesmo trabalho.
Qual é a diferença entre motores de vibração ERM e LRA?
Um motor ERM vibra ao girar uma massa desequilibrada no seu eixo e funciona com tensão CC contínua. Um LRA move um ímã preso a uma mola para frente e para trás, só funciona com um sinal alternado na sua frequência de ressonância e responde de forma mais nítida e rápida. Acionar um LRA exige um driver tátil como o DRV2605.
Por que um motor de vibração precisa de um diodo?
Como o motor contém uma bobina, surge um pico de tensão reversa elevado nos seus terminais no momento em que a corrente é cortada. Um diodo conectado em paralelo com o motor, com polaridade invertida, curto-circuita esse pico e evita danos ao transistor e ao microcontrolador. Os módulos prontos já têm esse diodo na placa.
Projetos para montar depois desta leitura
Ver todos os projetos
Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

Controle de LED com botão (momentâneo)
É como uma campainha: a luz fica acesa enquanto você pressiona o botão e apaga quando você solta.

Sensor de estacionamento com HC-SR04
Uma versão em miniatura do sensor de estacionamento de um carro: quanto mais perto um objeto chega, mais rápidos ficam os bipes.

Variação gradual do brilho do LED com PWM no ESP32
Varie suavemente o brilho do LED de 0 ao máximo e do máximo a 0. Controlamos o PWM com analogWrite(), como no Arduino. A mesma sintaxe funciona sem problemas com ESP32 Arduino Core 3.0+. Basta definir o pino e usar pinMode e analogWrite.

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

Sensor de estacionamento com ESP32 (HC-SR04 + barra de 5 LEDs + buzzer + OLED)
A versão com ESP32 do sensor de estacionamento de carro! Usamos o sensor ultrassônico HC-SR04 para medir a distância até o objeto à sua frente. Conforme a distância diminui, a barra de 5 LEDs vai se preenchendo (verde → amarelo → vermelho) e o intervalo entre os bipes do buzzer diminui. Quando o objeto chega muito perto (menos de 10 cm), o alarme soa continuamente e todos os LEDs acendem.

Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
O LED não só pisca — ele respira! Com o PWM (modulação por largura de pulso) do Raspberry Pi Pico, o brilho do LED aumenta e diminui lentamente, como a luz de um MacBook em repouso. Aprenda a usar a classe machine.PWM, duty_u16() (brilho de 16 bits, de 0–65535), frequência PWM (freq(1000) — 1.000 ciclos de ligar/desligar por segundo, sem cintilação visível), laços com passos usando range() (crescentes e decrescentes) e saída semelhante à analógica em um pino digital.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

