Tutoriel L298N : fonctionnement, branchement module, et exemples de code arduino (avec pilotage PWM)

L298N arduino tutorial complet avec exemple de code arduino, et tuto branchement puis fonctionnement avec PWM pour moteur courant continu

Envie de contrôler la vitesse et le sens de rotation d’un moteur à courant continu ? Alors rien de tel que le L298N pour ce faire ! Car il permet de faire cela en toute simplicité, en s’interfaçant avec un Arduino, par exemple. Mais avant tout : connaissez-vous ses caractéristiques ? ses limites ? son fonctionnement interne ? Eh bien, c’est ce que nous allons voir ensemble !

Ce tuto a pour but de faire découvrir le L298N à tous les amateurs ou débutants en électronique, aussi bien d’un point de vue théorique, que pratique. Bien évidemment, libre à vous de parcourir ce tutoriel comme bon vous semble, en fonction de vos connaissances ! Du reste, n’hésitez pas à faire part de vos remarques et commentaires en bas de page, si besoin est 😉

Bonjour, et bienvenue sur le site Passion Electronique !

Survol rapide

La puce L298N est un circuit intégré de chez STMicroelectronics. Elle contient essentiellement :

  • 2 ponts en H, permettant de piloter chacun 1 moteur électrique DC (dans un sens, ou dans l’autre)
  • Et une logique de commande à « faible courant », pour piloter ces ponts à « fort courant »

En somme, le L298N est simplement un « double étage de puissance », permettant de commander directement deux moteurs électriques, via des commandes logiques « basse puissance ». C’est donc le genre de puce idéale pour s’interfacer avec un microcontrôleur, tel que l’ATmega328 équipant la plupart des Arduino. Ainsi, on peut aisément contrôler le sens et la vitesse de rotation de « gros » moteurs à courant continu, et ce, sans se forcer !

Le L298N requiert 2 alimentations distinctes pour fonctionner :

  • Une tension pour la partie puissance (nommée Vs), qui servira à alimenter les moteurs, au travers de transistors de puissance
  • Une tension pour la partie commande (nommée Vss), qui servira à alimenter toute la partie logique de commande, dont ces transistors de puissance

Au niveau logique de pilotage, on distingue :

  • Des broches d’activation des ponts (ENA et ENB), qui permettent de lancer ou arrêter les moteurs. À noter qu’on peut alimenter ces entrées en tout ou rien (alors les moteurs « tourneront » à fond), ou en PWM, pour contrôler leur vitesse de rotation.
  • Des broches de sélection des ponts (IN1, IN2, IN3, et IN4), qui permettent de sélectionner les sens de rotation des moteurs (et comme il y a deux moteurs pilotables ici, on retrouve 4 entrées, correspondant aux 4 possibilités de sens de rotation, à raison de 2 par moteurs).

À noter que le L298N se trouve principalement sous 2 formats, dans le commerce :

  • L298N nu (la puce électronique seule, à intégrer à ses montages)
  • L298N « tout équipé », équipé de diodes de protection moteur, dissipateur thermique, borniers à visser, … et bien d’autres choses encore !

Enfin, compte tenu de la puissance à dissiper dans certains cas, une étude thermique est souvent nécessaire, afin de savoir si on doit lui accoler un dissipateur ou pas ! Ne zappez jamais cette étape sous prétexte que c’est trop compliqué à déterminer, sinon, sa vie risque fort d’être écourtée précipitamment !

Au niveau du brochage du L298N (version verticale à 15 broches, ici), voici la définition de toutes ses broches :

L298N pinout brochage boitier vertical 15 pins, entrées sorties numérotées avec signification des broches, modèle multiwatt 15 à souder électronique

Le saviez-vous ? Le L298N est un double driver pour moteur à courant continu. Mais ce n’est pas parce qu’il permet de piloter 2 moteurs que vous devrez nécessairement en brancher deux dessus ! Car vous pouvez parfaitement en brancher qu’un seul, en vous servant de « la moitié » du L298N, en quelque sorte 😉

Principe de fonctionnement du L298N (pilotage PWM)

Pour comprendre le fonctionnement du L298N, il faut tout d’abord bien comprendre qu’il y a 2 aspects à considérer :

  • D’une part le fait qu’on peut faire tourner les moteurs dans un sens, ou dans l’autre (ce qui est permis par les « Ponts en H »)
  • Et d’autre part, le fait qu’on peut contrôler la vitesse de rotation d’un moteur, grâce à un signal PWM envoyé sur sa broche de commande

Ce sont ces 2 aspects qui font que le L298N peut à la fois contrôler le sens de rotation des moteurs, ET, faire varier leur vitesse. Nous allons donc les voir en détail, dès à présent.

Les « Ponts en H »

Les Ponts en H ne sont en fait qu’un nom donné à une configuration particulière, de composants électroniques. Classiquement, ceux-ci sont composés de 4 transistors, disposés d’une certaine manière, formant visuellement la lettre « H » (ou presque !). En voici un exemple, avec quatre transistors bipolaires, comme ceux qu’on trouve en interne, dans le L298N :

L298N schéma pont en H interne double, équivalent transistors bipolaires pilotant charge type moteur électrique en PWM, puce électronique

Le principe d’un pont en H est super simple : en activant les transistors deux par deux (ceux de sens opposés), on peut contrôler le sens du passage du courant dans la charge, branchée « au milieu du H ». Et c’est ce changement de sens de courant, qui permet aux moteurs à courant continu de pouvoir tourner « à l’endroit », ou « à l’envers ». Visuellement, voici comment cela se passe :

L298N pont en H double, configuration moteur marche avant ou marche arrière, avec inversion du sens du courant, rotation à l'endroit ou à l'envers

Comme vous le voyez, cette configuration à 4 transistors permet :

  • Dans le 1er cas : le « + » du moteur sur le « + » de l’alimentation, et le « – » du moteur sur le « – » de l’alimentation
  • Dans le 2ème cas : le « + » du moteur sur le « – » de l’alimentation, et le « – » du moteur sur le « + » de l’alimentation (faisant ainsi tourner le moteur en sens inverse)

En bref, en commandant simplement 2 des 4 transistors de manière symétrique, on peut facilement faire passer le courant dans un sens, ou bien dans l’autre. Et c’est d’ailleurs exactement le principe utilisé dans le L298N, pour faire changer le sens de rotation des moteurs électriques.

Remarque : le module L298N comporte 2 ponts en H, totalement indépendants. On peut utiliser un seul de ces ponts, si on le souhaite, tout comme les coupler ensemble, pour pouvoir délivrer deux fois plus de courant ! C’est d’ailleurs ce que nous verrons, vers la fin de cet article 😉

Le pilotage PWM

Seconde force du L298N : pouvoir être piloté via un signal à rapport cyclique variable (PWM), pour pouvoir faire varier la vitesse des moteurs. En fait, le principe est tout simple : la vitesse d’un moteur à courant continu est proportionnelle à sa tension d’alimentation, ou plus exactement, à sa tension moyenne. Ainsi, il suffit de faire varier la tension moyenne de l’alimentation fournie à un moteur, pour en faire varier sa vitesse de rotation selon ses désirs. Et pour faire varier une tension moyenne, rien de tel que la modulation en largeur d’impulsion (ou PWM, en anglais !).

En effet, en PWM, on génère un signal de fréquence fixe, et de rapport cyclique variable. Et mathématiquement, la tension moyenne sera tout simplement égale à la tension max, multipliée par ce rapport cyclique. Voici une représentation imagée, de ce principe :

Signaux PWM tension moyenne en fonction du rapport cyclique, schéma explication signal modulé, avec cycle de service 0% à 100% commande

Du coup, pour faire varier la vitesse d’un moteur DC, il suffit d’envoyer un signal PWM au L298N. Ainsi, chaque « pont en H » hachera la tension d’alimentation des moteurs à ce rythme, et la vitesse de rotation des moteurs sera parfaitement contrôlée.

Bien évidemment, comme le L298N possède 2 ponts en H, il faudra fournir deux signaux PWM, si vous souhaitez contrôler 2 moteurs électriques, indépendamment l’un de l’autre.

Le saviez-vous ? En pratique, on évitera de descendre trop bas au niveau du rapport cyclique des signaux PWM envoyés au L298N. Car les moteurs électriques requièrent une tension minimale « pour démarrer », sans quoi ils n’arriveraient pas à se lancer. D’ailleurs, lorsque cette tension est insuffisante, non seulement les moteurs ne tournent pas, mais qui plus est, un son aigu et strident se fait entendre à leur niveau, particulièrement désagréable à l’oreille ! C’est pourquoi il ne faudra pas descendre le rapport cyclique en deçà d’un certain seuil, assez facile à déterminer en pratique (car il suffit de brancher une alimentation variable sur son moteur, et voir à partir de quelle tension il arrivera à démarrer !).

Table de vérité du L298N (fonctionnement)

Le L298N possède plusieurs entrées logiques, qui sont :

  • ENA et ENB : pour respectivement activer ou désactiver les pont A et B (les deux ponts en H de notre L298N, constitués de 4 transistors bipolaires chacun)
  • IN1 et IN2 : pour définir le sens du courant en « sortie » du pont A (pour le 1er moteur, donc)
  • IN3 et IN4 : pour définir le sens du courant en « sortie » du pont B (pour le 2ème moteur, donc)

Ces entrées s’alimentent avec :

  • Une tension basse (0 volts, par exemple), pour signifier un état bas (un « 0 » logique, donc)
  • Une tension haute (+5 volts, par exemple), pour signifier un état haut (un « 1 » logique, donc)

Et suivant comment vous alimenterez chacune de ces 6 broches (à l’état bas, ou à l’état haut), le comportement des moteurs branchés sur le L298N sera modifié en conséquence. Voici d’ailleurs tous les cas possibles, pour le pont A (ENA/IN1/IN2) et le pont B (ENB/IN3/IN4) :

L298N table de vérité des entrées ENA ENB, et IN1 IN2 IN3 IN4, et sorties moteur marche avant, arrière, frein fort, ou roue libre, suivant configuration

Nota : si vous alimentez les entrées ENA et ENB avec une tension fixe, de 0 ou +5V, votre moteur sera respectivement à l’arrêt, ou tournant, à fond les gamelles ! Pour ralentir la vitesse de vos moteurs, il faudra non pas envoyer une « tension fixe » sur ces entrées ENA/ENB, mais plutôt un signal PWM. Ainsi, le courant sera haché de telle manière que la tension moyenne arrivant aux moteur sera plus faible. C’est ainsi qu’on peut prendre le contrôle effectif de la vitesse de rotation des moteurs !

Remarque : attention à ne pas trop abuser du « freinage fort », ou passer brutalement de la marche avant à la marche arrière (ou vice-versa). Sinon, les contraintes mécaniques seraient plus importantes qu’à la normale, et pourraient induire un vieillissement prématuré de vos moteurs, ainsi qu’un échauffement supplémentaire au niveau de bon nombre de composants (notamment au niveau des diodes de roue libre, mises en parallèle des bobinages moteurs). En bref, dans la mesure du possible, allez y en douceur 😉

Caractéristiques et spécifications (L298N datasheet)

Dans cette partie, nous allons voir une à une toutes les principales caractéristiques du L298N, résumées à partir du datasheet du L298N, fourni par le fabricant STMicroelectronics. Bien sûr, je vous invite à toujours vous référer au document constructeur, pour éviter toute surprise !

Alimentation « partie puissance » (broche Vs)

Comme vu en intro, le L298N nécessite deux alimentations pour fonctionner : une pour la partie puissance, et une autre pour la partie commande. Ici, nous allons nous intéresser à l’alim de « puissance », c’est-à-dire celle qui alimentera les moteurs. Celle-ci est notée « Vs » sur la documentation constructeur.

Sa valeur pratique est en fait à déterminer en fonction des moteurs que vous comptez alimenter. Par exemple : si vous cherchez à alimenter un moteur DC 12V, il faudra que cette alim soit d’au moins 14 volts. Car il faut prendre en compte la chute de tension engendrée par les ponts en H du L298N. À ce sujet, il faut savoir que la chute de tension de ces ponts en H peut aller de 1,8 à 4,9 volts, dans le pire des cas (si vous essayez de tirer l’intensité maximale). Donc attention à ne pas sous-alimenter vos moteurs !

[Extrait datasheet] La tension d’alimentation de puissance Vs devra être comprise entre 5 et 46 volts

À noter que vous pouvez monter jusqu’à 50V pour cette tension Vs, si besoin est, mais pour un très court instant (car ceci correspondant à la valeur « absolue » indiquée par le fabricant, donc à « n’exercer » que très ponctuellement).

Nota : il faut savoir que la tension minimale de Vs est également fonction de la tension que vous envoyez sur les entrées de sélection des ponts (IN1, IN2, IN3, et IN4). En effet, selon la documentation constructeur, il faudra que la tension d’alim Vs soit à minima égale à la tension que vous envoyez sur les entrées INx + 2,5 volts. En clair : si vous pilotez votre L298N avec du 0/5V, il faudra alimenter la partie puissance avec une tension Vs de 7,5 volts minimum !

Alimentation « partie commande » (broche Vss)

C’est la seconde alim à fournir au L298N, pour alimenter non pas les moteurs cette fois-ci, mais plutôt la logique de commande, interne à ce circuit intégré. Car les transistors de puissances sont commandés via un dispositif logique interne, nécessitant une alimentation plus basse. Cette tension est notée « Vss » par le fabricant.

[Extrait datasheet] La tension de commande Vss devra être comprise entre 4,5 et 7 volts (et typiquement : 5 volts)

En pratique, on évitera d’alimenter en permanence le L298N en 7 volts, pour ne pas écourter sa durée de vie. Car c’est ici sa tension maximale admissible (« Absolute Rating »), qu’il ne faut pas maintenir longtemps. On préférera donc une alimentation stabilisée à 5V, plutôt qu’autre chose.

Remarque : il ne faut pas confondre cette alimentation « secondaire » du L298N, indispensable pour faire fonctionner les circuits internes du L298N, avec la tension à fournir sur ses « entrées de commande ». Car, par exemple, on pourrait fort bien avoir :
– une alimentation de puissance à 30 volts (Vs) ;
– une alimentation partie commande à 5 volts (Vss) :
– et des tensions de commande à 3,3 volts (sur les entrées ENA, ENB, IN1, IN2, IN3, ou IN4).

Donc attention à ne pas vous mélanger les pinceaux ici, et considérez chaque chose indépendamment du reste, pour cette partie !

Courant de sortie (broches Out1, Out2, Out3, et Out4)

Avant toute chose, il faut savoir que les « pont en H » du L298N peuvent être utilisés de 2 différentes manières :

  • Soit séparément : dans ce cas, les 2 ponts sont prévus pour alimenter 1 moteur chacun, indépendamment l’un de l’autre
  • Soit couplés : dans ce cas, les 2 ponts sont jumelés ensemble, et agissent de concert. Ainsi, leur puissance de sortie est doublée. Par contre, on ne peut plus brancher qu’un seul moteur, car les ponts couplés ne font plus qu’un, au final.

[Extrait datasheet] Pris séparément, chaque pont peut délivrer jusqu’à 2 ampères en continu.
En mode couplé, on peut donc atteindre les 4A, pour ne piloter plus qu’un seul moteur avec le L298N.

À noter que si vous pilotez votre module L298N en PWM, alors vous pourrez monter à 2,5 ampères par pont, si vous ne dépassez pas un rapport cyclique de 80%. Cela nous ramène à nos 2 ampères précédents, puisque 2,5 * 80% = 2. Par contre, le constructeur impose une durée maximale, pour l’impulsion « haute ». En effet, celle-ci ne doit pas dépasser 10 ms. Donc, en résumé : pour pouvoir atteindre les 2,5 ampères, il faudra une fréquence de pilotage PWM de 80 Hz maximum, avec un rapport cyclique de 80%. Ce qui nous donne bien un « temps haut » de (1/80)*0.8, soit 10ms, et un « temps bas » de (1/80)*0.2, soit 2,5ms.

Nota : quelle que soit l’intensité consommée par vos moteurs, vous devrez absolument vous assurer que le L298N puisse bien dissiper la chaleur générée à son niveau, pour le pilotage de ce courant. Car ne vous y trompez pas : étant constitué de transistors bipolaires pour la partie puissance, le L298N va fortement chauffer, si vous lui en demandez beaucoup ! Du coup, attention à ne pas le griller, faute d’une dissipation thermique absente, ou inadaptée !

Tension de pilotage des ponts (broches ENA, ENB, IN1, IN2, IN3, et IN4)

Les ponts en H du L298N sont pilotés via :

  • Les entrées ENA et ENB, pour activer/désactiver les ponts (avec une tension continue, ou un signal PWM)
  • Les entrées IN1, IN2, IN3, et IN4, pour choisir le sens de passage du courant, dans les moteurs

Au niveau de la tension applicable sur ces broches, celle-ci doit être comprise :

  • Entre -0,3 et 1,5 volts, pour un état bas (équivalent à l’envoi d’un « 0 » logique)
  • Entre 2,3 et Vss, pour un état haut (équivalent à l’envoi d’un « 1 » logique)

Pour rappel : « Vss » est la tension d’alimentation de la partie commande du L298N, vu précédemment. Cette tension est comprise entre 4,5 et 7 volts (et typiquement : 5V).

Remarque : vu qu’un état logique haut doit être compris entre 2,3 et 7 volts, on peut très facilement piloter le L298N avec un Arduino, fonctionnant en 3,3V ou en 5V ! C’est d’ailleurs ce que je vous proposerai de faire ensuite, un peu plus bas 😉

Tension de saturation des ponts (chutes de tension occasionnées par les transistors du L298N)

Eh oui… le L298N n’est pas parfait ! Et loin de là même. D’ailleurs, vous devriez fortement vous intéresser à ce qui va suivre, pour ne pas être surpris de voir à quel point la tension arrivant à vos moteurs puisse être inférieure à celle de votre alimentation de puissance !

En effet, le « problème » du L298N est qu’il est fait de transistors bipolaires, dont les jonctions collecteur-émetteur créent parfois d’importantes chutes de tension. D’ailleurs, ceci explique parfaitement pourquoi on peut très bien alimenter son L298N avec du 12V sur la partie puissance, et se retrouver avec seulement 7V, par exemple, au niveau des moteurs. Car les transistors des ponts en H induisent une chute de tension (qui plus est doublée, comme ils fonctionne par paires), qui diminuent d’autant la tension disponible au final pour les moteurs.

Voici d’ailleurs un graphe, fourni par le fabricant STMicroelectronics, montrant l’évolution de la chute de tension de ces transistors, en fonction du courant de sortie :

L298N graphe chute de tension Vcesat, en fonction du courant consommé par moteur, extrait datasheet, partie pont en H à transistors bipolaires

Mais comme dit précédemment, un pont en H nécessite 2 transistors « allumés » en même temps. La perte de tension visible sur le graphe ci-dessus est donc à doubler. D’ailleurs, voici ce qui est communiqué par le constructeur, concernant cette chute de tension totale, par pont, en fonction du courant soutiré :

L298N tableau chutes de tension pont en H, en fonction du courant consommé en sortie, mesures Vcesat de 1,8 à 4,9V de pertes en tension moteur

On constate donc qu’aux extrêmes, la chute de tension totale, pour alimenter un moteur en courant continu, va être comprise entre 1,8 et 4,9 volts. Et bien évidemment, ce n’est pas du tout négligeable ! Donc gare à ne pas sous-alimenter vos moteurs 😉

Nota : bien évidemment, qui dit chute de tension et courant importants, dit échauffement important. Du coup, la puissance à dissiper au niveau du L298N (égale au produit de cette chute de tension par le courant qui la traverse) peut rapidement devenir supérieure à ce que le L298N peut dissiper à lui seul, sans dissipateur thermique. N’oubliez donc jamais de faire des calculs thermiques, et d’équiper votre L298N en conséquence, sinon gare aux claquages !

Tension de mesure de courant (broches Vsensor)

Vous l’avez peut-être certainement déjà remarqué : le L298N possède des sorties Vsensor, permettant de mesurer le courant traversant les moteurs branchés dessus. Mais avant d’aller plus loin, il y a une chose à bien comprendre ici. Car vous avez le choix entre :

  • Soit vous branchez une résistance sur Vsensor, pour y mesurer une chute de tension, vous donnant ainsi par calcul la valeur du courant alimentant votre moteur
  • Soit vous branchez directement la sortie Vsensor à la masse, sans aucune résistance, si vous ne vous intéressez absolument pas à cette valeur de courant

Cette deuxième façon de faire est certainement la plus courante, lorsqu’on veut simplement faire tourner des moteurs, sans rétrocontrôle. C’est pourquoi la plupart des montages que vous verrez ont leurs sorties Vsensor reliées à la masse. Mais il y a d’ailleurs une deuxième raison à cela : une résistance de puissance, mise à ce niveau, engendre des pertes supplémentaires, qu’il faudra inévitablement gérer, d’une manière ou d’une autre (car oui, celle-ci va chauffer également, et pas qu’un peu, à fort courant !).

Cela étant dit, il peut être intéressant d’effectuer une mesure du courant qui alimente les moteurs. Mais attention, car vous ne pourrez pas mettre n’importe quelle valeur de résistance. Car, selon le fabricant, la chute de tension engendrée par une résistance branchée sur Vsensor doit être inférieure à 2 volts, en continu (ou 2,3 volts, en pointe).

Du coup, pour savoir quelle valeur maximale de résistance on peut mettre sur Vsensor, il faut appliquer la loi d’ohm. Par exemple : si vous avez un courant continu de 1,5 ampères, et une tension Vsensor max de 2 volts, alors R = U / i = 2 / 1,5 = 1,33 ohms (au maximum). Ainsi, il vous suffira de prendre une valeur inférieure (par exemple 1 ohm), et le tour est joué !

Attention : il y a une chose à surtout pas oublier ici. Il s’agit de la puissance dissipée par cette résistance branchée sur Vsensor, sous l’effet du fort courant qui va y passer. En effet, on ne pourra pas mettre une simple résistance « classique » de 1/4 de watt, comme on en voit couramment en électronique. Car la puissance à dissiper étant égale au produit du courant qui la traverse par la chute de tension qu’elle engendre, peut être particulièrement élevée. Par exemple, en prenant le cas cité précédemment (résistance de 1 ohm et un courant de 1,5A), la puissance à dissiper sera égale à P = R * i² = 1 ohm * (1,5A)² = 2,25 watts. Dans ce cas, il faudra prendre une résistance de puissance supérieure à ces 2,25 watts, pour assurer une parfaite dissipation thermique, induite par le passage de ce courant. Dans tous les cas, n’oubliez jamais de calculer la puissance à dissiper par vos composants, et de les comparer aux puissances effectivement dissipables, par ceux-ci.

Fréquence de commutation, des ponts en H du L298N

Chose souvent occultée, il faut savoir qu’on ne peut pas piloter un pont à H à n’importe quelle « vitesse ». En effet, dans le cas du L298N, le constructeur spécifie des fréquences de commutation maximales à ne pas dépasser.

[Extrait datasheet] Le L298N ne devra pas être piloté en PWM avec une fréquence supérieure à 40 kHz.
Classiquement, on utilise une fréquence de commutation de 25 kHz.

Bien évidemment, il ne s’agit là que de valeurs conseillées ou maximales. Du coup, rien ne vous empêche de fonctionner à 100 Hz, si le coeur vous en dit !

Le saviez-vous ? l’oreille humaine « entend » de 20 Hz à 20 kHz, environ. C’est pourquoi, en électronique, on utilise des fréquences de découpage supérieures à 20 kHz (comme les 25 kHz préconisés ci-dessus, avec le L298N), afin de ne rien entendre. Car oui, ces fréquences de fonctionnement peuvent être audibles. On le constate d’ailleurs fréquemment avec les petites alimentations à découpage « bon marché », qui ne « montent » pas très haut en fréquence.

Capacités thermiques du L298N

Lorsqu’on utilise un L298N, il y a plusieurs choses en prendre en compte. Et les caractéristiques thermiques de celui-ci en fonctionnement, sont toutes aussi importantes que les autres. Car oui, ce composant chauffe tout particulièrement, du fait qu’il peut admettre de « forts » courants, et que sa technologie est basée sur des transistors bipolaires (et non des MOSFET, par exemple).

Parmi les principales caractéristiques thermiques du L298N, on retrouve :

  • Sa température de stockage (composant non alimenté, au repos total) : de -40 à +150 °C
  • Sa température de fonctionnement (t° ambiante à son niveau, en fait) : de -25 à +130 °C
  • Sa température de jonction maximale (Tj) : valant 150 °C
  • Son pouvoir de dissipation maximal : 25 W, pour une température de boîtier à 75 °C (cette puissance correspond essentiellement à la somme des pertes de puissance au niveau des transistors de puissance, internes au L298N, qu’il peut supporter)
  • Rth(jonction-ambiant) : 35 °C / W (c’est la résistance thermique du L298N utilisé « seul », c’est-à-dire sans radiateur de refroidissement)
  • Rth(jonction-boitier) : 3 °C / W (c’est la résistance thermique du L298N « seul », lorsqu’utilisé en association avec un dissipateur thermique ; la résistance totale sera alors égale à la somme de cette valeur, plus celle de la pâte thermique, plus celle du dissipateur thermique, plus celle de tout autre élément mis entre les deux)

Bien entendu, vous devrez toujours calculer (ou tout du moins estimer) cette puissance à dissiper, et la comparer à la puissance dissipable par le L298N. Si nécessaire, vous devrez également calculer la résistance thermique nécessaire pour assurer un bon fonctionnement (ou un bon refroidissement thermique, si vous préférez !).

Un exemple, pour la forme :

  • Si vous utilisez un L298N pour alimenter un moteur en courant continu (on utilise donc qu’un seul des ponts)
  • Si le courant consommé est de 2A
  • Si la tension d’alimentation de puissance est de 28V
  • Si la température qu’on ne souhaite pas dépasser au niveau de notre L298N est de 55 °C (choisi arbitrairement)
  • Et comme la température de jonction du L298N est de 150 °C

Alors :

  • La chute de tension au niveau du L298N sera de 4 volts environ (estimé à partir du graphique vu un peu plus haut, avec Vcesat en fonction du courant de sortie)
  • La puissance dissipée par le L298N sera égale à : Pdis = Vcesat * i = 4V * 2A = 8 W
  • La résistance thermique nécessaire sera de : Rth = (Tj – Ta) / Pdis = (150°C – 55°C) / 8W = 11,875 °C / W

Dans cet exemple, on voit qu’il nous faudrait une résistance thermique de 11,875 °C / W maximum, pour être sûr que notre L298N ne chauffe pas à plus de 55°C au niveau de son boitier, en fonctionnement. Mais comme celui-ci a une résistance thermique de 35 °C / W, si équipé d’aucun dissipateur thermique, il faudra donc bel et bien rajouter un dispositif de dissipation thermique de la chaleur. Du coup, calculons la valeur de ce radiateur à prévoir. Pour ce faire, considérons les valeurs suivantes :

  • La résistance Rthcase du L298N, faisant 3 °C / W
  • La pâte thermique (ou « feuille » s’intercalant entre un composant à refroidir, et son dissipateur), faisant 0,5 °C / W
  • Et notre précédent résultat de résistance thermique max, de 11,875 °C

Alors, la valeur de la résistance thermique du radiateur à mettre en place sur ce L298N, pour le refroidir, est de :

Rrad = Rth – Rthcas – Rthpâte = 11,875 – 3 – 0,5 = 8,375 °C / W

En conclusion : il faudra que vous accoliez au L298N un dissipateur thermique ayant une résistance Rth inférieure ou égale 8,375 °C/W, pour refroidir correctement ce circuit intégré.

Module L298N (carte PCB toute assemblée) : comment le brancher à l’Arduino ?

Maintenant que nous avons vu la puce L298N en détail, il faut savoir que celle-ci est très souvent vendue « toute équipée », sous forme de mini plaquette électronique. C’est-à-dire, avec borniers, condensateurs de découplage, diodes de protection, et régulateur de tension embarqué. Voici à quoi cela ressemble, la plupart du temps :

Module L298N tout équipé, prêt à l'emploi, plaquette PCB avec diodes de protection enroulements moteurs, borniers, et condensateurs de filtrage

En sommes, nous avons ici un module « prêt à l’emploi », doté de tout le minimum nécessaire pour bien fonctionner, et facilement s’interfacer avec des interfaces de commande, tels que l’Arduino. D’ailleurs, voici le détail de toutes les entrées/sorties de cette plaquette électronique :

Module L298N pinout descriptif, avec détail des bornes et composants électroniques sur plaquette pcb, repérage entrées et sorties sur circuit imprimé

À présent, voyons à quoi chacune de ces broches correspondent :

  • Borne « +12V » : il s’agit en fait de l’alim de puissance du L298N. Cette tension devra être comprise entre 5 et 35 volts, comme indiqué par la plupart des fabricants de ces modules, bien que le L298N en lui-même, supporte jusqu’à 46 volts. Toutefois, je vous recommande de ne jamais dépasser 35 volts, et même de rester bien en dessous, à 30V maxi par exemple. Car si vous jetez un œil sur la carte présentée en photo ci-dessus, vous verrez que le condensateur de filtrage de cette alim admet une tension maximale de 35V. Donc autant se prendre une petite marge de sécurité, afin d’éviter tout claquage de condensateur !
  • Borne « +5V » : il s’agit là d’une broche pouvant, selon les cas, soit être une entrée, soit une sortie. En effet :
    • Cette borne sera équivalente à une entrée, si le jumper d’alim (cavalier « JMP1 », visible ci-dessus) est retiré. Il faudra alors envoyer de 5 à 7 volts sur cette borne, afin de permettre l’alimentation de la partie « commande » du L298N.
    • Cette borne sera équivalente à une sortie fixe +5V, si le cavalier d’alim (jumper « JMP1 ») est mis en place. Celle-ci peut servir, dans certains cas, d’alimentation pour des appareils fonctionnant en 5 volts, branchés dessus (comme un Arduino, ou autre). Par contre, cette possibilité n’est valable que si la tension d’alimentation de puissance n’excède pas 12V. Sinon, le régulateur de tension embarqué pourrait griller, du fait de la trop grande différence de potentiel, entre la tension qu’il reçoit, et la tension qu’il doit fournir.
  • Borne « GND » : c’est la masse commune (0 volt) aux deux alimentations vues précédemment (alim de puissance et alim de commande)
  • Bornes « OUT1 » et « OUT2 » : c’est ici que devra se brancher le 1er moteur
  • Bornes « OUT3 » et « OUT4 » : c’est ici que viendra se brancher le 2nd moteur, ou rien du tout, s’il n’y a qu’un seul moteur à piloter, via les sorties OUT1/OUT2
  • Bornes « ENA » et « ENB » : celles-ci commandent respectivement la mise sous tensions du 1er et 2ème moteur, via le pilotage respectif des ponts A et B (montages en H, internes au L298N)
  • Bornes « IN1 » et « IN2 » : ces entrées permettent de définir le sens de rotation du 1er moteur (selon table de vérité vue plus haut)
  • Bornes « IN3 » et « IN4 » : ces entrées permettent de définir le sens de rotation du 2ème moteur (voir table de vérité vue plus haut)

À noter que vous verrez également certains cavaliers (jumpers) présents sur cette plaquette électronique, pour court-circuiter (shunter) certaines choses. Ceci vous permettre de :

  • Faire le choix d’un « +5V » interne ou externe. Comme vu précédemment :
    • Si le cavalier JMP1 est présent : alors la borne +5V est une sortie fournissant 5 volts (dont vous pourrez vous servir pour alimenter d’autres choses avec, comme un Arduino ou autre)
    • Si le cavalier JMP1 est absent : alors la borne +5V est une entrée, où il faudra envoyer une tension continue, entre 5 et 7 volts (de préférence égale à +5V)
  • Faire le choix d’un « ENA » et « ENB » pour une vitesse fixe et maximale, ou d’une vitesse variable à souhait (via l’envoi d’un signal PWM sur ces broches) :
    • Si le cavalier sur ENA ou ENB est présent : alors chacun des moteurs sera soit totalement arrêté, soit tournera à vitesse maximale
    • Si le cavalier sur ENA ou ENB est absent : alors il faudra envoyer un signal PWM sur les entrées ENA et/ou ENB, pour piloter les moteurs, de manière proportionnée. Ainsi, vous les ferez tourner à vitesse voulue !

Pour ceux que ça intéresse, je vous ai fait rapido un schéma électronique, représentant un module L298N « tout équipé ». À noter que cette version en est une parmi tant d’autres, et qu’il existe de nombreuses variantes.

L298N schematic détaillé, exemple de schéma électronique pour un module L298N monté sur PCB, avec diodes, condensateurs, et régulateur de tension

ATTENTION : la plupart du temps, on trouve des modules L298N tous équipés avec leur cavalier JMP1 (jumper) enfiché dessus. Pour rappel, celui-ci permet d’alimenter la partie commande du L298N, soit depuis le régulateur de tension branché sur l’alim de puissance, soit depuis la borne notée « +5V ». Par contre, c’est l’un OU l’autre. Du coup, suivant votre situation, réfléchissez bien avant de brancher quoi que ce soit au niveau de la borne « +5V » de votre L298N, car si le jumper est en place, ça pourrait « faire des étincelles » ! Soyez donc très prudent à ce niveau, et réfléchissez bien à ce que vous faites, avant de brancher quoi que ce soit.

À présent, passons à des choses plus concrètes, en répondant à la question suivante : « Comment brancher le L298N sur un Arduino ? ». Bien évidemment, il y a plusieurs façons de faire. Pour commencer, je vous propose ici un premier exemple de montage, mettant en œuvre ce module L298N et un Arduino Uno. Bien entendu, vous êtes libre d’adapter ce montage selon vos besoins, que ce soit au niveau du type d’arduino utilisé (ou tout autre dispositif de pilotage), et du choix de branchement des entrées/sorties. Mon conseil : laissez-vous inspirer par ce montage si vous débutez avec le L298N, et ensuite, adaptez-le à vos besoins 😉

Branchement L298N sur Arduino Uno, avec détail câblage des entrées sorties, alimentation de commande +5V et puissance 5 à 35V, et branchement bornes

Comme vous le voyez, rien de bien compliqué ! Pour ma part, j’ai branché :

  • L’entrée « ENA » (du module L298N) sur la sortie D10 (de l’Arduino Uno)
  • L’entrée « IN1 » sur D9
  • L’entrée « IN2 » sur D8
  • L’entrée « IN3 » sur D7
  • L’entrée « IN4 » sur D6
  • L’entrée « ENB » sur D5
  • La borne « GND » (du module L298N) à la broche GND (de l’Arduino Uno)

Remarquez que je n’ai pas relié le +5V du L298N, sur le +5V de l’Arduino, dans cet exemple. En fait, je suis ici dans la configuration suivante :

  • Alimentation de la partie puissance du module L298N en +12V (pour faire tourner les moteurs)
  • Mise en place du cavalier JMP1 (jumper d’alim 5V, sur le PCB du L298N), permettant à ce dernier de se « créer » du +5V à partir du +12V reçu sur la partie puissance
  • Arduino Uno alimenté via son cordon USB (lui fournissant « son » 5 volts à lui)
  • Et seules les masses du module et de l’arduino sont « mises au même niveau », en les reliant ensemble

Exemple code arduino 1 : marche arrêt d’un moteur DC, avec inversion du sens de rotation

À présent, il est temps de passer à des choses encore plus concrètes, à savoir : la réalisation d’un petit montage, permettant de successivement faire tourner puis arrêter un petit moteur électrique (en 12V), aussi bien en marche avant, qu’en marche arrière ! Pour cela, nous allons nous servir d’un Arduino Uno. Voici d’ailleurs le montage que j’ai réalisé, de mon côté :

L298N code arduino exemple de programme, pour commande moteur électrique 12V, fonctionnement sur Arduino Uno, câblage dupont, et alimentations

Perso, j’alimente :

  • La partie puissance avec du +12V, au niveau du module L298N (ce qui donnera environ 9 à 10 volts au niveau du moteur, si l’on déduit grosso modo la chute de tension induite par le pont en H)
  • La partie Arduino en +5V, via son cordon de programmation USB

Nota : le cavalier JMP1, permettant la création de « +5V » à partir du +12V fourni au module L298N, est requis.

AperçuMatériel utilisé QtéLien
Arduino Uno Bleu fonctionnant avec microcontrôleur ATmega328, alimenté en 5V avec prise USB servant aussi à la programmation de la carte électronique Arduino Uno (microcontrôleur ATmega328)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec
Mini moteur jaune 12V, vitesse démultipliée pour modèle réduit amateur, avec roue fournie, motor DC 12 volts à courant continu, pour petits projets électroniques Ensemble moteur 12V avec roue (pour petits projets modélisme)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec
Mini module L298N tout équipé, PCB avec puce électronique intégrée, double driver pour moteur à courant continu DC 12V, et borniers commande PWM Module L298N (équipé de borniers et plots de branchement)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec

Au niveau du code arduino, voici ce que ça donne :

/*
   ______               _                  _///  _           _                   _
  /   _  \             (_)                |  __\| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier:      MarcheArretMoteurL298N
  Description:  Exemple de code Arduino, permettant de faire tourner un moteur à courant continu (marche avnat/marche arrière), via un module L298N branché sur un Arduino Uno
  Auteur:       Jérôme, Passion-Électronique (https://passionelectronique.fr/)
  Création :    05.05.2021
*/

//*******************************************************************************//
// Association des entrées du L298N, aux sorties utilisées sur notre Arduino Uno //
//*******************************************************************************//
#define borneENA        10      // On associe la borne "ENA" du L298N à la pin D10 de l'arduino
#define borneIN1        9       // On associe la borne "IN1" du L298N à la pin D9 de l'arduino
#define borneIN2        8       // On associe la borne "IN2" du L298N à la pin D8 de l'arduino
#define borneIN3        7       // On associe la borne "IN3" du L298N à la pin D7 de l'arduino
#define borneIN4        6       // On associe la borne "IN4" du L298N à la pin D6 de l'arduino
#define borneENB        5       // On associe la borne "ENB" du L298N à la pin D5 de l'arduino


//*******//
// SETUP //
//*******//
void setup() {
  
  // Configuration de toutes les pins de l'Arduino en "sortie" (car elles attaquent les entrées du module L298N)
  pinMode(borneENA, OUTPUT);
  pinMode(borneIN1, OUTPUT);
  pinMode(borneIN2, OUTPUT);
  pinMode(borneIN3, OUTPUT);
  pinMode(borneIN4, OUTPUT);
  pinMode(borneENB, OUTPUT);
}

//**************************//
// Boucle principale : LOOP //
//**************************//
void loop() {

  // Configuration du L298N en "marche avant", pour le moteur connecté au pont A. Selon sa table de vérité, il faut que :
  digitalWrite(borneIN1, HIGH);                 // L'entrée IN1 doit être au niveau haut
  digitalWrite(borneIN2, LOW);                  // L'entrée IN2 doit être au niveau bas

  // Et on lance le moteur (branché sur le pont A du L298N)
  lancerRotationMoteurPontA();

  // Puis on configure le L298N en "marche arrière", pour le moteur câblé sur le pont A. Selon sa table de vérité, il faut que :
  digitalWrite(borneIN1, LOW);                  // L'entrée IN1 doit être au niveau bas
  digitalWrite(borneIN2, HIGH);                 // L'entrée IN2 doit être au niveau haut

  // Et on relance le moteur (branché sur le pont A du L298N)
  lancerRotationMoteurPontA();
  
  // Puis... on boucle à l'infini !
}


//************************************************************************************//
// Fonction : lancerRotationMoteurPontA()                                             //
// But :      Active l'alimentation du moteur branché sur le pont A                   //
//            pendant 2 secondes, puis le met à l'arrêt (au moins 1 seconde)          //
//************************************************************************************//
void lancerRotationMoteurPontA() {
  digitalWrite(borneENA, HIGH);       // Active l'alimentation du moteur 1
  delay(2000);                        // et attend 2 secondes
  
  digitalWrite(borneENA, LOW);        // Désactive l'alimentation du moteur 1
  delay(1000);                        // et attend 1 seconde
}

Une fois le programme uploadé dans votre Arduino Uno, vous devriez votre le moteur :

  • tourner 2 secondes dans un sens
  • s’arrêter 1 seconde
  • tourner 2 secondes dans l’autre sens
  • s’arrêter 1 seconde
  • puis répéter tout cela indéfiniment !

Maintenant que nous avons vu comment faire tourner un moteur électrique à courant continu, aussi bien dans un sens que l’autre, nous allons faire un 2ème programme, permettant quant à lui de faire varier la vitesse de rotation du moteur, au doigt et à l’œil ! Alors en avant 😉

Exemple code arduino 2 : faire varier la vitesse d’un moteur à courant continu

Sur la base du montage précédent, avec le module L298N branché sur un Arduino Uno (voir croquis un peu plus haut), nous allons faire varier la vitesse du moteur, entre 0 et 100% de sa vitesse. Pour ce faire, nous allons simplement faire varier le rapport cyclique du signal PWM envoyé au L298N depuis l’arduino. Voici une photo du montage que j’ai réalisé pour faire mes essais (pour rappel, le câblage des entrées sorties de l’Arduino et du L298N sont ceux vus dans l’exemple précédent).

Test L298N et Arduino Uno, pilotage moteur 12V à courant continu, avec exemple de code de programmation arduino, signal PWM vitesse de rotation

Voici le programme arduino en lui-même :

/*
   ______               _                  _///  _           _                   _
  /   _  \             (_)                |  __\| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier:      VariationVitesseMoteurL298N
  Description:  Exemple de code Arduino, permettant de faire varier la vitesse d'un moteur à courant continu (accélération, puis décélération)
                avec inversion de sens de rotation, le tout piloté par un module L298N raccordé à un Arduino Uno
  Auteur:       Jérôme, Passion-Électronique (https://passionelectronique.fr/)
  Création :    05.05.2021
*/

//*******************************************************************************//
// Association des entrées du L298N, aux sorties utilisées sur notre Arduino Uno //
//*******************************************************************************//
#define borneENA        10      // On associe la borne "ENA" du L298N à la pin D10 de l'Arduino (PWM possible sur cette broche)
#define borneIN1        9       // On associe la borne "IN1" du L298N à la pin D9 de l'Arduino
#define borneIN2        8       // On associe la borne "IN2" du L298N à la pin D8 de l'Arduino
#define borneIN3        7       // On associe la borne "IN3" du L298N à la pin D7 de l'Arduino
#define borneIN4        6       // On associe la borne "IN4" du L298N à la pin D6 de l'Arduino
#define borneENB        5       // On associe la borne "ENB" du L298N à la pin D5 de l'Arduino (PWM possible sur cette broche)

//*************************//
// Constantes du programme //
//*************************//
#define delaiChangementVitesse     20       // Défini un petit délai, exprimé en millisecondes, avant tout autre changement de vitesse
#define vitesseMinimale            60       // Rapport cylique minimal du signal PWM, pour faire tourner le moteur au minimum de sa vitesse (en pratique, on évitera de trop approcher la valeur  0)
#define vitesseMaximale            255      // Rapport cylique maximal du signal PWM, pour faire tourner le moteur au maximum de sa vitesse

const char MARCHE_AVANT   = 'V';            // Défini une constante pour la "marche avant" (peu importe la valeur)
const char MARCHE_ARRIERE = 'R';            // Défini une constante pour la "marche arrière" (peu importe la valeur)

//************************//
// Variables du programme //
//************************//
int vitesse;                    // Spécifie la vitesse de rotation du moteur, entre son minimum (0) et son maximum (255) <= signal PWM

//*******//
// SETUP //
//*******//
void setup() {
  
  // Configuration de toutes les pins de l'Arduino en "sortie" (car elles attaquent les entrées du module L298N)
  pinMode(borneENA, OUTPUT);
  pinMode(borneIN1, OUTPUT);
  pinMode(borneIN2, OUTPUT);
  pinMode(borneIN3, OUTPUT);
  pinMode(borneIN4, OUTPUT);
  pinMode(borneENB, OUTPUT);
}

//**************************//
// Boucle principale : LOOP //
//**************************//
void loop() {

  // ***************** MARCHE AVANT ******************** //

  // On configure le sens de rotation du moteur branché sur le pont A en "marche avant"
  configurerSensDeRotationPontA(MARCHE_AVANT);

  // On lance le moteur raccordé au pont A, en faisant varier sa vitesse de 0 à sa vitesse maximale (atteinte lorsque le signal PWM a un rapport cyclique égal à 255)
  for(vitesse=vitesseMinimale ; vitesse<vitesseMaximale ; vitesse++) {
    changeVitesseMoteurPontA(vitesse);            // Met à jour la vitesse du moteur, en modifiant le rapport cyclique du signal PWM envoyé
    delay(delaiChangementVitesse);                // ... et on rajoute un petit délai pour que tout n'aille pas trop vite !
  }

  // Puis on ramène sa vitesse à 0, au même rythme
  for(vitesse=vitesseMaximale ; vitesse>vitesseMinimale ; vitesse--) {
    changeVitesseMoteurPontA(vitesse);            // Met à jour la vitesse du moteur, en modifiant le rapport cyclique du signal PWM envoyé
    delay(delaiChangementVitesse);                // ... et on rajoute un petit délai pour que tout n'aille pas trop vite !
  }

  // ****************** PETITE PAUSE ********************* //
  changeVitesseMoteurPontA(0);
  delay(1000);
  
  // ***************** MARCHE ARRIÈRE ******************** //
  
  // On configure le sens de rotation du moteur branché sur le pont A en "marche arrire"
  configurerSensDeRotationPontA(MARCHE_ARRIERE);

  // On lance le moteur raccordé au pont A, en faisant varier sa vitesse de 0 à sa vitesse maximale (atteinte lorsque le signal PWM a un rapport cyclique égal à 255)
  for(vitesse=vitesseMinimale ; vitesse<vitesseMaximale ; vitesse++) {
    changeVitesseMoteurPontA(vitesse);            // Met à jour la vitesse du moteur, en modifiant le rapport cyclique du signal PWM envoyé
    delay(delaiChangementVitesse);                // ... et on rajoute un petit délai pour que tout n'aille pas trop vite !
  }

  // Puis on ramène sa vitesse à 0, au même rythme
  for(vitesse=vitesseMaximale ; vitesse>vitesseMinimale ; vitesse--) {
    changeVitesseMoteurPontA(vitesse);            // Met à jour la vitesse du moteur, en modifiant le rapport cyclique du signal PWM envoyé
    delay(delaiChangementVitesse);                // ... et on rajoute un petit délai pour que tout n'aille pas trop vite !
  }
   
  // ****************** PETITE PAUSE ********************* //
  // ********* ET ON RE-BOUCLE INDÉFINIMENT ! ********* //
  changeVitesseMoteurPontA(0);
  delay(1000);
}



//************************************************************************************//
// Fonction : configurerSensDeRotationPontA()                                         //
// But :      Permet de définir le sens de rotation du moteu branché sur le pont A    //
//************************************************************************************//
void configurerSensDeRotationPontA(char sensDeRotation) {

  if(sensDeRotation == MARCHE_AVANT) {
    // Configuration du L298N en "marche avant", pour le moteur connecté au pont A. Selon sa table de vérité, il faut que :
    digitalWrite(borneIN1, HIGH);                 // L'entrée IN1 doit être au niveau haut
    digitalWrite(borneIN2, LOW);                  // L'entrée IN2 doit être au niveau bas    
  }
  
  if(sensDeRotation == MARCHE_ARRIERE) {
    // Configuration du L298N en "marche arrière", pour le moteur câblé sur le pont A. Selon sa table de vérité, il faut que :
    digitalWrite(borneIN1, LOW);                  // L'entrée IN1 doit être au niveau bas
    digitalWrite(borneIN2, HIGH);                 // L'entrée IN2 doit être au niveau haut
  }
}

//************************************************************************************//
// Fonction : changeVitesseMoteurPontA()                                              //
// But :      Change la vitesse de rotation du moteur branché sur le pont A           //
//            (cette valeur doit être comprise entre 0 et 255)                        //
//************************************************************************************//
void changeVitesseMoteurPontA(int nouvelleVitesse) {
  
  // Génère un signal PWM permanent, de rapport cyclique égal à "nouvelleVitesse" (valeur comprise entre 0 et 255)
  analogWrite(borneENA, nouvelleVitesse);
}

Une fois ce programme uploadé dans votre Arduino Uno, vous devriez voir les étapes suivantes :

  • le moteur démarrera progressivement, jusqu’à atteindre sa vitesse maximale
  • puis décélérera, jusqu’à s’arrêter
  • ensuite, le sens de rotation sera inversé
  • le moteur redémarrera une nouvelle fois, jusqu’à réatteindre sa vitesse maxi
  • puis décélérera encore, jusqu’à s’arrêter à nouveau
  • enfin, le sens de rotation sera remis « à la normale »
  • et on répètera toute cette séquence indéfiniment !
AperçuMatériel utilisé QtéLien
Arduino Uno Bleu fonctionnant avec microcontrôleur ATmega328, alimenté en 5V avec prise USB servant aussi à la programmation de la carte électronique Arduino Uno R3 (microcontrôleur ATmega328)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec
Mini moteur jaune 12V, vitesse démultipliée pour modèle réduit amateur, avec roue fournie, motor DC 12 volts à courant continu, pour petits projets électroniques Ensemble moteur DC 12V avec roue (pour petits projets modélisme)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec
Mini module L298N tout équipé, PCB avec puce électronique intégrée, double driver pour moteur à courant continu DC 12V, et borniers commande PWM Module L298N (équipé de borniers et pins de branchement)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec

Voilà ! Nous avons vu deux exemples vous permettant d’avoir un premier tour d’horizon pratique du L298N, à savoir :

  • Comment démarrer et arrêter un moteur à courant continu (exemple 1)
  • Et comment faire varier la vitesse de rotation d’un moteur DC (exemple 2)

Branchement des sorties en parallèle, pour plus de courant encore (schéma de couplage des ponts en H)

Il faut savoir que le L298N peut voir ses sorties couplées ensemble, pour profiter de 2 fois plus de courant en sortie. Par contre, cela signifie évidemment qu’on ne pourra plus piloter deux moteurs séparément, mais qu’un seul, sur la « sortie commune ».

Dans le principe, le montage est on ne peut plus simple à réaliser. Toutefois, il faudra bien veiller à relier les « bonnes entrées » ensemble, et de même pour les sorties. Car vous ne pourrez pas faire fonctionner correctement le L298N, si tout n’est pas parfaitement câblé. Voici d’ailleurs le câblage à faire, lorsqu’on souhaite jumeler les 2 ponts en H du L298N ensemble :

Couplage entrées sorties L298N pour doublage courant, pilotage moteur plus puissant possible, schéma électronique avec câblage du circuit intégré

En somme, rien de bien compliqué, comme vous pouvez le constater ! Mais encore une fois : faites très attention à bien respecter les câblages, sinon vous risquez fort de détruire vos composants électroniques. Restez toujours très vigilant à ce niveau.

Tutoriel L298N : conclusion

Voilà, nous voici au terme de ce tuto sur le L298N. J’espère que vous aurez pu apprendre ou découvrir plein de choses ici. Aussi, n’hésitez pas à vous inspirer de tous les montages et codes arduino présentés ici, pour vos futurs projets.

Du reste, si vous avez des questions, ou relevez la moindre coquille, n’hésitez pas à m’en faire part dans la zone commentaire, juste ci-dessous. Cela me permettra de tenir ce contenu le plus à jour possible, et de pouvoir vous aider au possible, dans les limites de mes connaissances et du temps dont je dispose, bien entendu ! Dans tous les cas, à bientôt !

Jérôme.

À découvrir également : Tous les tutoriels publiées sur le site Passion Électronique !

Ce contenu vous plaît ? Alors abonnez-vous à la Newsletter pour ne rien louper !

(*) Mis à jour le 23/05/2021

24 commentaires sur “Tutoriel L298N : fonctionnement, branchement module, et exemples de code arduino (avec pilotage PWM)”

  1. Site passionelectronique.fr
    Jean-Pierre Delon

    Très bon article, je pense avoir trouvé tout ce que j’avais besoin.
    Merci pour ce travail et le partage.
    Cordialement.
    Jean-Pierre

  2. Merci d’avoir pris le temps d’expliquer ce fonctionnement.
    Je n’ai pas le niveau en électronique pour tout comprendre mais j’y reviendrai en cas de question.

    Ça serai chouette si on pouvait en avoir une version pdf

  3. Félicitations. Excellent tutoriel.
    Concernant la fréquence de commutation comment est-elle fixée dans un montage avec Arduino et module L298N ?
    Cordialement

    1. Salut François !

      Les fréquences de commutation des signaux PWM sont fixes. Par exemple, avec l’Arduino Uno utilisé dans les exemples ci-dessus, la fréquence de sortie est d’environ :

      • 490 Hz sur la sortie D5 (où j’ai branché la broche ENB)
      • et 980 Hz sur la sortie D10 (où j’ai raccordé la broche ENA)

      Au passage, pour que ce soit bien clair pour tout le monde : ce n’est pas la fréquence des signaux PWM qui fait varier la vitesse d’un moteur ici, mais bien le rapport cyclique de ces signaux.

      Du reste, pour répondre à ta question, il faut savoir que les fréquences de commutation PWM sont fonction des timers arduino, associés à chaque sortie. Ainsi, pour modifier la fréquence PWM de la sortie D5, il faudra alors s’intéresser au Timer 0 de l’Arduino. Et pour la sortie D10, il s’agira de se pencher sur le Timer 1. Et lorsque je parle de Timer ici, je parle en fait de l’ensemble Horloge/Prescaler/Prédiviseurs/Timers, et de tous les registres associés. Car c’est selon le réglage/paramétrage de tous ces éléments, qu’une fréquence PWM peut être sélectionnée, plutôt qu’une autre.

      En résumé, si tu souhaites modifier la fréquence PWM des signaux sortant de l’Arduino, en direction du module L298N, il te faudra simplement t’intéresser à « comment modifier la fréquence des signaux PWM d’un Arduino ». Par contre, comme cela prendrait un peu plus que quelques lignes pour bien expliquer les choses, je me note d’en faire un tuto prochainement, enfin… dès que je le pourrais ! En attendant, je pense que tu pourras facilement trouver toutes les infos manquantes sur le net, pour cette partie là !

      Bon courage à toi, et à bientôt !
      Jérôme.

      1. Très bon article, pour la compréhension du fonctionnement du pont en H.
        Je me pose une question pour le branchement en parallèle ?
        Moi j’aurai relié IN1 avec IN3 et IN2 avec IN4, et non IN1 avec IN4 et IN2 avec IN3.
        Est ce une erreur dans l’article ou moi qui est mal compris ?
        Cordialement
        Eric

        1. Salut Eric !

          Je viens de vérifier sur la documentation constructeur, et il est bien présenté le couplage IN1/IN4 et IN2/IN3 pour le branchement en parallèle. Il n’y a donc pas d’erreur à ce niveau.

          Toutefois, ta remarque est fort pertinente. Et selon moi, ton montage constitue le second couplage réalisable, pour effectuer un branchement en parallèle. À ceci près que dans ton cas, il faudra alors relier OUT1 avec OUT3, et OUT2 avec OUT4 (alors que dans « mon cas », la sortie OUT1 est couplée avec OUT4, et OUT2 avec OUT3).

          Voilà !
          Jérôme.

      2. Merci pour ce tuto tres clair.
        Auparavant j’avais du mal à comprendre le fonctionnement du jmp1…
        encore bravo.
        Bien à toi
        Didier

      3. Un grand merci pour toutes ces explications très utiles pour un néophyte comme moi (78 ans). Je cherche à faire un véhicule qui ne fait qu’avancer pendant 3s en ligne droite.

        Puis-je faire l’économie de sorties arduino en mettant les entrées IN2 et IN3 à la masse ?

        Mon projet est de reproduire l’expérience de pensée de Galilée (dans un véhicule en mouvement rectiligne uniforme où un objet tombe « verticalement » comme s’il était immobile). Je fais donc un chariot portant un mat de 50 cm, avec un électroaimant au sommet. Une bille doit tomber, je mesure le temps de chute et la vitesse du chariot, le tout est affiché à la fin de l’expérience …

        1. Bonsoir Didier !

          Alors, concernant le L298N, tu peux effectivement mettre les entrées IN2 et IN3 à la masse, si tu n’as besoin que d’UN SEUL sens de rotation pour tes moteurs. Effectivement, ça te feras faire des économies de sorties, sur ton Arduino 😉

          Du reste, concernant l’expérience de pensée de Galilée, j’imagine que tu cherches à prouver que ce n’est pas parce qu’une chose est plus lourde qu’une autre, qu’elle touchera forcément « le sol » avant l’autre, même si elles sont lâchées en même temps, et de la même hauteur. Par contre, je n’arrive pas vraiment à visualiser ton montage, avec le chariot motorisé, désolé !

          En tout cas, ça fait très plaisir de voir que tu « t’amuses » bien, avec ce petit projet sympa, et instructif !

          À bientôt,
          Jérôme.

      4. Super dossier et très complet. Beau travail !!!
        Toutefois, je me pose la question si il est possible de piloter une dizaines de moteurs.
        Peut-être en passant par un module i2c ?

        1. Salut !

          Oui, tu peux « facilement » piloter une dizaine de moteurs en utilisant des modules i2c. Car certains de ces modules te permettront d’avoir des sorties PWM supplémentaires, ou des sorties digitales supplémentaires (suivant tes besoins). Et comme tu l’auras compris, le tout piloté avec 2 fils seulement (SDA/SCL).

          Sinon, si tu travailles avec une carte de type Arduino Uno ou Arduino Nano, tu peux aussi opter pour une carte plus « grande », telle que l’Arduino Mega. En effet, cette dernière comporte une pléiade d’entrées sorties digitales, et surtout, pas moins de 15 sorties PWM (D2 à D13, et D44 et D46). Donc potentiellement, de quoi pouvoir alimenter bon nombre de modules L298N en direct, et ce, sans module supplémentaire ! Mais là encore, c’est à voir selon tes besoins 😉

          Amuse toi bien !
          Jérôme.

      5. Bonjour,

        Merci pour cet article très complet !!

        Comment alimenteriez-vous l’arduino si ce n’est pas avec le câble usb, par exemple dans un robot… mobile… ??
        Si j’utilise une batterie lipo 7,4V, conseilleriez-vous :
        – directement depuis l’alim sur la broche Vin de l’arduino ?
        – en utilisant le 5V stabilisé du pilote sur la broche 5V de l’arduino ?

        Merci

        1. Salut Raphael !

          Tout d’abord, tu as parfaitement bien identifié les 2 autres façons d’alimenter un Arduino (outre l’alim par câble USB, et l’alim via connecteur JACK).

          Et effectivement, tu peux alimenter ton Arduino :

          • soit via sa broche Vin, qui accepte une tension de 7 à 12 volts environ (ce qui est idéal avec ta LIPO de 7,4 volts, et ce, tant que la tension de ta batterie ne descendra pas en dessous de 7V, environ)
          • soit directement sur la broche +5V, si tu fournies du 5 volts depuis l’extérieur (en mettant par exemple un régulateur de tension 5V en sortie de ta batterie LIPO)

          Perso, j’évite de tirer trop de courant sur le +5V d’un arduino (car son régulateur de tension intégré montre vite ses limites). C’est pourquoi, dans un cas comme le tien, j’aurais tendance à envoyer du 5 volts, bien régulé/filtré, sur l’entrée +5V de l’Arduino, plutôt que d’envoyer directement du 7,4 volts sur son entrée Vin.

          Maintenant, à toi de voir, selon ton montage 😉

          Amuse toi bien !
          Jérôme.

          1. Merci de ta réponse.

            dans un cas comme le tien, j’aurais tendance à envoyer du 5 volts, bien régulé/filtré, sur l’entrée +5V de l’Arduino
            La sortie 5v du L298N peut-il faire l’affaire du coup en terme de qualité de régulation ?

            Raphael

            1. Pour moi, oui. Car les plaquettes L298N disposent d’un régulateur linéaire 7805 intégré, couplé à un condensateur de filtrage en sortie de 220 µF (pour les modèles que j’ai vu).

              Donc, à moins que tu dépasses le courant que peut fournir un tel régulateur, un Arduino branché dessus ne devrait pas poser de soucis !

              Jérôme.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Symbole danger point d'exclamation site PSE, triangle jaune avec contour noir, texte noir alerte au milieu Afin de filtrer au maximum les messages de type "spam", chaque commentaire est soumis à modération, et validé manuellement. Du coup, ne vous inquiétez pas si votre message n'apparait pas immédiatement en zone commentaires !