Composants · 15 min de lecture

Moteur vibreur Arduino : module, PWM et motifs haptiques

Moteur vibreur Arduino : module ERM type pièce, transistor et diode, intensité en PWM, motifs haptiques, canne intelligente, code ESP32 et Pico, DRV2605.

Dans les projets moteur vibreur Arduino, un petit moteur est le moyen le plus simple d'informer l'utilisateur sans son ni lumière. Les téléphones en mode silencieux, les montres connectées qui tapotent le poignet et les manettes de jeu qui tremblent utilisent tous ces minuscules moteurs. Le type le plus courant en électronique amateur est le moteur ERM type pièce de monnaie (coin), de 10 mm de diamètre et seulement 2 à 3 mm d'épaisseur. Un moteur nu ne se branche pas directement sur une broche Arduino, mais un module moteur vibreur tout prêt, avec transistor et diode, fonctionne avec seulement trois fils.

Dans ce guide, tu vas apprendre comment vibre un moteur ERM, pourquoi le transistor et la diode du module sont nécessaires et combien de courant le moteur consomme. Ensuite, on réglera la vibration pas à pas en PWM et on verra pourquoi le moteur ne démarre pas du tout à faible puissance et comment une « impulsion de démarrage » règle le problème. On écrira un code qui joue des motifs haptiques comme un tap court, un double tap, un battement de cœur ou un SOS sans utiliser delay(), et on construira la logique d'une canne intelligente qui vibre selon la distance. Dans les dernières parties, tu trouveras un exemple qui donne un retour vibrant quand on touche la broche tactile de l'ESP32, du code MicroPython pour le Raspberry Pi Pico et le pilote DRV2605 pour des effets haptiques avancés.

Module moteur vibreur
Module moteur vibreur : moteur ERM type pièce, transistor de commande et diode de protection sur une seule carte.

Qu'est-ce qu'un moteur vibreur et comment fonctionne-t-il ?

ERM signifie en anglais « Eccentric Rotating Mass », c'est-à-dire masse rotative excentrique. L'axe du moteur porte une petite masse dont le centre de gravité n'est pas exactement au milieu. Quand le moteur tourne, ce balourd le tire d'un côté à chaque tour, et c'est cette traction que tu ressens comme une vibration. Dans les moteurs type pièce, la masse tourne à l'intérieur du boîtier plat et rien ne bouge à l'extérieur, ce qui les rend très faciles à coller et à utiliser. Les moteurs ERM cylindriques ont un contrepoids métallique en demi-lune à l'extérieur et vibrent plus fort. L'intensité comme la fréquence de la vibration dépendent de la vitesse du moteur : quand la tension monte, le moteur accélère et la vibration devient à la fois plus forte et plus aiguë. Le LRA (actionneur linéaire résonant), de plus en plus présent dans les téléphones et les manettes, fonctionne autrement : il fait aller et venir un aimant sur un ressort et ne fonctionne correctement qu'avec un signal alternatif à sa propre fréquence de résonance, pas avec une tension continue. Les modules des kits Arduino sont presque toujours des ERM.

CaractéristiqueMoteur ERM type pièce typique (ex. 1027)
Taille10 mm de diamètre, 2,7 mm d'épaisseur
Tension nominale3 V (environ 2,5–3,5 V)
Courant de fonctionnementEnviron 60–90 mA à 3 V
Courant de démarrageBrièvement 100–120 mA
VitesseEnviron 10 000–13 000 tr/min
Fréquence de vibrationEnviron 160–220 Hz
Tension minimale de démarrageEnviron 2–2,3 V ; en dessous, le moteur ne démarre pas

Que contient un module moteur vibreur ?

Une broche d'Arduino Uno fournit au maximum 40 mA, et la limite sûre tourne autour de 20 mA. Les broches de l'ESP32 et du Pico sont encore plus faibles. Un moteur vibreur, lui, consomme 60 à 120 mA et se comporte comme une bobine : au moment où son courant est coupé, une forte surtension inverse apparaît à ses bornes. C'est pourquoi brancher le moteur directement sur une broche force la broche et peut redémarrer, voire endommager le microcontrôleur. Un module tout prêt règle le problème avec trois composants :

  • Transistor de commande : En général un S8050 ou un petit NPN équivalent, parfois un MOSFET canal N. La broche Arduino ne fournit que quelques milliampères de commande, le courant du moteur passe par le transistor. On explique comment un transistor fonctionne en interrupteur dans Qu'est-ce qu'un transistor ?.
  • Résistance de base : Limite le courant de la broche vers le transistor ; une valeur d'environ 1 kΩ convient aux cartes 5 V comme 3,3 V.
  • Diode de roue libre : Montée en inverse aux bornes du moteur, cette diode court-circuite la surtension créée à l'arrêt du moteur et protège le transistor. Son rôle est expliqué dans Qu'est-ce qu'une diode ?.

La plupart des modules ont trois broches : VCC, GND et la broche de signal IN (S ou SIG sur certaines cartes). Quand tu mets IN à HIGH, le transistor conduit et le moteur tourne. Le module fonctionne entre 3,3 et 5 V. Alimenté en 5 V, le moteur reçoit environ 4,5 V après la petite chute du transistor, soit plus que la tension nominale d'un moteur 3 V. Pour des alertes courtes ce n'est pas un problème, mais si le moteur doit tourner longtemps sans arrêt, limiter la puissance à environ 60–70 pour cent en PWM prolonge sa durée de vie.

Branchement : Arduino Uno, ESP32 et Raspberry Pi Pico

Le tableau ci-dessous donne les broches utilisées par tous les programmes de cet article. Sur chaque carte, la broche du moteur doit pouvoir sortir du PWM. Sur l'ESP32 et le Pico, le signal 3,3 V sur la broche IN suffit pour piloter le transistor ; tu peux relier le VCC du module au 5 V pour une vibration plus forte ou au 3,3 V pour une vibration plus douce. Quelle que soit l'alimentation choisie, les masses (GND) doivent être communes.

LiaisonArduino UnoESP32Raspberry Pi Pico
VCC du module5VVIN (5 V) ou 3V3VBUS (5 V) ou 3V3(OUT)
GND du moduleGNDGNDGND
IN du moduleD5 (PWM)GPIO 25GP15
Bouton (autre patte au GND)D2Broche tactile GPIO 4 (T0)GP14
HC-SR04 TRIG (exemple de la canne)D9--
HC-SR04 ECHO (exemple de la canne)D10--
Si tu utilises un moteur nu sans module, ne le branche jamais directement sur une broche. Relie une borne du moteur au 5 V et l'autre au collecteur d'un transistor NPN (2N2222, BC337 ou S8050) ; l'émetteur au GND et la base à la broche Arduino via une résistance de 1 kΩ. Place une diode 1N4148 ou 1N5819 aux bornes du moteur, cathode (côté bague) vers le 5 V. Sans la diode, le transistor peut lâcher rapidement et l'Arduino redémarrer au hasard. Tu peux vérifier la résistance de base avec l'outil Loi d'Ohm et le courant et le gain du transistor avec l'outil Transistors.

Premier programme : marche-arrêt et intensité en PWM

Tu peux voir le module moteur vibreur comme une LED : digitalWrite(HIGH) fait tourner le moteur à pleine puissance, tandis qu'analogWrite() règle en PWM la tension moyenne et donc l'intensité de la vibration. Sur l'Arduino Uno, les broches D5 et D6 tournent à environ 980 Hz et les autres broches PWM à environ 490 Hz. On a détaillé les bases du PWM dans Qu'est-ce que le PWM ?. Les moteurs ERM ont une particularité importante : faire démarrer un moteur à l'arrêt demande plus de puissance que de faire tourner un moteur déjà lancé. C'est pourquoi un moteur démarré avec une faible valeur PWM peut ne pas bouger du tout. La solution consiste à lancer le moteur à pleine puissance pendant quelques dizaines de millisecondes puis à descendre à la valeur voulue ; c'est ce qu'on appelle une impulsion de démarrage (kick-start). Le programme ci-dessous fait d'abord une courte vibration à pleine puissance, puis augmente l'intensité par paliers et affiche chaque palier dans le moniteur série.

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}

En lançant le code, tu remarqueras qu'en dessous d'une certaine valeur PWM le moteur ne vibre pas du tout ou très faiblement. Avec une alimentation de 5 V, ce seuil se situe généralement entre 70 et 110 ; la valeur exacte dépend du moteur et du module. Note dans le moniteur série la valeur à laquelle tu sens nettement le moteur pour la première fois et utilise-la comme puissance minimale dans ton projet. Grâce à l'impulsion de démarrage, des valeurs un peu sous ce seuil peuvent aussi fonctionner, car un moteur déjà lancé continue de tourner avec moins de puissance.

Valeur PWM (alimentation 5 V)Tension moyenneVibration ressentie
0–600–1,2 VAucune, le moteur ne tourne pas
70–1101,4–2,2 VZone de seuil ; impulsion de démarrage parfois nécessaire
120–1702,4–3,3 VVibration légère à moyenne, idéale pour les alertes longues
180–2553,5–4,5 VVibration forte, pour des alertes courtes et marquantes

Motifs haptiques : tap court, double tap, battement de cœur et SOS

Une vibration toujours identique dit seulement « il s'est passé quelque chose ». Des motifs différents disent aussi quoi : un tap court peut signifier une confirmation, deux taps courts un avertissement, une longue vibration une alarme et un rythme de battement de cœur un rappel. La main humaine perçoit mal les vibrations de moins de 20–30 ms, et un moteur ERM a besoin d'environ 30–50 ms pour prendre de la vitesse. Garde donc la vibration la plus courte d'un motif à 40–60 ms et la pause entre deux vibrations à au moins 80–100 ms. Dans le programme ci-dessous, chaque motif est un tableau de paires {puissance, durée}. Le lecteur de motifs fonctionne avec millis(), donc loop() peut faire autre chose pendant qu'un motif se joue. Chaque appui sur le bouton en D2 joue le motif suivant.

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}

Pour changer les motifs, il suffit de modifier les tableaux ; la fonction de lecture reste la même. Dans le motif SOS, les vibrations courtes durent 100 ms, les longues 350 ms et la pause entre les lettres 300 ms ; ces proportions suivent le schéma « point, trait » du code Morse. Garde des motifs bien distincts pour qu'on ne les confonde pas : un nombre différent de vibrations (une, deux, trois) ou des durées nettement différentes. Avant de les intégrer à un projet, teste-les sur quelques personnes et demande-leur de deviner ce que signifie chaque motif ; en design haptique, c'est le meilleur test.

Alertes portables et canne intelligente

Le moteur vibreur prend tout son sens là où le son dérange ou ne s'entend pas. Dans les projets portables, place le moteur dans un bracelet, un gant ou une ceinture, près de la peau. L'intérieur du poignet, la paume et le bout des doigts sont les zones les plus sensibles aux vibrations. Coller le moteur sur une surface rigide, par exemple la paroi intérieure d'un boîtier imprimé en 3D avec du ruban double face, transmet mieux la vibration que de le coudre lâchement sur du tissu. Dans les cannes intelligentes pour personnes malvoyantes, le moteur se place dans la partie de la poignée juste sous le pouce, et la distance de l'obstacle se traduit en fréquence et en intensité de vibration : plus l'obstacle approche, plus les vibrations sont rapprochées et fortes, jusqu'à devenir continues quand il est tout près. Le programme ci-dessous montre cette logique avec un capteur de distance 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}

Pour rester simple, ce programme utilise delay() et ne mesure pas pendant l'attente ; dans une vraie canne, une structure basée sur millis() comme celle de la partie précédente réagit mieux. On garde la puissance minimale à 150 pour que, face aux obstacles lointains, le moteur ne reste pas sous son seuil sans tourner. Pour un projet complet avec alerte flaque d'eau, détection de chute, SOS et calcul de batterie, vois le projet de canne intelligente Arduino, et pour les détails du capteur le guide du capteur de distance HC-SR04.

Courant, alimentation et autonomie

Un moteur type pièce consomme 60 à 90 mA en marche et, au démarrage, un peu plus de 100 mA pendant un bref instant. La broche 5V de l'Arduino Uno fournit cela sans problème depuis l'USB. Les ennuis apparaissent surtout dans les circuits sur batterie dont la tension est déjà juste, ou dans les projets avec plusieurs moteurs qui tournent en même temps : au démarrage du moteur, la tension chute un instant et la carte redémarre. Pour l'éviter, ajoute un condensateur électrolytique de 47–100 µF entre VCC et GND du module et, si tu utilises plusieurs moteurs, démarre-les à quelques millisecondes d'intervalle plutôt qu'au même moment. Pour calculer l'autonomie, tiens compte du fait que le moteur fonctionne par courtes salves et non en continu : par exemple, un moteur de 80 mA qui tourne 3 secondes au total par minute n'a qu'un courant moyen de 4 mA. Avec les valeurs de ton projet, l'outil Autonomie de batterie te dit combien d'heures il tiendra.

Retour tactile avec l'ESP32

Deux atouts de l'ESP32 se marient très bien avec un moteur vibreur : la puce dispose de broches tactiles capacitives, et l'unité LEDC qui génère le PWM te laisse choisir librement la fréquence. Le programme ci-dessous donne un court « clic », comme un écran de téléphone, quand on touche un fil ou un morceau de ruban de cuivre relié au GPIO 4 (T0) ; si le contact dure plus d'une seconde, il confirme par une longue vibration. On a fixé la fréquence PWM à 20 kHz, à la limite de l'audition humaine, pour que le léger sifflement éventuel du pilote moteur disparaisse aussi. Le code compile avec les versions 2.x et 3.x du core Arduino de l'ESP32, car les noms des fonctions LEDC diffèrent entre les deux.

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}

Sur l'ESP32, la valeur de la broche tactile tourne généralement autour de 50–80 sans contact et baisse nettement au toucher du doigt ; c'est pourquoi le code mesure la moyenne au démarrage et calcule le seuil tout seul. Sur les ESP32-S2 et S3, en revanche, les valeurs tactiles montent au toucher ; sur ces cartes, il faut inverser la comparaison. Si tu relies le VCC du module à la broche VIN de l'ESP32, le moteur vibre plus fort en 5 V ; le signal 3,3 V de la broche IN suffit pour le transistor. En combinant cela avec le Wi-Fi ou le Bluetooth, tu peux créer un bracelet qui vibre à chaque notification du téléphone ou un appareil d'alerte piloté en BLE avec l'ESP32.

Moteur vibreur avec le Raspberry Pi Pico et MicroPython

Sur le Raspberry Pi Pico, chaque broche GPIO peut générer du PWM. En MicroPython, la fonction duty_u16() de la classe PWM prend une valeur entre 0 et 65535 ; 65535 correspond à la pleine puissance. Le code ci-dessous joue un motif de battement de cœur à chaque appui sur le bouton relié à GP14. Comme dans l'exemple Arduino, le motif est une liste de paires puissance-durée. Tu peux relier le VCC du module à VBUS (le 5 V de l'USB) pour une vibration plus forte ou à 3V3(OUT) pour une vibration plus douce.

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)

Les broches du Pico fonctionnent en 3,3 V et il est déconseillé de tirer plus d'environ 12 mA d'une seule broche ; avec le Pico aussi, il faut donc un module à transistor et non un moteur nu. Pendant qu'un motif se joue, le bouton n'est pas lu ; si tu dois faire plusieurs choses à la fois, tu peux reproduire le schéma millis() d'Arduino avec time.ticks_ms() ou faire avancer les étapes du motif avec une interruption Timer. Si tu débutes en MicroPython, l'article bases de MicroPython est un bon point de départ.

Pilote haptique DRV2605 : des effets de vibration professionnels

Un module à transistor ne fait qu'allumer et éteindre le moteur, ou le rendre plus ou moins fort en PWM. Le « clic » net d'un téléphone vient d'un démarrage et d'un arrêt très rapides : le moteur est d'abord accéléré par une impulsion au-dessus de sa tension nominale (overdrive), puis freiné à la fin par une brève tension inverse. La puce DRV2605L de Texas Instruments le fait toute seule. Elle se branche en I2C (adresse 0x5A), pilote les moteurs ERM comme LRA et contient 123 effets intégrés comme des clics, des doubles clics, des bourdonnements et des chocs doux. Elle apprend les caractéristiques du moteur par auto-calibration et peut transformer une entrée audio en vibration. Avec la bibliothèque Adafruit DRV2605, quelques lignes suffisent ; sur l'Uno, tu relies SDA à A4 et SCL à A5, et le moteur se branche directement sur la sortie moteur de la carte 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}

Le DRV2605 peut enchaîner jusqu'à 8 effets dans une séquence ; tu remplis les emplacements 0 à 7 avec setWaveform() et tu marques la fin de la séquence par 0. Si tu utilises un moteur LRA, appelle useLRA() et choisis la bibliothèque LRA numéro 6. Pour des alertes simples, un module à transistor suffit largement ; si tu conçois un objet portable, une manette de jeu ou une interface tactile, le DRV2605 améliore nettement la sensation.

Idées de projets avec un moteur vibreur

  • Bracelet minuteur silencieux : Crée un minuteur pomodoro qui vibre à ton poignet à la fin du cours ou de la séance de travail, sans déranger personne.
  • Canne intelligente pour malvoyants : Suis le guide de la canne intelligente pour un projet complet qui traduit la distance de l'obstacle en rythme de vibration.
  • Sonnette silencieuse : Fais vibrer un appareil dans ta poche quand un détecteur de mouvement PIR à la porte repère quelqu'un.
  • Manette de jeu : Ajoute des vibrations lors des collisions à une manette construite avec un module joystick.
  • Alerte de posture : Mesure l'inclinaison de ton dos avec un MPU6050 et préviens par une courte vibration quand tu restes voûté trop longtemps.
  • Vibration au lieu du son : Pour un réveil de nuit, glisse un moteur vibreur sous l'oreiller au lieu d'un buzzer.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Le moteur ne tourne pas du toutValeur PWM sous le seuil de démarrage ou GND non communEssaie d'abord 255, ajoute l'impulsion de démarrage et relie les masses
L'Arduino redémarre quand le moteur tourneLe courant de démarrage fait chuter l'alimentation ou la diode manqueUtilise un module tout prêt et ajoute 47–100 µF entre VCC et GND
La vibration est très faibleLe module est en 3,3 V ou le moteur repose sur une surface molleRelie VCC au 5 V et colle le moteur sur une surface rigide
Le moteur chauffeIl tourne longtemps à pleine puissance en 5 VLimite la puissance à 60–70 % en PWM et utilise des impulsions courtes plutôt qu'une vibration continue
Un léger sifflement sort du moteurLa fréquence PWM est dans la plage audibleSur l'ESP32, mets la fréquence LEDC à 20 kHz ; sur l'Uno, utilise des vibrations courtes
Erreur ledcSetup introuvable sur l'ESP32Core ESP32 en version 3.xUtilise l'aiguillage #if ESP_ARDUINO_VERSION_MAJOR de cet article
Une broche ne marche plus après avoir branché un moteur nuLe moteur était relié directement à la broche et l'a abîméeUtilise une autre broche et pilote toujours le moteur via transistor et diode
Les motifs se ressemblentVibrations trop courtes ou pauses trop brèvesVibration la plus courte à 40–60 ms, pause d'au moins 100 ms
Teste la vibration là où elle servira vraiment, pas sur ton bureau. Un moteur posé sur une table fait vibrer le bois et paraît plus fort qu'il ne l'est ; dans un bracelet ou une poignée de canne, le même moteur peut sembler bien plus faible. Fixe solidement le moteur sur une surface rigide, attache les fils pour qu'ils ne tirent pas et mesure de nouveau la valeur PWM de seuil après l'assemblage final.

Le moteur vibreur est le moyen le moins cher d'ajouter le sens du toucher à tes projets, en plus des écrans et des sons. Maintenant que tu connais le transistor et la diode du module, le réglage d'intensité en PWM, l'impulsion de démarrage et les motifs haptiques, tu peux concevoir aussi bien des alertes silencieuses que des aides pour personnes malvoyantes. Dans l'application BlueGrays, tu peux explorer des projets comme le buzzer, le radar de recul HC-SR04 et le contrôle de puissance en PWM, avec des schémas pas à pas et du code prêt à l'emploi, puis développer tes propres idées en y ajoutant un moteur vibreur.

Questions fréquentes

Comment brancher un moteur vibreur sur un Arduino ?

Relie le VCC du module moteur vibreur au 5V, le GND au GND et IN à une broche PWM comme D5. Le transistor du module porte le courant du moteur et la diode protège l'Arduino. Avec un moteur nu, il faut obligatoirement ajouter un transistor NPN, une résistance de base de 1 kΩ et une diode.

Quelle tension pour un moteur vibreur ?

La plupart des moteurs vibreurs ERM type pièce ont une tension nominale de 3 V et fonctionnent entre environ 2,5 et 3,5 V. Les modules s'alimentent en 3,3–5 V ; en 5 V le moteur vibre plus fort, mais en usage prolongé, limiter la puissance en PWM prolonge sa vie. En dessous d'environ 2 V, le moteur ne démarre pas.

Combien de courant consomme un moteur vibreur ?

Un moteur vibreur type pièce typique consomme 60 à 90 mA en marche et brièvement 100 à 120 mA au démarrage. C'est plusieurs fois ce qu'une broche Arduino peut fournir sans risque. Le moteur doit donc être piloté par un transistor ou par un module tout prêt.

Comment régler l'intensité d'un moteur vibreur ?

L'intensité se règle en PWM, c'est-à-dire avec analogWrite(broche, 0–255) sur Arduino ; plus la valeur est grande, plus le moteur tourne vite et vibre fort. Comme le moteur ne démarre pas sous un certain seuil, donner d'abord 20–30 ms de pleine puissance puis descendre à la valeur visée fonctionne bien à faible puissance. Sur l'ESP32, ledcWrite() fait le même travail, et duty_u16() sur le Pico.

Quelle différence entre un moteur vibreur ERM et LRA ?

Le moteur ERM vibre en faisant tourner une masse déséquilibrée sur son axe et fonctionne en courant continu. Le LRA fait aller et venir un aimant sur un ressort, ne fonctionne qu'avec un signal alternatif à sa fréquence de résonance et réagit de façon plus nette et plus rapide. Pour piloter un LRA, il faut un pilote haptique comme le DRV2605.

Pourquoi un moteur vibreur a-t-il besoin d'une diode ?

Comme le moteur contient une bobine, une forte surtension inverse apparaît à ses bornes au moment où son courant est coupé. Une diode montée en inverse aux bornes du moteur court-circuite cette surtension et évite d'abîmer le transistor et le microcontrôleur. Les modules tout prêts ont déjà cette diode sur la carte.

Voir tous les projets
Utilisation du buzzer
AR-13Débutant

Utilisation du buzzer

Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence.

4.7(92)
170
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

HC-SR04 Mesure de la distance (affichage en série)

Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

4.6(50)
82
Allumer une LED avec un bouton-poussoir (Push)
AR-9Débutant

Allumer une LED avec un bouton-poussoir (Push)

Comme une sonnette : la lumière reste allumée tant que tu appuies et s'éteint quand tu relâches.

4.8(114)
253
Capteur de stationnement avec HC-SR04
AR-28Intermédiaire
Premium

Capteur de stationnement avec HC-SR04

Une version miniature du radar de recul des voitures : plus un objet s'approche, plus les bips s'accélèrent.

4.8(64)
86
ESP32 LED Fade avec PWM
ES-8Débutant

ESP32 LED Fade avec PWM

Modifiez la luminosité de la LED en douceur de 0 à max, de max à 0. Nous contrôlons le PWM avec analogWrite() comme dans Arduino - la même syntaxe avec ESP32 Arduino Core 3.0+ fonctionne sans problème. La définition du pin + pinMode + analogWrite est suffisante.

4.8(36)
55
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)

Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

4.5(19)
32
Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)
ES-38Avancé
Premium

Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)

La version ESP32 d'un radar de recul ! Le capteur à ultrasons HC-SR04 mesure la distance jusqu'à l'objet devant lui. Plus il se rapproche, plus une barre de 5 LED se remplit (vert → jaune → rouge) et plus le buzzer bipe vite. Tout près (moins de 10 cm), une alarme continue retentit et toutes les LED s'allument. L'écran OLED SSD1306 affiche la distance en cm en grands caractères, avec un message d'état.

14
Raspberry Pi Pico PWM LED Fade (Effet Respiration)
PI-14Débutant

Raspberry Pi Pico PWM LED Fade (Effet Respiration)

La LED ne clignote plus — elle respire ! Grâce au PWM (modulation de largeur d'impulsion) du Raspberry Pi Pico, la luminosité monte puis descend lentement. Apprends la classe machine.PWM, duty_u16() (luminosité 16 bits 0–65535), la fréquence PWM, les boucles range() et la sortie quasi analogique. Base du mélange de couleurs RGB, du contrôle moteur, des servos et du buzzer.

4