Driver moteur L9110S Arduino : double canal et vitesse PWM
Comment brancher un driver moteur L9110S sur Arduino ? Broches, sens et vitesse PWM, limite de 800 mA, exemples de voiture robot et de ventilateur, code Uno, ESP32 et Pico.
Le L9110S est un module driver double canal, grand comme le bout d'un doigt et très bon marché, qui te permet de contrôler à la fois le sens et la vitesse de deux petits moteurs DC. Le duo L9110S et Arduino est l'une des solutions les plus pratiques pour les mini voitures robot sur piles, les petits ventilateurs, les bateaux jouets et les projets à hélice. Le module embarque deux puces L9110S ; chacune peut piloter un moteur avec environ 800 mA en continu par canal, sous 2,5 à 12 V.
Les broches d'Arduino ne peuvent pas fournir assez de courant pour alimenter directement un moteur : une broche d'Uno donne au maximum 20 à 40 mA, alors qu'un petit moteur jaune à réducteur en demande des dizaines de fois plus au démarrage. De plus, pour inverser le sens d'un moteur, il faut inverser le sens du courant qui le traverse. Dans cet article, tu vas découvrir les broches du L9110S, sa table de vérité, le réglage de vitesse par PWM et la limite de courant ; tu vas écrire le code d'une voiture robot avec Arduino Uno, d'un ventilateur piloté par potentiomètre avec ESP32 et du code MicroPython pour Raspberry Pi Pico. Dans la dernière partie, on verra quand le L9110S peut remplacer le L298N et quand il ne le peut pas.

Qu'est-ce que le L9110S et comment fonctionne-t-il ?
À l'intérieur du L9110S se trouve un pont en H composé de quatre interrupteurs. Quand les interrupteurs s'ouvrent et se ferment par paires en diagonale, le courant traverse le moteur dans un sens ou dans l'autre, et le moteur tourne en avant ou en arrière. Chaque pont en H a deux broches d'entrée (IA et IB) et deux broches de sortie (OA et OB). Si tu mets IA à HIGH et IB à LOW, le moteur tourne dans un sens ; avec l'inverse, il tourne dans l'autre. Si tu appliques un signal PWM sur l'une de ces deux entrées, la tension moyenne vue par le moteur change et tu règles ainsi sa vitesse. La puce contient aussi des diodes de protection contre les pointes de tension inverse que le moteur génère à l'arrêt et aux changements de sens ; tu n'as donc pas besoin d'ajouter de diode externe. Le module n'a ni alimentation logique séparée ni régulateur 5 V : la tension que tu appliques sur VCC alimente à la fois les puces et les moteurs.
| Caractéristique | Valeur |
|---|---|
| Puce de commande | 2 × L9110S (une par moteur) |
| Nombre de canaux | 2 moteurs DC ou 1 petit moteur pas à pas bipolaire |
| Tension d'alimentation (VCC) | 2,5 à 12 V |
| Courant continu | Environ 800 mA par canal |
| Courant de pointe | Environ 1,5 A en bref |
| Entrée logique | Compatible 3,3 V et 5 V |
| Contrôle de la vitesse | PWM sur les broches d'entrée (pas de broche enable séparée) |
| Protection | Diodes de roue libre intégrées |
| Taille | Environ 3 × 2,5 cm, quelques grammes |
Broches du L9110S et table de vérité
| Broche | Fonction |
|---|---|
| B-IA | Entrée 1 du moteur B (PWM possible) |
| B-IB | Entrée 2 du moteur B (PWM possible) |
| GND | Masse commune (moins de la pile et GND du microcontrôleur) |
| VCC | Alimentation des moteurs et des puces, 2,5 à 12 V |
| A-IA | Entrée 1 du moteur A (PWM possible) |
| A-IB | Entrée 2 du moteur A (PWM possible) |
| MOTOR A / MOTOR B | Borniers à vis à deux bornes pour brancher les moteurs |
| A-IA | A-IB | Moteur A |
|---|---|---|
| HIGH | LOW | Tourne en avant |
| LOW | HIGH | Tourne en arrière |
| LOW | LOW | S'arrête |
| HIGH | HIGH | S'arrête |
| PWM | LOW | Avant, vitesse selon le rapport cyclique |
| LOW | PWM | Arrière, vitesse selon le rapport cyclique |
Ici, « avant » et « arrière » ne sont que des noms : le vrai sens de rotation dépend de l'ordre dans lequel tu as branché les fils sur le bornier. Si le moteur tourne à l'envers, inverse simplement ses deux fils plutôt que de modifier le code. Comme le module n'a pas de broches ENA/ENB comme le L298N, tu envoies le PWM sur l'une des deux entrées pour régler la vitesse. Si tu manques de broches PWM, tu peux garder une entrée à HIGH fixe et envoyer le PWM sur l'autre ; mais la logique s'inverse alors : plus le rapport cyclique monte, plus le moteur ralentit, car il s'arrête quand les deux entrées sont à HIGH. La méthode la plus propre reste donc de réserver deux broches PWM par moteur.
Branchement du L9110S : Arduino Uno, ESP32 et Pico
| Broche L9110S | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| A-IA | D5 | GPIO 25 | GP16 |
| A-IB | D6 | GPIO 26 | GP17 |
| B-IA | D9 | GPIO 32 | GP18 |
| B-IB | D10 | GPIO 33 | GP19 |
| VCC | Plus de la pile (ex. 4×AA, 6 V) | Plus de la pile (ex. 4×AA, 6 V) | Plus de la pile (ex. 4×AA, 6 V) |
| GND | GND (commun avec le moins de la pile) | GND (commun avec le moins de la pile) | GND (commun avec le moins de la pile) |
| Curseur du potentiomètre (optionnel) | A0 | GPIO 34 | GP26 |
Pour l'alimentation, choisis une source proche de la tension nominale de ton moteur. Pour les moteurs jaunes TT à réducteur et les micro-moteurs N20, 4 piles AA (environ 6 V) sont un excellent point de départ. Deux accus Li-Ion 18650 en série donnent 7,4 V (8,4 V pleine charge) ; des moteurs 6 V l'acceptent mais chauffent et s'usent plus vite, et il est alors judicieux de limiter la vitesse maximale par PWM. Souder un condensateur électrolytique de 100 µF sur la ligne VCC près du bornier, et un condensateur céramique de 100 nF entre les deux bornes de chaque moteur, réduit fortement l'influence du bruit des moteurs sur le microcontrôleur. Pour estimer l'autonomie, utilise l'outil de calcul d'autonomie de pile : avec des piles AA de 2000 mAh, un robot qui consomme 450 mA au total tient environ 2000 / 450 ≈ 4,4 heures ; en pratique, un peu moins.
Pas à pas : voiture robot avec L9110S (Arduino Uno)
- Fixe les deux moteurs DC à réducteur sur le châssis ; branche le moteur gauche sur le bornier MOTOR A et le droit sur MOTOR B.
- Relie les broches A-IA et A-IB du module aux broches D5 et D6 de l'Uno, et B-IA et B-IB aux broches D9 et D10 ; ce sont toutes les quatre des broches compatibles PWM.
- Branche le plus du boîtier de 4 piles AA sur la broche VCC du module et le moins sur la broche GND.
- Relie la broche GND du module à la broche GND de l'Uno avec un fil de liaison pour créer la masse commune.
- Alimente l'Uno par USB et téléverse le code ci-dessous ; pour le premier essai, soulève les roues.
- Si un moteur tourne dans le mauvais sens, inverse ses deux fils sur le bornier.

1// L9110S ile iki motorlu robot araba / Two-motor robot car with L9110S
2const int A_IA = 5; // Sol motor girişi 1 (PWM) / left motor input 1 (PWM)
3const int A_IB = 6; // Sol motor girişi 2 (PWM) / left motor input 2 (PWM)
4const int B_IA = 9; // Sağ motor girişi 1 (PWM) / right motor input 1 (PWM)
5const int B_IB = 10; // Sağ motor girişi 2 (PWM) / right motor input 2 (PWM)
6
7// hız: -255 tam geri, 0 dur, 255 tam ileri / speed: -255 full reverse, 0 stop, 255 full forward
8void setMotor(int pinIA, int pinIB, int speed) {
9 speed = constrain(speed, -255, 255);
10 if (speed > 0) {
11 analogWrite(pinIA, speed); // ileri / forward
12 analogWrite(pinIB, 0);
13 } else if (speed < 0) {
14 analogWrite(pinIA, 0); // geri / reverse
15 analogWrite(pinIB, -speed);
16 } else {
17 analogWrite(pinIA, 0); // dur / stop
18 analogWrite(pinIB, 0);
19 }
20}
21
22void drive(int left, int right) {
23 setMotor(A_IA, A_IB, left);
24 setMotor(B_IA, B_IB, right);
25}
26
27void setup() {
28 pinMode(A_IA, OUTPUT);
29 pinMode(A_IB, OUTPUT);
30 pinMode(B_IA, OUTPUT);
31 pinMode(B_IB, OUTPUT);
32 drive(0, 0);
33 delay(2000); // tekerlekleri kaldırmak için süre / time to lift the wheels
34}
35
36void loop() {
37 for (int s = 80; s <= 200; s += 5) { // yumuşak kalkış / soft start
38 drive(s, s);
39 delay(30);
40 }
41 delay(1500); // 200 hızla ileri / forward at speed 200
42 drive(0, 0);
43 delay(500);
44 drive(-160, -160); // geri / reverse
45 delay(1000);
46 drive(0, 0);
47 delay(500);
48 drive(-150, 150); // yerinde sola dön / spin left in place
49 delay(600);
50 drive(150, -150); // yerinde sağa dön / spin right in place
51 delay(600);
52 drive(0, 0);
53 delay(2000);
54}| Morceau de code | Ce qu'il fait |
|---|---|
| setMotor(pinIA, pinIB, speed) | Selon le signe de la vitesse, envoie le PWM sur une entrée et 0 sur l'autre ; positif = avant, négatif = arrière, 0 = arrêt. |
| constrain(speed, -255, 255) | Écrête les valeurs qui dépasseraient la limite d'analogWrite. |
| drive(left, right) | Gère les deux moteurs ensemble ; des valeurs égales vont tout droit, des signes opposés font pivoter la voiture sur place. |
| boucle for (80 → 200) | Démarrage progressif : réduit l'appel de courant et le patinage des roues. |
| drive(-150, 150) | Le moteur gauche tourne en arrière et le droit en avant ; la voiture pivote vers la gauche sur son axe. |
Contrôle de vitesse par PWM : rapport cyclique et tension moyenne
Le PWM consiste à allumer et éteindre la broche des centaines de fois par seconde pour appliquer au moteur une tension moyenne. Grâce à son inertie, le moteur perçoit ces impulsions rapides comme une moyenne. Tu calcules la tension moyenne grossièrement avec la formule V_moy = V_alim × duty / 255 : avec une alimentation de 6 V, analogWrite(pin, 150) correspond à environ 6 × 150 / 255 ≈ 3,5 V. Sur l'Arduino Uno, les broches D5 et D6 génèrent un PWM d'environ 980 Hz, et D9 et D10 d'environ 490 Hz ; à ces fréquences, il est normal d'entendre un léger bourdonnement du moteur. Sur ESP32 et Pico, tu choisis toi-même la fréquence ; autour de 1 kHz est un point de départ sûr pour le L9110S. À très haute fréquence, la puce dissipe plus de chaleur à chaque commutation, et à très basse fréquence, le moteur tourne en vibrant. Pour plus de détails, consulte l'article Qu'est-ce que le PWM.
Limite de courant : quels moteurs le L9110S supporte-t-il ?
La limite la plus importante du L9110S est son courant continu d'environ 800 mA par canal. La valeur à surveiller n'est pas le courant à vide du moteur, mais son courant de blocage (stall). Quand le moteur démarre ou que la roue se bloque contre un obstacle, seule la résistance du bobinage limite le courant et le moteur consomme alors le maximum. Tu peux l'estimer grossièrement avec la loi d'Ohm : si la résistance du bobinage mesurée au multimètre est de 5 Ω et l'alimentation de 6 V, le courant de blocage est d'environ 6 / 5 = 1,2 A. Cette valeur ne pose pas de problème au démarrage bref, mais si la voiture reste plaquée contre un mur, roues bloquées, pendant plusieurs secondes, la puce chauffe vite. Comme le module n'a pas de dissipateur, il vaut mieux ne pas maintenir longtemps des charges continues supérieures à 500 mA par canal.
| Moteur | Courant typique | Pour le L9110S |
|---|---|---|
| Micro-moteur à réducteur N20 (6 V) | À vide 30–100 mA | Très adapté |
| Moteur jaune TT à réducteur (3–6 V) | À vide 150–250 mA, environ 1 A en blocage | Adapté ; évite les blocages prolongés |
| Moteur DC type 130 + hélice | 200–500 mA | Adapté (mini ventilateur) |
| Ventilateur PC brushless 5 V | 100–250 mA | Adapté dans un seul sens uniquement |
| Moteur 12 V à réducteur métallique (25GA/37GA) | 2–5 A en blocage | Non adapté, il faut un driver plus puissant |
| Moteur RS-550 / 775 | De quelques ampères à des dizaines d'ampères | Absolument pas adapté |
L9110S avec ESP32 : vitesse et sens d'un ventilateur par potentiomètre
Les broches de l'ESP32 fonctionnent en 3,3 V et les entrées du L9110S reconnaissent ce niveau sans problème ; pas besoin de convertisseur de niveau. Dans l'exemple ci-dessous, on branche un petit moteur 130 avec hélice sur le bornier MOTOR A. Avec un potentiomètre dont les extrémités sont reliées à 3V3 et GND et le curseur au GPIO 34, le ventilateur s'arrête au milieu ; en tournant dans un sens, il souffle de plus en plus fort, et dans l'autre, il aspire en sens inverse. La petite zone morte au milieu évite que les lectures instables du potentiomètre fassent sans cesse aller et venir le moteur. Le code sépare avec #if la différence LEDC entre l'ESP32 Arduino core 2.x et 3.x ; si tu veux utiliser aussi le canal B, tu peux ajouter les GPIO 32 et 33 de la même façon.
1// ESP32 + L9110S: potansiyometre ile fan hızı ve yönü / fan speed and direction with a potentiometer
2const int FAN_IA = 25; // Motor A girişi 1 / Motor A input 1
3const int FAN_IB = 26; // Motor A girişi 2 / Motor A input 2
4const int POT_PIN = 34; // Potansiyometre orta ucu (ADC1) / potentiometer wiper (ADC1)
5const int PWM_FREQ = 1000; // PWM frekansı (Hz) / PWM frequency (Hz)
6const int PWM_RES = 8; // 8 bit: 0-255 / 8 bit: 0-255
7const int DEAD_ZONE = 40; // ortadaki ölü bölge / dead zone around the middle
8
9void pwmBegin(int pin, int channel) {
10#if ESP_ARDUINO_VERSION_MAJOR >= 3
11 (void)channel; // 3.x kanalı kendisi seçer / 3.x picks the channel itself
12 ledcAttach(pin, PWM_FREQ, PWM_RES);
13#else
14 ledcSetup(channel, PWM_FREQ, PWM_RES); // 2.x: önce kanal ayarı / 2.x: set up the channel first
15 ledcAttachPin(pin, channel);
16#endif
17}
18
19void pwmSet(int pin, int channel, int duty) {
20#if ESP_ARDUINO_VERSION_MAJOR >= 3
21 (void)channel;
22 ledcWrite(pin, duty); // 3.x: pin numarasıyla / 3.x: by pin number
23#else
24 (void)pin;
25 ledcWrite(channel, duty); // 2.x: kanal numarasıyla / 2.x: by channel number
26#endif
27}
28
29void setFan(int speed) {
30 speed = constrain(speed, -255, 255);
31 if (speed >= 0) {
32 pwmSet(FAN_IA, 0, speed); // üfle / blow
33 pwmSet(FAN_IB, 1, 0);
34 } else {
35 pwmSet(FAN_IA, 0, 0); // ters yönde em / suck in reverse
36 pwmSet(FAN_IB, 1, -speed);
37 }
38}
39
40void setup() {
41 Serial.begin(115200);
42 analogReadResolution(12); // 0-4095
43 pwmBegin(FAN_IA, 0);
44 pwmBegin(FAN_IB, 1);
45 setFan(0);
46}
47
48void loop() {
49 int raw = analogRead(POT_PIN);
50 int speed = map(raw, 0, 4095, -255, 255);
51 if (abs(speed) < DEAD_ZONE) speed = 0; // ortada dur / stop in the middle
52 setFan(speed);
53 Serial.printf("ADC: %d Hiz/Speed: %d\n", raw, speed);
54 delay(50);
55}Raspberry Pi Pico et MicroPython avec le L9110S
Chaque broche GPIO du Pico peut générer du PWM matériel, tu es donc assez libre dans le choix des broches. Dans l'exemple, le moteur gauche est sur GP16 et GP17, et le droit sur GP18 et GP19. Le code définit chaque moteur comme une classe et prend la vitesse en pourcentage (de -100 à 100) ; tu n'as donc pas à gérer la plage 0–65535 de duty_u16. Alimente le Pico par USB et les moteurs par le pack de piles relié au VCC du module, et relie les deux GND. Quand tu arrêtes le programme avec Ctrl+C dans Thonny, le bloc KeyboardInterrupt arrête les moteurs en sécurité ; sans lui, le matériel PWM continue de tourner et ta voiture pourrait tomber de la table.
1from machine import Pin, PWM
2import time
3
4class Motor:
5 def __init__(self, pin_ia, pin_ib, freq=1000):
6 self.ia = PWM(Pin(pin_ia)) # IA girişi / IA input
7 self.ib = PWM(Pin(pin_ib)) # IB girişi / IB input
8 self.ia.freq(freq)
9 self.ib.freq(freq)
10 self.stop()
11
12 def speed(self, percent): # -100 geri ... 100 ileri / -100 reverse ... 100 forward
13 percent = max(-100, min(100, percent))
14 duty = int(abs(percent) * 65535 // 100)
15 if percent > 0:
16 self.ia.duty_u16(duty)
17 self.ib.duty_u16(0)
18 elif percent < 0:
19 self.ia.duty_u16(0)
20 self.ib.duty_u16(duty)
21 else:
22 self.stop()
23
24 def stop(self):
25 self.ia.duty_u16(0)
26 self.ib.duty_u16(0)
27
28left = Motor(16, 17) # A-IA = GP16, A-IB = GP17
29right = Motor(18, 19) # B-IA = GP18, B-IB = GP19
30
31def drive(l, r, ms):
32 left.speed(l)
33 right.speed(r)
34 time.sleep_ms(ms)
35
36try:
37 while True:
38 for s in range(30, 81, 5): # yumuşak kalkış / soft start
39 drive(s, s, 40)
40 drive(80, 80, 1500) # ileri / forward
41 drive(0, 0, 500)
42 drive(-60, -60, 1000) # geri / reverse
43 drive(0, 0, 500)
44 drive(-60, 60, 600) # yerinde sola dön / spin left in place
45 drive(0, 0, 2000)
46except KeyboardInterrupt:
47 left.stop() # Ctrl+C ile güvenli dur / safe stop on Ctrl+C
48 right.stop()L9110S ou L298N ? Lequel utiliser et quand ?
| Caractéristique | Module L9110S | Module L298N |
|---|---|---|
| Tension du moteur | 2,5 à 12 V | Environ 5 à 35 V |
| Courant par canal | Environ 800 mA en continu | Environ 2 A en continu |
| Chute de tension dans le driver | Faible | Environ 2 V et plus |
| Contrôle de la vitesse | PWM sur les broches IA/IB | PWM sur les broches ENA/ENB |
| Broches de commande nécessaires | 4 | 6 (4 avec les cavaliers) |
| Régulateur 5 V intégré | Non | Oui (jusqu'à 12 V d'alimentation) |
| Taille et poids | Très petit, quelques grammes | Grand, avec dissipateur |
| Logique 3,3 V | Compatible | Fonctionne en général |
En résumé, si tes moteurs sont sous 12 V et dépassent rarement 1 A chacun, même en blocage, le L9110S est le meilleur choix : il est plus petit, plus léger et ne gaspille pas les environ 2 V perdus dans les transistors bipolaires du L298N. Cette différence est très nette sur les projets à piles : avec un pack de 6 V, le L298N ne laisse qu'environ 4 V au moteur, alors que le L9110S transmet l'essentiel de l'alimentation et ta voiture va visiblement plus vite. En revanche, pour les moteurs 12 V à réducteur métallique, les châssis lourds, les charges continues supérieures à 1 A ou les alimentations au-dessus de 12 V, il te faut le L298N ou des drivers plus modernes à MOSFET. Pour une comparaison détaillée avec des alternatives comme le TB6612FNG, consulte l'article comparatif des drivers moteur.
Idées de projets avec le L9110S
- Mini voiture pilotée en Bluetooth : avec un module HC-05, appelle la fonction drive() selon les lettres reçues depuis le téléphone.
- Robot évitant les obstacles : ajoute un HC-SR04 à l'avant et fais reculer et tourner le robot devant un obstacle à moins de 20 cm ; détails dans l'article robot évitant les obstacles.
- Robot suiveur de ligne : suis la ligne noire avec deux capteurs TCRT5000 ; avec des moteurs N20 et le L9110S, tu obtiens un robot léger et agile.
- Ventilateur selon la température : augmente progressivement la vitesse du ventilateur par PWM selon la température mesurée ; tu trouveras la logique dans l'article contrôle de ventilateur avec Arduino.
- Conduite de char au joystick : convertis les axes X et Y d'un joystick en vitesses des moteurs gauche et droit.
- Voiture contrôlée en Wi-Fi : envoie des commandes de direction et de vitesse depuis les boutons d'une page web sur l'ESP32.
- Mini treuil ou ouvre-rideau : enroule une corde avec un moteur à réducteur ; arrête le moteur aux extrémités avec un interrupteur de fin de course.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Le moteur ne tourne pas du tout | Pas de GND commun ou VCC non alimenté | Relie le GND du module à celui de la carte, mesure VCC au multimètre |
| Le moteur ne tourne pas à basse vitesse, il ne fait que bourdonner | Le rapport cyclique est sous le seuil de démarrage du moteur | Monte la vitesse minimale vers 70–100 |
| L'Arduino redémarre quand le moteur démarre | Les moteurs sont alimentés par la même ligne 5V que la carte | Utilise une pile séparée pour les moteurs, ajoute un condensateur de 100 µF sur VCC |
| Tourne dans un sens mais pas dans l'autre | Une entrée est sur une broche sans PWM ou un fil fait mauvais contact | Branche les quatre entrées sur des broches PWM, vérifie les fils |
| La puce chauffe beaucoup | Le courant du moteur dépasse 800 mA ou le moteur est bloqué | Utilise un moteur plus petit, évite le blocage ou passe au L298N |
| Le réglage de vitesse fonctionne à l'envers | Une entrée à HIGH, l'autre en PWM | Mets l'entrée fixe à LOW ou retire la valeur de duty à 255 |
| Sur ESP32, le moteur tourne brièvement au démarrage | La broche choisie génère un signal au démarrage | Utilise des broches silencieuses au démarrage comme GPIO 25, 26, 32, 33 |
Le L9110S est un driver léger, bon marché et efficace pour les projets à piles avec de petits moteurs ; si tu connais ses limites et que tu l'associes au bon moteur, il fonctionne longtemps sans problème. Quand tu passeras à de plus gros moteurs, tu pourras garder la même logique de sens et de PWM avec le L298N. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets comme la voiture Bluetooth, le robot évitant les obstacles et le contrôle PWM par potentiomètre, et tu pourras y adapter facilement le branchement du L9110S décrit ici. Le guide construire une voiture robot avec Arduino t'aidera aussi à choisir le châssis, les roues et la pile.
Questions fréquentes
Quel courant supporte le L9110S ?
Le L9110S peut fournir environ 800 mA en continu par canal, avec un courant de pointe bref d'environ 1,5 A. Comme le module a deux puces, il pilote deux moteurs séparément avec cette limite. Pour une longue durée de vie, garde le courant continu sous 500 à 600 mA par moteur.
Peut-on piloter un moteur 12 V avec le L9110S ?
La tension d'alimentation maximale du module est de 12 V, donc un petit moteur 12 V peut en théorie être piloté. Mais la plupart des moteurs 12 V consomment bien plus de 1 A en blocage, et la puce chauffe à la limite. Pour les moteurs 12 V, un L298N ou un driver à MOSFET est plus sûr.
Le L9110S fonctionne-t-il avec ESP32 et 3,3 V ?
Oui. Les entrées du L9110S reconnaissent le niveau logique 3,3 V comme HIGH, tu peux donc le brancher directement à l'ESP32, au Raspberry Pi Pico et aux autres cartes 3,3 V. Il suffit d'alimenter les moteurs séparément sur VCC et de relier les GND.
Quel est le meilleur : L9110S ou L298N ?
Pour les projets à piles avec de petits moteurs, le L9110S est meilleur : plus petit, plus léger, et sans la chute d'environ 2 V du L298N. Si le courant du moteur dépasse 1 A ou si tu as besoin d'une alimentation au-dessus de 12 V, choisis le L298N.
Peut-on piloter un moteur pas à pas avec le L9110S ?
Oui, les deux ponts en H du module peuvent piloter les deux bobines d'un petit moteur pas à pas bipolaire (4 fils), et la bibliothèque Arduino Stepper fonctionne avec ce branchement. Le courant des bobines ne doit pas dépasser 800 mA. Pour les moteurs unipolaires à 5 fils comme le 28BYJ-48, la carte ULN2003 convient mieux.
Pourquoi le L9110S chauffe-t-il autant ?
La cause la plus fréquente est un moteur qui consomme un courant proche de la limite de la puce ; surtout les moteurs aux roues coincées ou qui portent une charge lourde approchent le courant de blocage. Une tension d'alimentation supérieure à la tension nominale du moteur augmente aussi le courant. Utilise un moteur plus petit, limite la vitesse maximale par PWM ou passe à un driver plus puissant.
Projets à réaliser après cet article
Voir tous les projets
Voiture contrôlée par Bluetooth avec L298N
Transforme ton téléphone en télécommande et pilote ta propre voiture robot. L'Arduino reçoit, via un module Bluetooth, les ordres d'une appli de télécommande sur ton téléphone et fait tourner les…

Robot évitant les obstacles
Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

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.

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.

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.

Servocommande avec joystick
Pilote deux moteurs avec un joystick, comme si tu orientais une caméra de surveillance.

Utilisation d'un servomoteur avec un potentiomètre
Quand tu tournes le bouton du potentiomètre, le bras du servomoteur tourne avec lui : un bout du bouton correspond à zéro degré, l'autre à un demi-tour.

Utilisation du moteur pas à pas
Un moteur qui tourne pas à pas, exactement autant que tu le veux, comme l'aiguille d'une horloge.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

