Aller au contenu

Module L298N : fonctionnement, branchement module, et exemples de code arduino (tutorial 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 !
Module Description Lien
Module L298N avec borniers PCB pour par exemple piloter un moteur électronique avec un Arduino simplement, platine avec composants assemblés Module L298N avec borniers sur PCB
(intégrant diodes de protection et broches/contacts de pilotage)

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 😉

Module Description Lien
Module L298N avec borniers PCB pour par exemple piloter un moteur électronique avec un Arduino simplement, platine avec composants assemblés Module L298N avec borniers sur PCB
(intégrant diodes de protection et broches/contacts de pilotage)

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 minimum, 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
Module Description Lien
Module L298N avec borniers PCB pour par exemple piloter un moteur électronique avec un Arduino simplement, platine avec composants assemblés Module L298N avec borniers sur PCB
(intégrant diodes de protection et broches/contacts de pilotage)

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 électroniqueArduino Uno (microcontrôleur ATmega328)x1Lien 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 électroniquesEnsemble moteur 12V avec roue (pour petits projets modélisme)x1Lien 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 PWMModule L298N (équipé de borniers et plots de branchement)x1Lien 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 électroniqueArduino Uno R3 (microcontrôleur ATmega328)x1Lien 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 électroniquesEnsemble moteur DC 12V avec roue (pour petits projets modélisme)x1Lien 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 PWMModule L298N (équipé de borniers et pins de branchement)x1Lien 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)
Module Description Lien
Module L298N avec borniers PCB pour par exemple piloter un moteur électronique avec un Arduino simplement, platine avec composants assemblés Module L298N avec borniers sur PCB
(intégrant diodes de protection et broches/contacts de pilotage)

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 18/01/2024

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

  1. Site passionelectronique.fr

    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. Site passionelectronique.fr

    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. Site passionelectronique.fr

    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. Site passionelectronique.fr

      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.

  4. Site passionelectronique.fr

    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. Site passionelectronique.fr

      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.

  5. Site passionelectronique.fr

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

  6. Site passionelectronique.fr

    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. Site passionelectronique.fr

      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.

  7. Site passionelectronique.fr

    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. Site passionelectronique.fr

      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.

  8. Site passionelectronique.fr

    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. Site passionelectronique.fr

      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. Site passionelectronique.fr

        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. Site passionelectronique.fr

          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.

  9. Site passionelectronique.fr

    Salut tout le monde 😉

    Solution avec les jumpers ENABLE en places
    Économie de deux sorties au niveau de l’Arduino (ou de l’ESP8266, plus limité en broches)

    #define borneIN1  9    
    #define borneIN2  8
    
    int vitesse = 150;
    
    void setup()
    {
      pinMode(borneIN1, OUTPUT);
      pinMode(borneIN2, OUTPUT);
    }
    
    void loop() 
    {
      // Moteur dans un sens
      analogWrite(borneIN1, vitesse);
      digitalWrite(borneIN2, LOW);  
    
      delay(2000);
    
      // Inversion de la rotation
      analogWrite(borneIN1, 255 - vitesse );   // valeur du PWM inversée, vu que borneIN2 est "HIGH"
      digitalWrite(borneIN2, HIGH);  
     
      delay(2000);
    
      // Arrêt moteur
      digitalWrite(borneIN1, LOW);
      digitalWrite(borneIN2, LOW);
    
      delay(4000);
    }
    
  10. Site passionelectronique.fr

    Bonjour Jérôme. Merci bcp pour ces très bons renseignements, bien clairs et très bien expliqués. Je débute en électronique à 60 ans. C’est pas simple mais avec tes présentations ça va mieux. Encore Merci ! Erick

  11. Site passionelectronique.fr

    Bonjour Jérôme,

    Tout d’abord félicitations pour ton tuto, pour moi il est top ! Bien expliqué ! Continue ainsi…

    Je souhaiterais utiliser le L298N pour piloter un réseau de train électrique. L’Arduino (dans mon cas une Mega) enverrait, via le L298N, une tension sur les rails, comprise entre 0 et 12 VDC, pour faire avancer les locomotives, à plus ou moins grande vitesse. Est-ce réalisable ? A quoi dois-je faire attention dans mon projet ?

    Encore merci ! Fred

    1. Site passionelectronique.fr

      Salut Fred !

      Hum … je ne m’y connais malheureusement pas en modélisme ferroviaire. Du coup, je vais te répondre sur la partie L298N, seulement 😉

      Alors : si tes locomotives consomment moins de 2 ampères en courant continu, un L298N pourrait convenir (en « mode normal »). Mais avant tout, perso, je ferai des essais sur une locomotive placée sur un « bout de rail », si c’est possible. Ainsi, tu pourrais vérifier si la commande PWM de tes moteurs de loco fonctionne bien.

      Par contre, il faut savoir qu’il y a une chute de tension induite aux bornes d’un L298N, d’environ 2 à 5 volts. Du coup, si tes locomotives nécessitent 12V pour fonctionner, il faudra peut-être alors alimenter le tout avec du 14V (ou un peu plus), pour que tout roule bien !

      Désolé de ne pouvoir t’en dire plus, sur ce sujet…
      Mais amuse toi bien !

      Jérôme.

  12. Site passionelectronique.fr

    Salut Jérôme,

    Je pensais faire aussi des tests.
    Pour l’intensité, le transfo actuel donne 500mA. Et ça tourne ! Donc je pense qu’on est bon.
    C’est pour la tension, il va falloir que je trouve un transfo qui donne un peu plus de 14VDC…

    Merci encore pour tes conseils et continue à nous informer et faire des tutoriels aussi bien montés ! C’est top !

    A+ Fred

  13. Site passionelectronique.fr

    Bonjour Jérôme,

    Merci pour ce partage qui vaut mieux que tout ce que j’ai vu jusqu’à présent. Félicitations pour la clarté de tes explications, cela m’a permis de trouver plusieurs astuces dont j’avais besoin pour améliorer mes montages.

    J’aurai une question cependant, concernant le modélisme ferroviaire, qui utilise désormais des moteurs sans fer qu’il faut piloter avec des PWM de 20KHz. Je ne vois pas comment le faire avec l’arduino. Aurais-tu une piste à me suggérer ?

    Merci d’avance pour ton temps !

    1. Site passionelectronique.fr

      Salut !

      Tout d’abord merci, pour ce message chaleureux 😉

      Du reste, je vais voir si je peux te créer un programme permettant de faire cela. En attendant, si tu es motivé, tu peux toujours lire l’article que j’ai fait sur le PWM Arduino, qui donne déjà des éléments de réponses (même si ça peut, je le conçois, être compliqué de prime abord !).

      @+
      Jérôme.

    2. Site passionelectronique.fr

      Re,

      Voici ce que j’ai pu écrire et tester de mon côté, afin d’obtenir un signal PWM de 20 kHz sur une sortie (la D10), avec rapport cyclique ajustable à souhait.

      // *******************************************************************
      // PROGRAMME : permet de sortir un signal de 20 kHz sur la sortie D10,
      //             avec rapport cyclique ajustable à la demande
      // *******************************************************************
      
      // Variables du programme
      float valeurRapportCyclique = 0.50;     // Valeur comprise entre 0 et 1
                                              // --> pour un rapport cyclique à  1%, mettre 0.01
                                              // --> pour un rapport cyclique à 50%, mettre 0.50
                                              // --> pour un rapport cyclique à 99%, mettre 0.99
      
      void setup()  
      { 
        // Déclaration de la pin D10 en sortie
        pinMode(10, OUTPUT);
        
        // Sélection du mode "Fast PWM avec TOP=0CR1A"
        bitSet(TCCR1B, WGM13);        // Mise à 1 de WGM13
        bitSet(TCCR1B, WGM12);        // Mise à 1 de WGM12
        bitSet(TCCR1A, WGM11);        // Mise à 1 de WGM11
        bitSet(TCCR1A, WGM10);        // Mise à 1 de WGM10
        
        // Valeur OCR1A = freq. signal PWM (800 pour obtenir du 20 kHz)
        OCR1A = 800;
        
        // Valeur OCR1B = durée du signal à l'état haut
        OCR1B = OCR1A * valeurRapportCyclique;
      
        // Réglage du prévidiseur du Timer1 sur 1 (donc, pas de division de fréquence)
        TCCR1B &= 0b11111000;
        TCCR1B |= 0b00000001;
        
        // Génération du signal PWM sur la sortie D10
        bitSet(TCCR1A, COM1B1);
        bitClear(TCCR1A, COM1B0);
      }
      
      void loop()  
      { 
        // Vide
      }

      Voilà, c’est « prêt à l’emploi », comme on dit ! Du reste, je pense que je ferai un article dessus plus tard, quand j’aurais le temps, pour expliquer vraiment tout le fonctionnement détaillé de ce type de programme.

      Amuse toi bien 😉
      Jérôme.

  14. Site passionelectronique.fr

    Bonjour Jérôme,

    Je te remercie pour ton tuto super clair.

    J’aurais juste une question : j’ai besoin d’avoir 40 kHz en sortie. J’ai vu que tu avais déjà répondu pour 20 kHz, mais j’ai très peu de connaissances en électronique. Y a t-il un moyen simple comme par exemple ajouter un facteur 2 pour OCR1A (passé de 800 à 1600 par exemple) ? J’ai vu sur un autre tuto sur le PMW qu’on pouvait changer la fréquence avec le prédiviseur. Mais on ne pouvait avoir seulement des valeurs fixes (par exemple prédiviseur réglé sur le 1 = 31372 Hz, sur le 2 = 3921 Hz). Pourrais-tu m’éclairer dessus ou alors je suis à coté de la plaque.

    Je te remercie d’avance.

    1. Site passionelectronique.fr

      Salut !

      Ton raisonnement est très bon, concernant la valeur de OCR1A. Par contre, pour passer de 20 kHz à 40 kHz, il faut baisser la valeur d’OCR1A, et non la monter (afin d’avoir une durée plus courte, et donc, une fréquence plus élevée). Du coup, pour passer de 20 à 40 kHz, il faut faire passer OCR1A de 800 à 400 (399 en réalité, pour être plus précis !).

      Sinon, concernant le prédiviseur d’horloge, tu as vu juste là aussi. Car, concernant le timer 1 de l’ATmega328P, les facteurs de division possibles sont uniquement /1, /8, /64, /256, et /1024. Donc le plus simple, ici, est de toucher uniquement à la valeur d’OCR1A. Cela étant dit, cette voie n’est pas mauvaise en soi, car il y a parfois plusieurs façons de faire, pour arriver au même résultat !

      Voilà ! @+
      Jérôme.

  15. Site passionelectronique.fr

    Salut Jérôme !

    Je te remercie énormément pour ce magnifique article. Il est vraiment clair d’explications et très riche.

    Bravo !

  16. Site passionelectronique.fr

    Bonjour,

    Super Tuto… mais il me reste des incertitudes… de débutant… lol.

    Je m’interroge sur la nécessité de réaliser les branchements IN3, IN4, ENB si je n’utilise que la sortie A. Pour l’instant, mon prog ne fonctionne pas et j’aimerais pouvoir valider l’hypothèse ENA, IN1, IN2 seuls branchés sur mon arduino uno (12V à 14V sur la partie puissance, alim via batterie rechargée solaire).

    Les Pins IN3, IN4, ENB peuvent-ils rester libres ou doivent-ils être reliés à la masse ?

    Merci d’avance pour ta réponse
    Jeep

    1. Site passionelectronique.fr

      Salut Jeep !

      En fait, le L298N est composé de deux ponts en H, mis dans le même boitier. Du coup, si tu n’en as besoin que d’un seul pont (le A, dans ton cas), il est effectivement inutile de câbler le second.

      Cela étant dit, en électronique, on évite de laisser « volante » une entrée non utilisée. En effet, on préfèrera toujours la rattacher à un potentiel fixe, afin que les interférences environnantes ne viennent pas, via la logique de ces entrées, générer du bruit sur l’alimentation de ce composant (oscillations parasites), ou des consommations anormales (changements d’état trop fréquents). C’est pourquoi on voit si souvent les entrées non utilisées reliées à la masse, en électronique.

      Donc, dans ton cas, il faudrait par exemple mettre les entrées ENB, IN3, et IN4 à la masse, si non utilisées.

      Voili voilou !
      Bon courage à toi 😉

      Jérôme.

  17. Site passionelectronique.fr

    Salut Jérôme et merci beaucoup pour ce tuto.

    J’ai un montage qui comprend une alim 12V/3Amp max, une carte Arduino UNO, un L298N et deux moteurs 12V XD-3420.

    Je fais face à une forte chute de tension en sortie du L298N qui ne permet pas un bon fonctionnement des moteurs. En effet j’alimente mon L298N avec du 12V sur la partie puissance, et je me retrouve avec seulement 6V, au niveau de chaque moteur. Que dois je faire ? Remplacer le L298N par un composant plus performant ?

    Merci d’avance pour ton aide.
    Didier

    1. Site passionelectronique.fr

      Salut Didier !

      En fait, la chute de tension « aux bornes » d’un L298N est inévitable. Et quand bien même on pourrait trouver mieux comme composant, qu’il y aurait toujours une chute de tension à ce niveau.

      Du coup, je pense que, si j’étais dans ton cas, je passerais sur une tension d’alim supérieure (18 volts, par exemple). Ainsi, même si tu as 6 volts de chute de tension au niveau du L298, tu te retrouverais bien avec 12V arrivant aux moteurs.

      Du reste, il y aurait une chose à vérifier au passage, au niveau de ton montage. Il s’agit du courant consommé par tes moteurs, en situation réelle. Car peut-être que ceux-ci consomment bien plus que ce qui est communiqué par le fabricant, ou dépassent les capacités du L298 (environ 2A de courant max, par pont en H).

      Enfin, il faudrait également vérifier la tension sortant de ton alim 12V / 3A, lorsque tes moteurs sont en charge. Car c’est peut-être simplement ton alim qui flanche, lorsque trop sollicitée, faisant qu’il ne reste plus que 6V au niveau de tes moteurs.

      À voir ! Bon courage à toi 😉
      Jérôme.

  18. Site passionelectronique.fr

    Salut,

    Je suis entrain d’essayer les programmes pour l’accélération et la décélération, cependant la fonction « changeVitesseMoteurPontA » n’est pas définie sur mon ide arduino. il y a t’il une librairie ?

    J’en profite pour te remercier de ce tuto très enrichissant et particulièrement simple a comprendre.

    Cordialement,
    Sofiane Chaouadi

    1. Site passionelectronique.fr

      Salut Sofiane !

      Non, la fonction « changeVitesseMoteurPontA » ne provient pas d’une librairie externe, car elle est bel et bien interne au programme. En fait, si tu regardes le code en détail, tu verras sa définition tout en bas, sous la forme : « void changeVitesseMoteurPontA(int nouvelleVitesse) ».

      Cette fonction ne comprend d’ailleurs qu’une seule ligne, qui est : analogWrite(borneENA, nouvelleVitesse);

      Voilà ! Bon courage à toi 😉
      Jérôme.

  19. Site passionelectronique.fr

    Bonjour

    Par rapport à votre dernier code : si on veut faire tourner deux moteurs, il suffit de rajouter dans les fonctions « digitalWrite(borneIN3, LOW); » et « digitalWrite(borneIN4, HIGH); » (dans la première) et « analogWrite(borneENB, nouvelleVitesse); » dans la deuxième non ?

    Ma question c’était de savoir si votre fonction changeVitesseMoteurPontA(int nouvelleVitesse) génère deux signaux différents pour chaque moteur ou le même ?
    Merci

    1. Site passionelectronique.fr

      Bonsoir Eliott !

      Tu as parfaitement bien compris. Il faut effectivement rajouter ces instructions, dans ces fonctions.

      Par contre, en procédant ainsi, tes deux moteurs tourneront de manière strictement identique.

      C’est pourquoi je te conseille plutôt de loger ton instruction « analogWrite(borneENB, nouvelleVitesse) » dans une autre fonction, que tu nommerais par exemple « changeVitesseMoteurPontB ». Ainsi, tu pourrais piloter les vitesses de tes deux moteurs indépendamment.

      En espérant que ma réponse soit suffisamment claire 😉

      Bon courage à toi !
      Jérôme.

  20. Site passionelectronique.fr

    Salut Jérôme,

    Merci infiniment pour votre tuto.

    Je suis novice en électronique et j’ai une préoccupation. J’aimerais savoir s’il est possible de commander la variation de la vitesse avec une entrée analogique (potentiomètre pas exemple) et s’il est possible d’asservir ce système et comment ?

    Cordialement.🙏
    Franck

    1. Site passionelectronique.fr

      Salut Franck !

      Oui, c’est possible 😉

      Pour t’inspirer, tu peux lire cet article que j’avais fais sur les ESC, qui se pilotent en PWM, comme le L298N (avec potentiomètre branché sur une des entrées analogiques de l’Arduino, comme tu souhaitais).

      Au passage, il ne faudra pas oublier d’effectuer une « conversion d’échelle », entre la valeur 10 bits lue sur une entrée analogique Arduino (valeur retournée entre 0 et 1023, donc), et la valeur 8 bits qu’il faut envoyer à un PWM (entre 0 et 255, donc), pour piloter le L298N (tout ça se fait avec la fonction « map »).

      Après, reste à voir si tu as besoin d’avoir une fonction marche avant / marche arrière dans ton projet, ou pas.

      Voilà 😉

      Bon courage à toi,
      Jérôme.

  21. Site passionelectronique.fr

    Bonjour Jérôme,

    Super tuto, je suis novice et je comprends tout.
    Votre site est une mine d’information.

    Pour réaliser mon projet, j’ai acheté un servomoteur pouvant effectuer des rotations continus dans les deux sens et qui est équipé de trois câbles (noir, rouge, jaune). Je crois comprendre que le L298N ne convient pas pour le fonctionnement de ce matériel.

    Avez vous un lien a me conseiller expliquant le fonctionnement du servomoteur ?

    Merci de votre aide.
    Cédric

    1. Site passionelectronique.fr

      Salut Cédric !

      Non désolé, je n’ai malheureusement pas encore eu le temps de faire un article sur les servomoteurs.

      Du reste, un servomoteur est « assez simple à piloter ». En effet, sur les 3 fils que tu as : le noir est la masse, le rouge l’alim, et le jaune le signal de commande. Le signal de commande est de type PWM, de fréquence 50 Hz, et dont l’état haut doit être compris entre 1 milliseconde (servo tourné à fond dans un sens) et 2 millisecondes (servo tourné à fond dans l’autre sens).

      Tu trouveras un exemple de pilotage PWM Arduino en ce sens ici : https://passionelectronique.fr/esc-modelisme/#exemple-de-code-arduino-pilotage-dun-esc-a-partir-dune-sortie-pwm (en fait, un ESC se pilote « exactement » comme un servomoteur ; donc tu peux t’en inspirer).

      Voilà, et désolé de ne pouvoir t’aider davantage !
      Jérôme.

  22. Site passionelectronique.fr

    Bonsoir,

    Bravo et merci, travail magnifique, je m’y réfère souvent.

    Aujourd’hui, face à un cas de mise en tandem des deux voies pour piloter un moteur de 24V/100W, je remarque ceci qui me pose question :

    "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"

    Mais alors, si la durée de l’impulsion haute est limitée, la fréquence de 80Hz calculée n’est elle pas alors une fréquence MINI et non maxi ?
    Philippe

    1. Site passionelectronique.fr

      Salut Simon !

      Excellente remarque ! Je m’étais effectivement trompé (je viens de corriger). C’est bien une fréquence MINI, pour cette durée MAXI 😉

      Encore merci à toi, et bon courage !
      Jérôme.

  23. Site passionelectronique.fr

    Bonjour Jerome, j’ai besoin d’utiliser la driving chip L298N pour un de mes projets étudiant est-ce possible d’avoir vôtre fichier easyEDA s’il vous plaît ?

  24. Site passionelectronique.fr

    Bonjour Jérôme,

    Je m’apprêtais à commander du matos pour construire un véhicule commandé par Wifi ou BT. Bref, la chose avec laquelle je n’étais pas familier c’était le driver L298. Un grand bravo et un grand merci car sur cette page j’ai trouvé l’essentiel, bien plus que le minimum, en bref tout ce qu’il faut pour être à l’aise avec un driver de moteurs CC à base de L298.

    C’est une superbe page très pédagogique, claire, qui donne envie de la lire. C’était un régal. Bonne continuation.

    Philippe

  25. Site passionelectronique.fr

    Bonjour,

    Merci pour ce très bon tutoriel et les remarques et solutions judicieuses des lecteurs. Je viens de démarrer une réalisation de voiture à 6 roues avec utilisation du contrôleur Raspberry pico et le langage micropython.

  26. Site passionelectronique.fr

    Bonjour à vous,

    Excellent ! Vraiment tous mes remerciements pour cette explication, ce partage. Simple, complet et efficace : quoi demander de mieux ! Bonne fin de journée.

    Jean-Charles

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 milieuAfin de filtrer au maximum les messages de type "spam" ou "inappropriés", chaque commentaire est soumis à modération, et validé manuellement. Du coup, il se peut que certains commentaires ne soient pas publiés, ou sinon, avec un peu de retard. Par ailleurs, j'ai malheureusement plus de messages à traiter que de temps pour y répondre ; c'est pourquoi je ne pourrais pas répondre à tout le monde. Désolé …