Module TB6612FNG : fonctionnement, branchement, et exemples de code pour Arduino et ESP32 (tutorial avec pilotage PWM)

Comme vous le savez certainement, piloter des moteurs électriques ne peut pas se faire directement depuis un microcontrôleur (du fait du peu de courant que ça peut sortir, mais pas que !). C’est pourquoi on a besoin d’une interface entre la partie commande (notre µC, carte Arduino, ou autre) et la partie puissance (nos moteurs électriques) ; et cette interface s’appelle un « driver ». Et comme vous pouvez vous en douter, des drivers il en existe de très nombreux modèles ! Aujourd’hui, nous allons voir ensemble le TB6612FNG, qui est un driver pour petits moteurs à courant continu (moteurs DC), parce qu’il est particulièrement efficace, et vraiment très populaire 🙂

Nous verrons ici comment le raccorder à une carte Arduino Uno ou ESP32, et comment le piloter, avec ou sans librairie arduino spécialisée ! Nous verrons également en quoi le driver TB6612 FNG (intégrant des transistors mosfets) est plus efficace que le driver L298N (à base de transistors bipolaires) que je vous avais présenté il y a quelque temps de cela, et les avantages et inconvénients de chacun. Ça vous dit ? Alors en avant !

Remarque : dans cet article, je vous présente le TB6612FNG sous forme modulaire (ce qu’on appelle une « breakout board »), afin qu’il n’y ait pas la moindre soudure à faire ici. Ainsi, on pourra câbler ce module TB6612 FNG avec de simples fils dupont, pour la démo, histoire de faire simple ! Bien entendu, ensuite, compte tenu des courants en jeu, il faudra proscrire ces petits fils dupont, et souder la puce ou embrocher le module directement sur vos PCB !

Module	Description	Lien
	Module TB6612FNG, monté sur PCB (double driver moteur)	Voir le prix

Principe de fonctionnement du TB6612FNG (driver moteur)

Le cœur du TB6612FNG repose sur ce que l’on appelle un pont en H (un ensemble de 4 interrupteurs électroniques, si vous voulez, disposés de manière à pouvoir alimenter et inverser la polarité de tout moteur électrique DC). Ces « interrupteurs électroniques » sont pilotés via des courants faibles (signaux logiques provenant d’un microcontrôleur, par exemple), et peuvent commuter de « très » forts courants (côté moteur). Et comme la puce TB6612 FNG contient non pas un pont en H mais deux, on peut piloter 2 moteurs DC avec 1 seul TB6612FNG.

En résumé, le principe de fonctionnement du TB6612 FNG repose donc sur 2 ponts en H, permettant de pouvoir contrôler la vitesse et le sens de rotation de 1 à 2 moteurs à courant continu (partie puissance), à partir de signaux logiques (partie commande).

Plus précisément, le TB6612FNG permet de :

• faire tourner des moteurs dans un sens
• faire tourner des moteur en sens inverse (sans toucher au câblage physique, j’entends)
• arrêter des moteur (en « roue libre », ou avec un « freinage actif », en court-circuitant les bobines moteurs)
• et contrôler leurs vitesses, à l’aide d’un signal PWM, et selon le rapport cyclique fourni (des impulsions tout-ou-rien, périodiques, plus ou moins longues, permettant d’obtenir une tension moyenne variable, comprise entre 0V et la tension maximale des moteurs DC)

Schématiquement parlant, voici à quoi ressemble un pont en H, avec ses différentes configurations possibles (nota : en pratique, sur le TB6612 FNG, chaque interrupteur correspond en fait à un transistor mosfet) :

On retrouve bien là les 4 modes de fonctionnement possible, au niveau de nos moteurs : être à l’arrêt (rotation libre, non freinée), tourner dans un sens, tourner dans l’autre sens, ou être à l’arrêt (en rotation freinée). On remarque que les interrupteurs électroniques (mosfets) sont en fait commandés par paires, en sens diamétralement opposé pour faire tourner les moteurs dans un sens ou dans l’autre.

Ces « interrupteurs électroniques » sont pilotés depuis l’extérieur du TB6612FNG, via des signaux logiques (lignes de commandes), émanant généralement d’un microcontrôleur (comme l’ATmega328P, intégré aux cartes Arduino Uno ou Nano, par exemple). Et comme la puce TB6612FNG intègre en réalité deux ponts en H indépendants en son sein, on a donc 2 groupes de 4 interrupteurs électroniques. Cela signifie qu’un seul circuit intégré TB6612 FNG peut piloter :

• deux moteurs à courant continu, indépendamment l’un de l’autre (c’est son usage le plus courant)
• ou un moteur pas à pas bipolaire (même si ce n’est pas idéal dans ce cas, où on préférera utiliser des A4988 ou DRV8825 par exemple, pour les piloter de manière plus adaptée)

Du reste, retenez bien ceci : les drivers moteurs, comme le TB6612FNG présenté ici, permettent de faire l’interface entre une « partie logique » (courant faible) et une « partie puissance » (courant fort), du fait que les µC ne sont pas conçus pour pouvoir alimenter des moteurs directement. Cela permet également de pouvoir travailler sur 2 tensions différentes, si souhaité (une tension de pilotage, côté µC, et une tension de puissance potentiellement différente, côté moteur). C’est pourquoi on trouve sur les drivers moteurs, à l’instar du TB 6612 FNG, des broches nommées « VCC » (pour l’alimentation logique du driver, la même que celle du microcontrôleur de pilotage), et « VM » (pour alimenter les moteurs, indépendamment de la partie commande).

Présentation du module TB6612 FNG

Passons à présent à des choses plus concrètes, et voyons en détail ce Driver Moteur TB6612FNG !

Puce seule vs module prêt à l’emploi ?

Pour commencer, il faut savoir que le TB6612FNG est un circuit intégré, développé par Toshiba. Il se présente sous la forme d’un petit boîtier CMS (package SSOP-24), et est destiné à être soudé directement sur PCB. Sous cette forme, il n’est pas possible de brancher des fils dupont dessus ! Et quant à souder des fils directement sur chaque patte du circuit intégré, ce serait mission impossible (du fait que l’entraxe des broches n’est que de 0,65 mm !).

C’est pourquoi on préférera des « modules prêts à l’emploi » pour faire des essais (des « breakout boards », comme on dit en anglais), qui sont ni plus ni moins que des « cartes d’adaptation », fournissant des broches (pin header) écartées au pas standard de 2,54 mm. Ainsi, on peut facilement brancher dessus des fils dupont, et relier ça à nos cartes Arduino, STM32, ESP32, ou autre 🙂

Qui plus est, ces modules sont souvent équipés de base avec quelques composants additionnels, tels que des condensateurs de filtrage et découplage, afin de pouvoir être utilisés directement, sans avoir à se creuser la tête.

Pour ceux qui se poseraient la question, voici à quoi ressemble la puce TB6612FNG seule (le circuit intégré CMS au format SSOP-24, donc), et un exemple de module prêt à l’emploi (mini plaquette PCB, compatible fils dupont et breadboards) :

Modèle	TB6612FNG « seul »	TB6612FNG « monté sur PCB »
Aperçu
Avantages	Très petit, facile à intégrer dans ses PCB « fait-maison »	Idéal pour les débutants, pour ne pas avoir à souder quoi que ce soit (à câbler via des fils dupont, ou à embrocher sur un connecteur femelle, type pinSocket), et intègre déjà les condensateurs de filtrage/découplage
Inconvénients	Broches difficiles à souder, car très rapprochées (entraxe = 0,65 mm)	Prend plus de place que la puce seule, à cause des larges connecteurs pinHeader de part et d’autre, au pas de 2,43 mm
Lien (description/prix)	Version « puce TB6612FNG »	Version « module TB6612FNG »

Remarque importante : n’en déduisez pas qu’un « module » est forcément mieux qu’un « circuit intégré », du fait qu’il est plus facilement raccordable, et déjà équipé de condos. Car tout dépend de l’utilisation qu’on en fait, en fait. Dit simplement, je dirais que les modules sont adaptés pour faire des essais à la volée ou sur breadboard, et pour être montés sur PCB si le circuit intégré est trop petit à souder par soi-même ; et les circuits intégrés achetés « nus » sont plus faciles à intégrer, avec des connections au final plus sûres que des pins header/socket, et une meilleure « maîtrise » des séparations de courant / plan de masse.

Nota : pour la suite de cet article, nous allons uniquement nous concentrer sur la version « module » du TB 6612 FNG, car c’est ce qui est le plus adapté pour ce tuto, pour faire des démos !

Description du module TB6612FNG

Comme vu juste avant, le module TB6612FNG se présente sous la forme d’un petit circuit imprimé (PCB) rectangulaire de couleur rouge, avec 2 rangées de picots (des pins headers), prévus pour être raccordés via fils dupont, emboîtés sur plaquette de prototypage (breadboard, en anglais), ou sur connecteurs femelles type pinSocket, sur son propre PCB.

Si je résume, cette mini plaquette PCB comporte donc :

• la puce TB6612FNG en elle-même, au centre du PCB
• les deux rangées de broches, au pas standard 2,54 mm (partie commande d’un côté, et partie puissance/alim de l’autre)
• et quelques composants CMS additionnels (généralement, des condensateurs, pour filtrer/stabiliser l’alimentation)

TB6612FNG pinout (breakout board)

Zoomons à présent sur ce module PCB, pour découvrir le brochage (pinout) du TB6612FNG, et sa sérigraphie (les « textes » écrits à même le circuit imprimé) :

Comme évoqué au début de ce tuto, la puce TB6612 FNG intègre en fait 2 ponts en H, ce qui lui permet de piloter jusqu’à 2 moteurs DC simultanément. C’est pourquoi, au niveau de la sérigraphie, on retrouve des lettres « A » (qui font référence au 1er moteur pilotable avec, nommé « Moteur A »), et des lettres « B » (faisant références au 2ème moteur pilotage avec le TB 6612 FNG, nommé « Moteur B »).

Au passage, j’insiste bien sur une chose : ce n’est pas parce que le TB6612 FNG peut alimenter jusqu’à 2 moteurs qu’il n’est pas capable ou fait pour alimenter un moteur unique (que vous pourrez brancher en « A » ou en « B », comme bon vous plaira !). Donc si vous avez 1 seul moteur à piloter, ou 2, le TB 6612FNG convient dans tous les cas 😉

Au niveau du brochage de ce module TB6612FNG (breakout board pinout, en anglais), on retrouve :

(*) Voir le tableau ci-après, pour bien comprendre comment les entrées xINy (AIN1, AIN2, BIN1, et BIN2) permettent de sélectionner le mode de fonctionnement des moteurs, branchés sur ce module TB 6612 FNG.

Remarque : ce brochage est donné à titre indicatif, à partir du modèle que j’avais sous la main. Dites vous que d’un fabricant à un autre, il peut parfois y avoir quelques variations ! Vérifiez donc toujours la correspondance avec la sérigraphie présente sur le PCB, et vos câblages !

Tension d’alimentation et courant max du TB6612FNG

Comme spécifié dans le datasheet du fabricant (section « Operating Range »), les plages de tensions d’alimentation du TB6612FNG sont les suivantes :

• la tension moteur (VM) doit être comprise entre 2,5V et 13,5V
• la tension de commande (Vcc) doit être comprise entre 2,7V et 5,5V

En sachant que le courant max « en continue » ne devra pas dépasser :

• 400 mA max par moteur, si Vm est inférieur à 4,5 volts
• ou 1A max par moteur, si Vm est supérieur à 4,5 volts

À noter que le constructeur indique qu’on peut monter jusqu’à 15 volts pour VM, et 6 volts pour Vcc, mais seulement de manière très ponctuelle (section « Absolute Maximum Ratings » du datasheet). De même au niveau du courant : on pourrait monter jusqu’à 1,2 A ponctuellement (en pic, donc), voire même 2A à 3,2A si le rapport cyclique est respectivement inférieur à 20 % (2A) et 10 % (3,2A). Là encore, ce sont des valeurs en pics, qu’il vaut mieux de ne pas maintenir trop longtemps, ni répéter trop souvent !

Du reste, pour vous rassurer, dites vous qu’une protection thermique intégrée à la puce TB 6612FNG vous protège contre certains excès (coupure si la puce atteint les 175°C, avec 20°C d’hystérésis, donc redémarrage à 155°C). Ainsi, si jamais vous tirez trop de courant, les sorties seront automatiquement/momentanément désactivées. Mais évitez d’aller jusqu’à ces extrêmes, car de tels niveaux de températures ne sont pas sans risques (y compris pour vous, si vous mettez le doigt dessus !). Dans tous les cas, réfléchissez bien avant de brancher quoi que ce soit, et restez extrêmement vigilant à ce que vous faites !

Tableau de sélection de mode de pilotage moteur (rotation avant / rotation arrière / arrêt / freinage)

Comme expliqué précédemment, le TB6612FNG peut piloter jusqu’à 2 moteurs simultanément ; ceux-ci sont notés :

• « Moteur A » (avec ses lignes de commande AIN1, AIN2, PWMA, et ses sorties AO1 et AO2)
• « Moteur B » (avec ses lignes de commande BIN1, BIN2, PWMB, et ses sorties BO1 et BO2)

Plus généralement, on parlera de lignes IN1, IN2, PWM, O1, et O2, en sachant qu’il faudra ajouter la lettre A ou B, selon si on s’intéresse spécifiquement au moteur A ou au moteur B.

Et pour rappel, comme évoqué tout en haut de cet article, chacun de ces moteurs (A ou B) peuvent être pilotés de 4 manières différentes (selon les 4 configurations possibles d’un pont en H). Du coup, voici donc la table de vérité correspondante à chaque moteur (A ou B) :

Dit autrement :

• si IN1=0 et IN2=0, alors la rotation du moteur est libre (sorties O1 et O2 en état de haute impédance)
• si IN1=1 et IN2=0, alors le moteur tourne dans un certain sens (en « marche avant », par exemple)
• si IN1=0 et IN2=1, alors le moteur tourne dans l’autre sens (en « marche arrière », par exemple)
• si IN1=1 et IN2=1, alors le moteur est en mode « freinage » (rotation freinée, par court-circuitage du bobinage moteur)

Remarque 1 : les moteurs vont tourner à un certain pourcentage de leur vitesse max (entre 0 et 100%), selon le rapport cyclique (entre 0 et 100%) du signal PWM envoyé. Ainsi : plus le rapport cyclique du signal PWM sera élevé, plus la tension moyenne du moteur sera élevée, et plus la vitesse de rotation sera rapide ; et vice-versa ! Enfin, pour ce soit bien clair : ce n’est pas la fréquence du signal PWM (fixe, typiquement 100 kHz) qui dit à quel vitesse doit tourner le moteur, mais bien le rapport cyclique (duty cycle) de ce signal PWM (le rapport cyclique étant le rapport entre la durée de l’impulsion à l’état haut, sur la durée d’une période complète).

Remarque 2 : si jamais un de vos moteurs moteurs (ou les deux !) ne tourne pas dans le bon sens, alors vous aurez 3 moyens de corriger ce problème :
– soit physiquement permuter les fils de puissance, côté moteur
– soit physiquement permuter les fils de commande IN1 et IN2, côté microcontrôleur
– soit logiciellement permuter les lignes IN1 et IN2, dans le code (c’est le plus simple, selon moi !)

TB6612FNG schematic diagram

Juste pour que vous ayez une idée de ce qu’intègre un module TB6612 FNG (breakout board, en anglais), voici un exemple de schéma électronique pour module TB 6612 FNG (schematic diagram, en anglais) :

En gros, on retrouve ce que je vous avais listé précédemment, à savoir :

• le circuit intégré TB6612 FNG en lui-même
• 2 rangées de 8 broches de connexion (pin headers)
• 2 condensateurs de découplage de 100 nF (un pour Vcc, et l’autre pour Vm)
• et 1 condensateur de filtrage de 10 µF (sur la ligne Vm)

Nota : qu’il n’y ait pas d’ambiguïtés ici ! Il s’agit là d’un exemple de schéma électronique de carte TB6612 FNG, et cela peut varier d’un fabricant à l’autre. Ne considérez donc pas cela comme universel, car c’est seulement une aide visuelle, vous montrant ce qui se fait usuellement, pour mieux comprendre de quoi sont généralement faits ces modules !

Module	Description	Lien
	Module TB6612FNG, monté sur PCB (double driver moteur)	Voir le prix

TB6612FNG vs L298N : lequel choisir ?

Lorsqu’on cherche à piloter des « petits moteurs DC » via microcontrôleur, deux modules viennent souvent à l’esprit : le L298N et le TB6612FNG. Nous allons donc voir ces 2 puces tour à tour, en examinant leurs avantages/atouts, et leurs faiblesses !

Les limites du L298N

Le driver L298N a très longtemps été populaire dans les projets DIY, pilotés par Arduino. Et ce, malgré le fait que cette puce soit relativement ancienne (conçue dans les années 1980). Pour ceux que ça intéresse, je vous avais fait un tuto sur les modules L298N ici (n’hésitez donc pas à y faire un saut, si vous souhaitez en savoir plus à son sujet !).

Basiquement, le L298N est éprouvé par les années, et donc fiable.

Mais le L298N a une faiblesse « majeure », d’un certain point de vue : il repose sur une technologie à transistors bipolaires. Du coup, cela induit des chutes de tensions non négligeables au niveau de ses transistors internes, suivant le courant passant au travers. Ainsi, la tension arrivant aux moteurs est parfois bien inférieure à la tension d’alim !

En pratique, d’ailleurs, il n’est pas rare d’avoir une chute de tension de près de 2 à 4 volts au niveau du L298N, lorsqu’on tire pas mal de courant dessus. Concrètement, par exemple :

• si vous alimentez la partie puissance en +6V, alors la tension arrivant réellement au moteur sera de 3 à 4 volts seulement
• si vous alimentez la partie puissance en +9V, alors la tension moteur ne sera que de 5 à 7 volts

Le rendement énergétique est donc plus ou moins médiocre, car cette chute de tension induit une perte de puissance, traduite sous forme de chaleur (qu’il faut dissiper, bien évidemment, et ce d’autant plus que le courant est fort). Au final, il faut donc quasiment toujours adjoindre un gros dissipateur thermique au L298N, pour évacuer cette « énergie gaspillée ». Et bien entendu, qui dit « gros dissipateur thermique », dit empiétement important sur nos circuits imprimés PCB (déjà que la puce en elle-même est « assez grosse », au format traversant, en boîtier « Multiwatt15 » !).

Les avantages du TB6612 FNG

De nos jours, on préférera des drivers moteurs comme le TB6612FNG, car ceux-ci fonctionnent avec des mosfets, et non des transistors bipolaires. Car la chute de tension au niveau des mosfets (drain/source) est bien moindre, grâce à une résistance interne plus faible (Rdson), comparé aux chutes de tension des transistors bipolaires (collecteur/émetteur). Et comme la chute de tension est plus faible, il y a moins de pertes énergétiques, donc caloriques (moins de chaleur perdue, à dissiper).

En clair : le TB6612FNG a un bien meilleur rendement que le L298N.

D’ailleurs, sauf cas particulier, on n’a pas spécialement besoin de dissipateur thermique, lorsqu’on utilise un TB6612 FNG (je dirais qu’on en a besoin lorsqu’on fonctionne soit en continu soit avec de forts pics de courant répétés, ou alors une carte électronique trop compacte, des plans de cuivres insuffisants, ou mal ventilée). Cela étant dit, si vous prenez le temps de bien faire votre conception, ça devrait aller 😉

On a donc moins d’encombrement, au final, avec un TB 6612 FNG, plutôt qu’un L298N (sans parler que le TB6612FNG est un circuit intégré de format compacte, au format CMS, avec un boîtier SSOP-24).

Un autre avantage du circuit intégré TB 6612 FNG par ailleurs, est qu’il peut être alimenté de 2,7V à 5,5V pour sa partie commande, là où le L298N n’acceptait que du 4,5V à 7V (ce qui posait notamment quelques complications avec les cartes ESP32 et STM32, par exemple, dont les microcontrôleurs fonctionnaient en 3,3 volts ; bien sûr, on peut toujours faire des adaptations, mais ce n’est pas pratique !).

Remarque : un dernier avantage, si je puis dire, en faveur du TB6612 FNG, est le fait qu’il accepte une fréquence de commutation (pilotage PWM) de 100 kHz, là où le L298N se « limitait » à du 25 kHz (40 kHz max). Même si toutes ces fréquences ne sont pas audibles (à l’oreille humaine, j’entends), travailler avec une fréquence de hachage plus haute permet d’avoir moins de vibrations audibles côté moteur. Cela dit, encore faut-il que votre µC puisse générer une telle fréquence PWM, bien évidemment (mais cela n’est pas forcément indispensable, dans les petits projets fait-maison DIY !).

Les inconvénients du TB6612FNG (il y en a, ne les cachons pas !)

Même si le TB6612FNG présente de nombreux avantages, il n’est pas forcément le meilleur choix dans toutes les situations. En effet, il a plusieurs choses à savoir au sujet du TB 6612FNG, lorsqu’on le compare au L298N :

• le courant moteur est limité à 1,2A en continu sur le TB6612FNG, là où le L298N accepte au moins 2A de manière continue (nota : en pointe ils se rejoignent, en quelque sorte, puisqu’ils acceptent tous deux jusqu’à 3A en pic)
• la tension moteur est limitée à la plage 2,5V à 13,5V sur le TB 6612FNG, là où le L298N accepte d’environ 5V à 46V (autant dire que le L298N peut monter bien plus haut en tension, côté moteur !).

Cela étant dit, pour la grande majorité des projets Arduino et robotique DIY, le TB6612FNG est très souvent un bien meilleur choix, vis à vis du L298N (pour les raisons évoquées précédemment, à savoir : encombrement de la puce, encombrement de l’éventuel dissipateur thermique, et perte de tension côté moteur). Et lorsque le TB6612 FNG ne suffit plus, on peut passer sur un driver DRV8871 (6,5V à 45V, jusqu’à 3,6 A, mono-canal) ou autre, toujours avec du pont en H à mosfets ! On peut donc à présent « abandonner » nos vieux driver à transistors bipolaires, comme le L298N, dès lors qu’on cherche à avoir quelque chose d’énergétiquement efficient !

Et bien sûr, sans trop vouloir me répéter : sans parler du fait que le TB6612 FNG est directement pilotable avec des microcontrôleurs 3,3V (comme on en trouve sur les cartes STM32, ESP32, etc), là où il fallait faire de l’adaptation avec le L298N (requérant du 4,5 à 7 volts !).

Module	Description	Lien
	Module TB6612FNG, monté sur PCB (double driver moteur)	Voir le prix

Branchement Module TB6612FNG ↔ Carte Arduino Uno

Basiquement, brancher un module TB6612FNG sur une carte Arduino Uno est on ne peut plus simple. Car il suffit pour cela de quelques fils dupont, et le tour est joué (j’entends par là qu’il n’y a pas besoin de composants additionnels, pour l’utiliser !).

Pour preuve, voici un exemple de câblage TB6612FNG Arduino Uno, permettant le pilotage de 2 moteurs (on aurait pu en mettre qu’un seul, pour rappel, mais là je voulais vous montrer un exemple de câblage « complet ») :

À noter que :

• il est impératif d’utiliser une alimentation externe pour alimenter les moteurs (car l’Arduino Uno n’est pas fait pour délivrer un tel courant, sans parler du parasitage que cela induirait au passage)
• on n’a pas besoin de mettre de résistance pull-down sur la ligne STBY, pour désactiver le module par défaut (indispensable le temps que l’Arduino Uno démarre), car celle-ci est déjà présente, et intégrée dans la puce TB6612FNG (pour info, cette ligne STBY ainsi que tous les autres lignes de commande PWMB, BIN2, BIN1, STBY, AIN1, AIN2, et PWMA, sont toutes équipées en interne d’une résistance pull-down de 200K environ, évitant ainsi tout démarrage aléatoire des moteurs, le temps que les lignes de commandes soient correctement initialisées)
• on aurait pu utiliser n’importe quelles autres broches arduino pour piloter le TB6612 FNG, du moment où on connecte bien les lignes « PWMA » et « PWMB » du module TB6612FNG à de « vraies » sorties PWM arduino (c’est à dire les pins D3, D5, D6, D9, D10, et D11 sur l’Arduino Uno, elles-seules pouvant nativement/matériellement sortir des signaux PWM ; sinon, il faudrait faire de l’émulation logicielle, mais là, ce serait bien plus complexe !)

Au final, j’ai donc opté pour le raccordement TB6612 FNG ↔ Arduino Uno suivant :

Du reste, tout est géré ensuite logiciellement, dans le code arduino !

Le saviez vous ? Le microcontrôleur équipant les cartes Arduino Uno est un µC ATmega328P. Mais il ne permet pas de générer des signaux PWM à 100 kHz nativement/matériellement, comme « préconisé » par le fabricant du TB 6612 FNG dans son datasheet. Toutefois, la fréquence des signaux pwm arduino (par défaut environ 500 ou 1000 Hz, suivant la sortie utilisée) est amplement suffisante pour l’application qu’on en fait ici, et pourrait être montée jusqu’à 62,5 kHz si souhaité, comme je vous l’avais détaillé dans le tableau des fréquences PWM possibles sur l’Arduino Uno.

Module	Description	Lien
	Module TB6612FNG, monté sur PCB (double driver moteur)	Voir le prix

Exemple de code #1 : pilotage de moteur DC avec Arduino + TB6612 FNG (via analogWrite)

À présent, voyons un premier exemple de code arduino, permettant de piloter des moteurs DC via le TB6612 FNG ! Ici, on va :

• faire tourner le 1er moteur (« A ») dans un sens, progressivement, de 0 à 100 % de sa vitesse nominale, puis l’arrêter 2 secondes après
• idem pour le 2ème moteur (« B »)
• faire tourner le 1er moteur (« A ») en sens inverse, progressivement, de 0 à 100 % de sa vitesse nominale, puis l’arrêter 2 secondes après
• idem pour le 2ème moteur (« B »)
• et reboucler à l’infini !

Pour ce faire, on va reprendre le schéma précédent (arduino uno + TB6612FNG), ce qui donne ceci, une fois câblé avec des fils dupont :

Remarque 1 : les couleurs de fils dupont ne correspondent pas forcément à celles présentées sur le schéma ; n’y prêtez donc pas attention ! Au final, seul compte quelle broche ira à telle ou telle autre broche, c’est tout !

Remarque 2 : et pour rappel, encore une fois : les fils dupont sont juste suffisants pour faire une démo, mais pas plus (du fait qu’ils sont trop petits en section) ; il conviendra donc de passer sur des fils de plus gros diamètres, ou souder le module TB 6612 FNG sur PCB, pour correctement laisser passer les courants moteurs !

Pour info, les petits moteurs DC choisis ici sont des petits moteurs TT jaunes arduino. Ceux-ci :

• s’alimentent avec une tension continue de 4 à 6 Vdc
• consomment, très approximativement (variable selon les modèles, et fabricants) :
  • environ 180 mA à vide
  • environ 300 mA en charge « normale » (poids d’un « petit » robot, par exemple)
  • environ 500 mA si la charge est « lourde » (poids important, friction élevée, ou autre)
  • environ 800 mA si démarrage « brusque »
  • et environ 1 à 2A si le rotor est bloqué

Nota : pour alimenter les moteurs (partie puissance de la carte TB 6612 FNG), j’ai opté pour du +5V (ceux-ci nécessitant une tension d’alimentation de 4V à 6V DC, pour rappel). Mais ce +5V ne provient pas de la carte arduino, j’insiste bien, car celle-ci n’est pas faite pour délivrer un tel courant, sans parler des perturbations que les bobinages moteurs induiraient au passage !

Voilà pour la partie matérielle ! À présent, passons à la partie logicielle, avec le détail du code arduino de ce premier exemple Arduino/TB6612FNG, ci-dessous :

// ===================================================================================================
//   ______               _                  _///_ _           _                   _
//  /   _  \             (_)                |  ___| |         | |                 (_)
//  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
//  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
//  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
//  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
//                                                                                      | |
//                                                                                      \_|
// ===================================================================================================
//
//  Projet  :       Exemple de code #1 : pilotage PWM de moteurs via Arduino Uno + module TB6612FNG
//  Fichier :       prg1-ArduinoUno-ModuleTB6612FNG-pilotage-PWM-moteurs.ino
//  Auteur  :       Jérôme TOMSKI
//  Créé le :       20.03.2026
//  Site    :       https://passionelectronique.fr/
//  GitHub  :       https://github.com/PassionElectronique/
//  Licence :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// ===================================================================================================
//
//  Remarques :
//    1)  Pas d'utilisation de librairie spécifique ici, afin de montrer comment piloter "manuellement" des moteurs en PWM, via le TB6612FNG
//    2)  Les broches arduino utilisées ici peuvent être changées, du moment où on garde bien des "vraies sorties PWM" pour piloter les lignes PWMA et PWMB du TB6612FNG
//
// ===================================================================================================

// Affectation des broches Arduino Uno, pour le pilotage du TB 6612 FNG
#define pin_PWMA  5    // La broche PWMA du module TB6612FNG sera reliée à la broche D5  de l'Arduino Uno (ligne PWM native/matérielle Arduino ? Oui !)
#define pin_AIN2  6    // La broche AIN2 du module TB6612FNG sera reliée à la broche D6  de l'Arduino Uno
#define pin_AIN1  7    // La broche AIN1 du module TB6612FNG sera reliée à la broche D7  de l'Arduino Uno
#define pin_STBY  8    // La broche STBY du module TB6612FNG sera reliée à la broche D8  de l'Arduino Uno
#define pin_BIN1  9    // La broche BIN1 du module TB6612FNG sera reliée à la broche D9  de l'Arduino Uno
#define pin_BIN2 10    // La broche BIN2 du module TB6612FNG sera reliée à la broche D10 de l'Arduino Uno
#define pin_PWMB 11    // La broche PWMB du module TB6612FNG sera reliée à la broche D11 de l'Arduino Uno (ligne PWM native/matérielle Arduino ? Oui !)


// ========================
// Initialisation programme
// ========================
void setup() {

  delay(1000);
  // ----------------------------------------------------------------------------
  // Configuration de toutes les broches Arduino en "sortie" et mise à "état bas"
  // ----------------------------------------------------------------------------
  pinMode(pin_STBY, OUTPUT);    digitalWrite(pin_STBY, LOW);
  pinMode(pin_AIN1, OUTPUT);    digitalWrite(pin_AIN1, LOW);
  pinMode(pin_AIN2, OUTPUT);    digitalWrite(pin_AIN2, LOW);
  pinMode(pin_BIN1, OUTPUT);    digitalWrite(pin_BIN1, LOW);
  pinMode(pin_BIN2, OUTPUT);    digitalWrite(pin_BIN2, LOW);
  pinMode(pin_PWMA, OUTPUT);    digitalWrite(pin_PWMA, LOW);
  pinMode(pin_PWMB, OUTPUT);    digitalWrite(pin_PWMB, LOW);

  // -----------------------
  // Activation du TB6612FNG
  // -----------------------
  digitalWrite(pin_STBY, HIGH);     // Mise à "l'état haut" de la ligne STBY, pour activer la puce TB6612 FNG

}


// =================
// Boucle principale
// =================
void loop() {

  // ----------------
  // Principe de base
  // ----------------
  // Pour faire passer la vitesse d'un moteur de 0 à 100%, on va simplement utiliser un signal PWM,
  // et faire varier son rapport cyclique de 0 à 100%. Pour ce faire, on utilisera la fonction
  // "analogWrite", sur une sortie spécifique PWM arduino ; à noter que cette fonction requiert
  // un argument compris entre 0 et 255 (0 correspondant à un rapport cyclique de 0%, et 255 à un
  // rapport cyclique de 100%). Juste pour info : le signal PWM aura une fréquence fixe (celle par défaut),
  // donc seul son rapport cyclique varie (faisant ainsi varier la tension moyenne, aux bornes des moteurs).


  // -----------------------------------------------------------|
  // |            Table de vérité pilotage moteurs              |
  // -----------------------------------------------------------|
  // | xIN1 | xIN2 | Mode                                       |
  // |----------------------------------------------------------|
  // | LOW  | LOW  | Arrêt            (rotation libre)          |
  // | LOW  | HIGH | Marche "arrière" (rotation sens "inverse") |
  // | HIGH | LOW  | Marche "avant"   (rotation sens "normal")  |
  // | HIGH | HIGH | Arrêt            (rotation freinée)        |
  // -----------------------------------------------------------|


  // -----------------------------------------------------------------------------------------------
  // Test partie 1/4 : passage progressif (de 0 à 100%) de la vitesse du moteur A, en "marche avant"
  // -----------------------------------------------------------------------------------------------
  digitalWrite(pin_AIN1, HIGH);     // MARCHE AVANT   (IN1 à l'état haut, et IN2 à l'état bas)
  digitalWrite(pin_AIN2, LOW);
  for(int i=0 ; i <= 255 ; i++) {
    analogWrite(pin_PWMA, i);
    delay(5);
  }
  delay(2000);                      // Laisser tourner "à fond" pendant 2 secondes de plus
  digitalWrite(pin_AIN1, HIGH);     // ARRÊT          (IN1 et IN2 à l'état haut)
  digitalWrite(pin_AIN2, HIGH);

  // -----------------------------------------------------------------------------------------------
  // Test partie 2/4 : passage progressif (de 0 à 100%) de la vitesse du moteur B, en "marche avant"
  // -----------------------------------------------------------------------------------------------
  digitalWrite(pin_BIN1, HIGH);     // MARCHE AVANT   (IN1 à l'état haut, et IN2 à l'état bas)
  digitalWrite(pin_BIN2, LOW);
  for(int i=0 ; i <= 255 ; i++) {
    analogWrite(pin_PWMB, i);
    delay(5);
  }
  delay(2000);                      // Laisser tourner "à fond" pendant 2 secondes de plus
  digitalWrite(pin_BIN1, HIGH);     // ARRÊT          (IN1 et IN2 à l'état haut)
  digitalWrite(pin_BIN2, HIGH);

  // -------------------------------------------------------------------------------------------------
  // Test partie 3/4 : passage progressif (de 0 à 100%) de la vitesse du moteur A, en "marche arrière"
  // -------------------------------------------------------------------------------------------------
  digitalWrite(pin_AIN1, LOW);      // MARCHE ARRIÈRE (IN1 à l'état bas, et IN2 à l'état haut)
  digitalWrite(pin_AIN2, HIGH);
  for(int i=0 ; i <= 255 ; i++) {
    analogWrite(pin_PWMA, i);
    delay(5);
  }
  delay(2000);                      // Laisser tourner "à fond" pendant 2 secondes de plus
  digitalWrite(pin_AIN1, HIGH);     // ARRÊT          (IN1 et IN2 à l'état haut)
  digitalWrite(pin_AIN2, HIGH);

  // -------------------------------------------------------------------------------------------------
  // Test partie 4/4 : passage progressif (de 0 à 100%) de la vitesse du moteur B, en "marche arrière"
  // -------------------------------------------------------------------------------------------------
  digitalWrite(pin_BIN1, LOW);      // MARCHE ARRIÈRE (IN1 à l'état bas, et IN2 à l'état haut)
  digitalWrite(pin_BIN2, HIGH);
  for(int i=0 ; i <= 255 ; i++) {
    analogWrite(pin_PWMB, i);
    delay(5);
  }
  delay(2000);                      // Laisser tourner "à fond" pendant 2 secondes de plus
  digitalWrite(pin_BIN1, HIGH);     // ARRÊT          (IN1 et IN2 à l'état haut)
  digitalWrite(pin_BIN2, HIGH);

}

Pour rappel :

• les lignes AIN1, AIN2, BIN1, et BIN2 permettent de définir la configuration du moteur visé (marche avant, marche arrière, rotation libre, ou rotation freinée, selon la table de vérité vue plus haut)
• les lignes PWMA et PWMB permettent de définir la vitesse de rotation des moteurs, selon le rapport cyclique des signaux PWM qu’on envoie sur ces lignes

C’est pourquoi, dans ce programme, on a :

• des commandes digitalWrite(broche_visée, état), qui permettent de définir les niveaux de sortie (état haut = +5V / état bas = GND) des lignes AIN1, AIN2, BIN1, BIN2, et STBY
• des commandes analogWrite(broche_visée, rapport_cyclique_voulu), qui permettent de générer un signal PWM persistant, avec un rapport cyclique donné (valeur comprise entre 0 et 255 inclus, pour un rapport cyclique allant de 0% à 100%)

Du reste, je n’ai pas optimisé le code, afin qu’il reste très visuel, et simple à comprendre (même si c’est « lourd » et répétitif, je vous l’accorde !).

Au niveau des essais, avec les moteurs tournant « dans le vide », aucun échauffement n’est apparu au niveau de la carte TB6612FNG. J’ai dû manuellement freiner les axes de moteurs à la main (via les roues), pour faire grimper le courant, et commencer à voir la puce TB6612 FNG s’échauffer, comme visible sur les 2 images thermiques ci-dessous (fonctionnement « à vide » à gauche, et « manuellement freiné » à droite) :

À noter que je n’ai pas fait la moindre mesure de courant ici, car ceux-ci ne signifieraient pas grand-chose, en l’état. En effet, les fils Dupont utilisés ici pour la démo ne sont pas faits pour véhiculer un tel courant (là, c’était juste pour vous montrer le principe de fonctionnement du driver TB6612FNG). En pratique, il faudra bien évidemment utiliser des fils de plus grosses sections, ou souder la puce ou le module TB6612 FNG sur un PCB !

Module	Description	Lien
	Module TB6612FNG, monté sur PCB (double driver moteur)	Voir le prix

Exemple de code #2 : pilotage de moteur DC avec ESP32 + TB6612FNG (via librairie spécialisée)

Maintenant, voyons un second exemple, qui utilise cette fois-ci :

• un ESP32 (à la place d’un Arduino Uno), pour vous montrer qu’on peut piloter un TB6612FNG avec du 3,3V (donc une tension différente de la partie « puissance moteur »)
• une librairie spécialisée, pour ne pas avoir à gérer individuellement chaque pin du module TB6612 FNG (j’entends par là les broches AIN1, AIN2, BIN1, BIN2, STBY, PWMA, et PWMB), et avoir des commandes logicielles plus claires (plus « parlantes », si je puis dire !)

Au niveau schéma de branchement, voici un exemple de raccordement d’une carte ESP32 ↔ module TB6612FNG (plus précisément, une carte ESP32-S3-DevKitC N16R8, pour la démo ici) :

Donc, nous aurons :

• une partie commande alimentée en 3,3V (provenant de l’ESP32, et entrant sur la broche Vcc du module TB 6612FNG)
• une partie puissance alimentée via une alim externe (du +5V en l’occurrence de mon côté, car la plage d’alimentation des petits moteurs jaunes TT arduino va de 4V à 6V, en courant continu)

Au niveau des branchements ESP32-S3 → TB6612 FNG, voici les broches utilisées ici (libre à vous de les changer, selon vos préférences, tout en gardant bien à l’esprit qu’il faudra également reporter ces modifications dans le code !) :

Au niveau logiciel, nous allons utiliser la librairie « TB6612 de chez SparkFun », car elle est :

• simple d’utilisation (idéal pour débuter)
• compatible Arduino et ESP32 (même si vous aurez un petit message d’alerte à la compilation), du fait que cette librairie utilise en arrière-plan que des « digitalWrite » et « analogWrite », pour ainsi dire !

Bien sur, là aussi, libre à vous d’utiliser une autre librairie ensuite si souhaité, ou de revenir à un « pilotage manuel », comme je vous avais montré dans l’exemple #1 ! Du reste, sans plus attendre, voici le code arduino de cet exemple ESP32 + TB6612FNG :

ATTENTION : pour cette partie, il y aura une librairie externe à télécharger/installer sur votre IDE Arduino. Tout est détaillé en début de code, ci-dessous. Dans tous les cas, n’oubliez pas de faire cela, sinon vous aurez une belle erreur à la compilation !

// ===================================================================================================
//   ______               _                  _///_ _           _                   _
//  /   _  \             (_)                |  ___| |         | |                 (_)
//  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
//  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
//  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
//  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
//                                                                                      | |
//                                                                                      \_|
// ===================================================================================================
//
//  Projet  :       Exemple de code #2 : pilotage PWM de moteurs via ESP32-S3-DevKitC + module TB6612FNG
//  Fichier :       prg2-ESP32S3-ModuleTB6612FNG-pilotage-moteurs-avec-librairie.ino
//  Auteur  :       Jérôme TOMSKI
//  Créé le :       27.03.2026
//  Site    :       https://passionelectronique.fr/
//  GitHub  :       https://github.com/PassionElectronique/
//  Licence :       https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr (BY-NC-ND 4.0 CC)
//
// ===================================================================================================
//
//  Remarques :
//    1)  La librairie "TB6612" de chez SparkFun qu'on va utiliser ici, n'est pas téléchargeable depuis le
//        "gestionnaire de bibliothèques" d'Arduino IDE. Il faudra donc l'installer manuellement ! Voici comment procéder :
//            - Allez sur la page GitHub de la librairie : https://github.com/sparkfun/SparkFun_TB6612FNG_Arduino_Library
//            - Sur la page GitHub, cliquez sur le bouton "Code" puis "Download ZIP", pour télécharger le fichier zip
//            - Une fois fait, allez sur Arduino IDE
//            - Sur Arduino IDE, cliquez dans le menu Sketch (croquis) → Include library (inclure une bibliothèque) → Add .ZIP library (ajouter la bibliothèque .ZIP)
//            - Sélectionnez votre fichier précédemment téléchargé (il doit s'appeller "SparkFun_TB6612FNG_Arduino_Library-master.zip", normalement)
//            - Et effacez le fichier précédemment téléchargé (car il ne sert plus à rien, du fait que Arduino IDE en a fait une copie, dans votre répertoire de librairies arduino !)
//    2)  Les broches ESP32 utilisées ici peuvent être changées, du moment où on n'empiète pas sur les broches "réservées" (USB, UART, BOOT, etc)
//
// ===================================================================================================

// Inclusion de la librairie dont nous aurons besoin ici
#include <SparkFun_TB6612.h>

// Affectation des broches ESP32-S3, pour le pilotage du TB 6612 FNG
#define pin_PWMA  5    // La broche PWMA du module TB6612FNG sera reliée à la broche GPIO5  de l'ESP32-S3-DevKitC
#define pin_AIN2  6    // La broche AIN2 du module TB6612FNG sera reliée à la broche GPIO6  de l'ESP32-S3-DevKitC
#define pin_AIN1  7    // La broche AIN1 du module TB6612FNG sera reliée à la broche GPIO7  de l'ESP32-S3-DevKitC
#define pin_STBY  8    // La broche STBY du module TB6612FNG sera reliée à la broche GPIO8  de l'ESP32-S3-DevKitC
#define pin_BIN1  9    // La broche BIN1 du module TB6612FNG sera reliée à la broche GPIO9  de l'ESP32-S3-DevKitC
#define pin_BIN2 10    // La broche BIN2 du module TB6612FNG sera reliée à la broche GPIO10 de l'ESP32-S3-DevKitC
#define pin_PWMB 11    // La broche PWMB du module TB6612FNG sera reliée à la broche GPIO11 de l'ESP32-S3-DevKitC

// Autres constantes
#define sens_de_rotation_normal_par_defaut    1
#define sens_de_rotation_inverse_par_defaut   -1

// Instanciation d'objets
Motor moteurA = Motor(pin_AIN1, pin_AIN2, pin_PWMA, sens_de_rotation_normal_par_defaut, pin_STBY);
Motor moteurB = Motor(pin_BIN1, pin_BIN2, pin_PWMB, sens_de_rotation_normal_par_defaut, pin_STBY);


// ========================
// Initialisation programme
// ========================
void setup() {

  // Petit délai avant de passer à la boucle loop !
  delay(1000);

}


// =================
// Boucle principale
// =================
void loop() {

  // --------------------------------------------
  // Fonctions utiles (librairie SparkFun_TB6612)
  // --------------------------------------------
  //
  //    moteur.drive(valeur)        → cela permet de fixer la vitesse du moteur, selon la "valeur" donnée (entre -255 et +255)
  //                                  - pour une "marche avant", la valeur doit être comprise entre 0 et 255 inclus (0 = "point mort" ; +255 = "marche avant à fond")
  //                                  - pour une "marche arrière", la valeur doit être comprise entre -255 et 0 inclus (-255 = "marche arrière à fond" ; 0 = "point mort")
  //
  //    moteur.drive(valeur, temps) → idem, mais fait tourner le moteur un temps donné, puis l'arrête
  //
  //    moteur.brake()              → permet d'arrêter le moteur (freinage fort / bobines courts-circuitées)
  //
  //    moteur.standby()            → permet de mettre en sommeil le module TB6612FNG (passage de la broche "STBY" à l'état bas, donc)
  //                                    (nota : pour sortir du "mode sommeil", il suffira tout simplement de faire appel à la fonction "drive" !)


  // ---------------------------------------------------------
  // Test partie 1/4 : rotation du moteur A, en "marche avant"
  // ---------------------------------------------------------
  // Démarrage progressif (de 0 à 100%) de la vitesse
  for(int i = 0; i <= 255; i++) {
    moteurA.drive(i);
    delay(5);
  }
  // Maintien pleine vitesse pendant 2 secondes
  delay(2000);
  // Freinage fort
  moteurA.brake();

  // ---------------------------------------------------------
  // Test partie 1/4 : rotation du moteur B, en "marche avant"
  // ---------------------------------------------------------
  // Démarrage progressif (de 0 à 100%) de la vitesse
  for(int i = 0; i <= 255; i++) {
    moteurB.drive(i);
    delay(5);
  }
  // Maintien pleine vitesse pendant 2 secondes
  delay(2000);
  // Freinage fort
  moteurB.brake();

  // -----------------------------------------------------------
  // Test partie 3/4 : rotation du moteur A, en "marche arrière"
  // -----------------------------------------------------------
  // Démarrage progressif (de 0 à 100%) de la vitesse
  for(int i = 0; i >= -255; i--) {
    moteurA.drive(i);
    delay(5);
  }
  // Maintien pleine vitesse pendant 2 secondes
  delay(2000);
  // Freinage fort
  moteurA.brake();

  // -----------------------------------------------------------
  // Test partie 4/4 : rotation du moteur B, en "marche arrière"
  // -----------------------------------------------------------
  // Démarrage progressif (de 0 à 100%) de la vitesse
  for(int i = 0; i >= -255; i--) {
    moteurB.drive(i);
    delay(5);
  }
  // Maintien pleine vitesse pendant 2 secondes
  delay(2000);
  // Freinage fort
  moteurB.brake();

}

Là encore, on aurait pu simplifier le code, pour que ce soit moins répétitif ; mais j’ai préféré vous montrer les choses simplement, plutôt que d’optimiser de suite et rendre la compréhension moins évidente !

À noter également qu’au moment de la compilation de ce programme, vous aurez certainement un message d’alerte en console, vous disant : « ATTENTION : la bibliothèque SparkFun_TB6612FNG_Arduino_Library-master prétend être exécutable sur la (ou les) architecture(s) avr et peut être incompatible avec votre carte actuelle qui s’exécute sur esp32.« . Ne vous inquiétez pas, car c’est juste un message d’alerte, et non un message d’erreur ! En fait, c’est juste dû au fait que cette librairie SparkFun a initialement été écrite pour arduino (microprocesseurs AVR), et que là, on s’en sert sur ESP32. Mais encore une fois : rassurez-vous, car tout va parfaitement bien fonctionner (du fait, qu’en arrière-plan, cette librairie n’utilise au final que des « digitalWrite » et « analogWrite », si je puis dire !).

Et juste pour vous montrer ce que donne le câblage ESP32 / TB6612FNG sur breadboard et fils dupont, voici quelques photos prises de mon côté, au moment des essais :

Si tout va bien, une fois le code uploadé et vos alims branchées, vous devriez voir les moteurs tourner l’un après l’autre, dans un sens puis dans l’autre !

Module	Description	Lien
	Module TB6612FNG, monté sur PCB (double driver moteur)	Voir le prix

FAQ rapide (TB6612 FNG)

Histoire d’être proactif, voici un ensemble de questions/réponses au sujet du TB6612FNG, pour vous aider si vous débutez 😉

Important : je pars de l’hypothèse où vous avez fourni :
→une alim correcte côté moteur (VM/GND), comprise entre 2,5 et 13,5 volts
→une alim correcte côté commande (VCC/GND), comprise entre 2,7 et 5,5 volts.

Pourquoi mon moteur ne tourne pas ?

Si votre moteur ne tourne pas, vérifiez que :

• la broche STBY est bien tirée au niveau haut (+Vcc), sans quoi le TB 6612FNG reste en sommeil !
• un signal PWM, avec un rapport cyclique suffisamment élevé pour faire tourner le moteur ; ce signal doit arriver sur la pin correspondante au moteur à piloter (PWMA pour le moteur A, et PWMB pour le moteur B)
• que les pins xIN1 et xIN2 présentent des niveaux autorisant la rotation du moteur (pour rappel : il faut que IN1=Vcc et IN2=GND pour aller en « marche avant », et que IN1=GND et IN2=Vcc pour aller en « marche arrière »)

Du reste, il peut arriver qu’une puce TB 6612 FNG devienne défaillante, en cas de choc électrostatique ou tension d’alim inappropriée, soumise par inadvertance !

Mon moteur tourne toujours à l’envers… que faire ?

Si votre moteur tourne systématiquement à l’envers (en « marche avant » quand vous souhaitez qu’il aille en « marche arrière », et vice-versa), vous avez 3 solutions pour solutionner ce problème :

• soit physiquement permuter vos fils moteurs (AO1/AO2 pour le moteur A, et BO1/BO2 pour le moteur B)
• soit physiquement permuter vos fils de commande (AIN1/AIN2 pour le moteur A, et BIN1/BIN2 pour le moteur B)
• soit logiciellement permuter la logique de commande (AIN1/AIN2 pour le moteur A, et BIN1/BIN2 pour le moteur B), dans le code

Perso, je trouve la solution logicielle la plus rapide à mettre en oeuvre, car y’a pas besoin de tournevis 😉

Est-ce normal que mon moteur n’arrive pas à se lancer, si le rapport cyclique est faible ?

Oui, c’est tout à fait normal ! En fait, en pratique, un moteur électrique a besoin d’un minimum de couple pour démarrer. Et le couple étant proportionnel au courant, il faut donc un minimum de courant pour lancer un moteur (donc une tension suffisante, donc un rapport cyclique suffisant). Dit autrement : si le rapport cyclique PWM est trop faible, alors la tension moyenne côté moteur sera trop basse, et par conséquent, le courant (donc le couple) sera également trop bas … faisant que le moteur n’arrive pas à se lancer (car insuffisant pour combattre les frottements, etc).

Il faut donc un minimum de couple (donc de courant, donc de tension, donc de rapport cyclique), pour que le moteur puisse commencer à tourner !

Par contre, d’un point de vue pratique, on ne peut pas donner de valeur précise, ici. Car cela dépend du couple, donc des caractéristiques de votre moteur et des forces exercées sur son axe. Cela étant dit, empiriquement, je vous dirais qu’il faut souvent un minimum d’environ 10% de rapport cyclique pour qu’un moteur commence à tourner, s’il ne force pas. Mais cela peut vite monter à 30 ou 40%, dès lors qu’on fait forcer un moteur (ce qui peut arriver souvent en robotique, ne serait-ce que dû au poids d’un robot en lui-même, par exemple !).

Au passage, lorsque le rapport cyclique est faible, il n’est pas rare également d’entendre un bruit aigu, émanant du moteur (que celui-ci ai commencé à tourner ou non). En fait, cela provient du fait que le moteur reçoit pas suffisamment de courant, pour entraîner une rotation continue du rotor. Il en résulte donc des micro-vibrations mécaniques, qui produisent ce « sifflement » audible, particulièrement désagréable, j’en conviens ! Mais ce bruit disparaît normalement lorsque le rapport cyclique devient « suffisant », pour que le moteur tourne de manière continue !

Liens et téléchargements

Pour ceux que ça intéresse, vous trouverez ci-après les programmes arduino complets de ce tuto TB6612 FNG, directement téléchargeables sur GitHub :

• L’ensemble des programmes de test TB6612FNG :
  • https://github.com/PassionElectronique/Programmes-tests-driver-TB6612FNG
• Et plus précisément :
  • Le programme #1 (Arduino Uno + TB6612FNG + fonction « analogWrite »)
  • Le programme #2 (ESP32-S3 + TB6612FNG + librairie « SparkFun »)

Et enfin, tout aussi important je dirais, le datasheet du TB6612FNG de chez Toshiba en lui-même, pour tout savoir sur ce driver moteur 😉

Module	Description	Lien
	Module TB6612FNG, monté sur PCB (double driver moteur)	Voir le prix

TB6612FNG arduino : conclusion !

Nous voici au terme de ce tutoriel sur le driver moteur TB6612FNG, piloté via Arduino ou ESP32 ! J’espère que tout ceci pourra vous servir, dans vos projets perso ou pro, et que vous pourrez plus facilement l’intégrer à vos prochains schémas électroniques, au besoin !

Il est l’heure pour moi de vous laisser, et de vous dire à bientôt, sur un prochain article !
Jérôme.

À découvrir aussi : le driver moteur L298N, pour les nostalgiques 😉

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 04/04/2026