← Retour à l’aperçu

Carte de commande de moteur L298N rouge – 1

Carte de commande de moteur L298N rouge – 2

Carte de commande de moteur L298N rouge – 3

Carte de commande de moteur L298N rouge – 4

Carte de commande de moteur L298N rouge

Name: Carte de commande de moteur L298N rouge
Brand: OTRONIC
SKU: OT2099-B41
Price: 2.60 EUR
Availability: InStock

SKU: OT2099-B41 Numéro d’article: AA034 EAN: 8720589817425

€ 2,60 TTC (€ 2,15 HT)

Carte de commande de moteur L298N – double pont en H pour moteurs à courant continu et moteurs pas à pas

Avec cette carte de commande de moteur L298N, vous pouvez facilement piloter des moteurs à courant continu et des moteurs pas à pas avec, par exemple, un Arduino, un ESP32, un Raspberry Pi, un microcontrôleur ou tout autre système de commande numérique.

Le module est basé sur le célèbre pilote de moteur L298N Dual H-Bridge. Grâce aux deux ponts en H intégrés, vous pouvez commander indépendamment deux moteurs à courant continu à balais, y compris le sens de rotation et le réglage de la vitesse. De plus, le module peut être utilisé pour piloter un moteur pas à pas bipolaire.

L’alimentation moteur peut, selon les spécifications de ce module, se situer entre 5 et 35 V DC. La logique fonctionne en 5 V. Le L298N prend en charge un courant allant jusqu’à 2 A par canal dans des conditions appropriées, un bon refroidissement étant important en cas de charges plus élevées.

Adapté aux moteurs à courant continu

Le L298N n’est pas uniquement destiné aux moteurs pas à pas. La carte est très adaptée au contrôle de moteurs à courant continu à balais ordinaires.

Avec un seul module, il est possible de commander séparément jusqu’à deux moteurs à courant continu :

Moteur A via OUT1 et OUT2
Moteur B via OUT3 et OUT4

Via les entrées numériques, vous pouvez déterminer le sens de rotation de chaque moteur. Via les connexions ENA et ENB, un signal PWM peut en outre être appliqué pour régler la vitesse des moteurs.

Cela permet notamment les fonctions suivantes :

Faire tourner le moteur vers l’avant
Faire tourner le moteur vers l’arrière
Arrêter le moteur
Freinage électrique
Régler la vitesse avec PWM
Commander deux moteurs indépendamment l’un de l’autre

Cela rend le module adapté, entre autres, aux voitures robotisées, véhicules, petites machines, actionneurs, ventilateurs et autres projets avec moteurs à courant continu.

Adapté aux moteurs pas à pas

Les deux ponts en H peuvent également être utilisés ensemble pour piloter un moteur pas à pas bipolaire. Les quatre sorties moteur OUT1 à OUT4 sont alors connectées aux deux bobines du moteur pas à pas.

L’ordre dans lequel IN1 à IN4 sont commandées détermine ensuite le sens de rotation et la séquence de pas.

Réglage de la vitesse avec PWM

Pour les moteurs à courant continu, la vitesse peut être réglée via PWM (Pulse Width Modulation).

Pour cela, les cavaliers de ENA et/ou ENB sont retirés et ces connexions sont reliées à une sortie PWM du microcontrôleur.

ENA : activation/PWM pour le moteur A
ENB : activation/PWM pour le moteur B

Lorsque le cavalier correspondant reste en place, le canal est activé en continu et le moteur peut être commandé via les broches IN sans signal PWM séparé.

Connexions

Alimentation

Alimentation moteur / VS
Connexion pour la tension d’alimentation des moteurs.

GND
Masse commune pour l’alimentation et la commande. La GND du microcontrôleur et celle du pilote moteur doivent être reliées entre elles.

5V
Connexion 5 V pour la logique du module. Selon la configuration du régulateur 5 V et du cavalier, cette connexion peut fonctionner comme entrée ou sortie d’alimentation.

Moteur A

OUT1 / OUT2
Sortie du pont en H A. Le moteur à courant continu A y est connecté.

IN1 / IN2
Entrées de commande numériques qui déterminent le sens de rotation du moteur A.

ENA
Entrée d’activation du moteur A. Peut également être utilisée pour le réglage de vitesse PWM.

Moteur B

OUT3 / OUT4
Sortie du pont en H B. Le moteur à courant continu B y est connecté.

IN3 / IN4
Entrées de commande numériques qui déterminent le sens de rotation du moteur B.

ENB
Entrée d’activation du moteur B. Peut également être utilisée pour le réglage de vitesse PWM.

Commande d’un moteur à courant continu

ENA	IN1	IN2	Fonction
HIGH	HIGH	LOW	Sens de rotation 1
HIGH	LOW	HIGH	Sens de rotation 2
HIGH	LOW	LOW	Arrêt/freinage
HIGH	HIGH	HIGH	Arrêt/freinage
LOW	X	X	Sortie désactivée

Le sens de rotation réel dépend de la manière dont les deux fils du moteur sont connectés à OUT1 et OUT2.

Pour le moteur B, la commande fonctionne de la même manière via IN3, IN4 et ENB.

Spécifications techniques

Type : carte de commande de moteur L298N
CI pilote : L298N
Technologie de pilotage : double pont en H / double pont complet
Convient pour : moteurs à courant continu à balais et moteurs pas à pas bipolaires
Nombre de moteurs CC : jusqu’à 2 moteurs commandés indépendamment
Nombre de moteurs pas à pas bipolaires : 1 maximum
Tension d’alimentation logique : 5 V DC
Tension d’alimentation moteur du module : 5 – 35 V DC
Courant moteur maximal indiqué : 2 A
Commande : logique numérique
Réglage de vitesse moteur CC : PWM via ENA et ENB
Réglage du sens de rotation : oui
Double pont en H : oui
Dissipateur thermique : oui
Sorties moteur : OUT1, OUT2, OUT3 et OUT4
Entrées de commande : IN1, IN2, IN3 et IN4
Entrées d’activation : ENA et ENB
Dimensions : environ 43 × 43 × 27 mm
Longueur : 43 mm
Largeur : 43 mm
Hauteur : 27 mm
Couleur du circuit imprimé : rouge

Pilote L298N

Le L298N utilisé est un pilote double pont complet spécialement conçu pour la commutation de charges inductives telles que les moteurs à courant continu, les moteurs pas à pas, les relais et les solénoïdes. Selon le fabricant, le L298 lui-même prend en charge une tension d’alimentation moteur allant jusqu’à 46 V et dispose notamment d’une protection thermique.

Sur ce module complet, une tension d’alimentation moteur de 5 à 35 V DC est prévue.

Attention au courant moteur

Le courant maximal indiqué de 2 A doit être considéré comme la valeur maximale du pilote. À des courants moteurs continus plus élevés, des pertes de chaleur importantes se produisent dans le L298N. Le courant continu réellement exploitable dépend donc notamment de la tension d’alimentation, du refroidissement, de la température ambiante et de la charge.

Vérifiez en outre non seulement le courant nominal d’un moteur à courant continu, mais aussi le courant de démarrage et le courant de blocage (stall current). Celui-ci peut être plusieurs fois supérieur au courant en fonctionnement normal.

Chute de tension dans le pilote

Le L298N utilise des transistors de sortie bipolaires et présente donc une chute de tension plus importante que les pilotes de moteur MOSFET modernes. La tension réellement appliquée au moteur est donc inférieure à la tension d’alimentation fournie.

Cela est particulièrement important pour les moteurs basse tension. Pour les applications où un rendement très élevé ou une très faible chute de tension est important, un pilote MOSFET moderne peut être un meilleur choix.

Applications

Projets Arduino
Projets ESP32
Voitures robotisées
Robotique
Entraînements à deux roues
Commande de moteurs CC
Commande de moteurs PWM
Moteurs réversibles
Moteurs pas à pas bipolaires
Petites machines et mécanismes
Électronique de prototypage et de loisir
Projets éducatifs
Projets d’automatisation

Dimensions

Longueur : 4,3 cm
Largeur : 4,3 cm
Hauteur : 2,7 cm

En résumé

La carte de commande de moteur L298N est un double pont en H polyvalent pour piloter aussi bien des moteurs à courant continu ordinaires que des moteurs pas à pas. Avec un seul module, deux moteurs CC peuvent être commandés indépendamment en marche avant et arrière, et leur vitesse peut être réglée via PWM. En alternative, les deux ponts en H peuvent être utilisés ensemble pour un moteur pas à pas bipolaire.

Grâce à sa commande numérique simple, ce module est très adapté à une utilisation avec Arduino, ESP32 et d’autres microcontrôleurs.

Lire plus

Schéma de câblage et exemple de code

Voici comment connecter le Carte de commande de moteur L298N rouge à un Arduino UNO ou à un ESP32, avec un exemple de sketch que tu peux téléverser directement.

Arduino UNO ESP32 DevKit V1

Commande du driver de moteur L298N avec Arduino Uno

Cet exemple montre comment contrôler des moteurs DC à l’aide d’une carte driver de moteur L298N. L’Arduino définit le sens de rotation du moteur via des broches logiques numériques et ajuste la vitesse du moteur à l’aide du PWM sur la broche enable. Le programme fait avancer les moteurs, les arrête, puis les fait tourner en sens inverse.

Schéma de câblage : Carte de commande de moteur L298N rouge sur un Arduino UNO — Schéma de câblage · Cliquez pour agrandir

Tableau de câblage : Carte de commande de moteur L298N rouge sur un Arduino UNO — Tableau de câblage · Cliquez pour agrandir

L298N_Motor_Driver_Control_with_Arduino_.ino · compilé et testé

/*
 * ==================================================================
 *  Generated by Codey.online  —  https://www.codey.online
 * ==================================================================
 *  Project   : L298N Motor Driver Control with Arduino Uno
 *  Board     : Arduino UNO (arduino:avr:uno)
 *  Parts     : L298N Motor Driver Board
 *  Libraries : none (built-in)
 *
 *  Codey Online is an AI-powered browser IDE for Arduino and ESP32.
 *  Describe your project and Codey writes the code, draws the wiring
 *  diagram and uploads it to your board, straight from the browser.
 *  This code is free to use, modify and share, without warranty.
 * ==================================================================
 */

// L298N Motor Driver Control Demo

const int ENA_PIN = 5;   // PWM speed control
const int IN1_PIN = 8;   // Motor A direction 1
const int IN2_PIN = 9;   // Motor A direction 2
const int IN3_PIN = 10;  // Motor B direction 1
const int IN4_PIN = 11;  // Motor B direction 2

void stopMotors() {
  digitalWrite(IN1_PIN, LOW);
  digitalWrite(IN2_PIN, LOW);
  digitalWrite(IN3_PIN, LOW);
  digitalWrite(IN4_PIN, LOW);
  analogWrite(ENA_PIN, 0);
}

void driveForward(int speedVal) {
  digitalWrite(IN1_PIN, HIGH);
  digitalWrite(IN2_PIN, LOW);
  digitalWrite(IN3_PIN, HIGH);
  digitalWrite(IN4_PIN, LOW);
  analogWrite(ENA_PIN, speedVal);
}

void driveReverse(int speedVal) {
  digitalWrite(IN1_PIN, LOW);
  digitalWrite(IN2_PIN, HIGH);
  digitalWrite(IN3_PIN, LOW);
  digitalWrite(IN4_PIN, HIGH);
  analogWrite(ENA_PIN, speedVal);
}

void setup() {
  Serial.begin(115200);
  pinMode(ENA_PIN, OUTPUT);
  pinMode(IN1_PIN, OUTPUT);
  pinMode(IN2_PIN, OUTPUT);
  pinMode(IN3_PIN, OUTPUT);
  pinMode(IN4_PIN, OUTPUT);

  stopMotors();
  Serial.println(F("L298N Motor Driver initialized."));
}

void loop() {
  Serial.println(F("Driving forward"));
  driveForward(200);
  delay(2000);

  Serial.println(F("Stopping"));
  stopMotors();
  delay(1000);

  Serial.println(F("Driving reverse"));
  driveReverse(200);
  delay(2000);

  Serial.println(F("Stopping"));
  stopMotors();
  delay(1000);
}

Afficher tout le codeAfficher moins de code

Wiring diagram and example code generated by Codey.online — https://www.codey.online

Commande de deux moteurs DC avec ESP32 et L298N

Ce projet contrôle deux moteurs DC à l’aide d’un ESP32 et d’un driver en pont en H L298N. Le sketch fait tourner les deux moteurs en avant, les arrête, les fait tourner en arrière et illustre le contrôle de la vitesse en PWM. Connectez une alimentation externe à la borne 12V du L298N afin de fournir assez de courant pour des moteurs plus puissants.

Schéma de câblage : Carte de commande de moteur L298N rouge sur un ESP32 DevKit V1 — Schéma de câblage · Cliquez pour agrandir

Tableau de câblage : Carte de commande de moteur L298N rouge sur un ESP32 DevKit V1 — Tableau de câblage · Cliquez pour agrandir

ESP32_Dual_DC_Motor_Control_with_L298N.ino · compilé et testé

/*
 * ==================================================================
 *  Generated by Codey.online  —  https://www.codey.online
 * ==================================================================
 *  Project   : ESP32 Dual DC Motor Control with L298N
 *  Board     : ESP32 DEVKIT V1 (esp32:esp32:esp32doit-devkit-v1)
 *  Parts     : L298N Motor Driver Board
 *  Libraries : none (built-in)
 *
 *  Codey Online is an AI-powered browser IDE for Arduino and ESP32.
 *  Describe your project and Codey writes the code, draws the wiring
 *  diagram and uploads it to your board, straight from the browser.
 *  This code is free to use, modify and share, without warranty.
 * ==================================================================
 */

const int ENA_PIN = 14;
const int IN1_PIN = 27;
const int IN2_PIN = 26;
const int IN3_PIN = 25;
const int IN4_PIN = 33;
const int ENB_PIN = 32;

void setMotors(int speedA, int dirA, int speedB, int dirB) {
  // Motor A direction
  if (dirA > 0) {
    digitalWrite(IN1_PIN, HIGH);
    digitalWrite(IN2_PIN, LOW);
  } else if (dirA < 0) {
    digitalWrite(IN1_PIN, LOW);
    digitalWrite(IN2_PIN, HIGH);
  } else {
    digitalWrite(IN1_PIN, LOW);
    digitalWrite(IN2_PIN, LOW);
  }
  analogWrite(ENA_PIN, speedA);

  // Motor B direction
  if (dirB > 0) {
    digitalWrite(IN3_PIN, HIGH);
    digitalWrite(IN4_PIN, LOW);
  } else if (dirB < 0) {
    digitalWrite(IN3_PIN, LOW);
    digitalWrite(IN4_PIN, HIGH);
  } else {
    digitalWrite(IN3_PIN, LOW);
    digitalWrite(IN4_PIN, LOW);
  }
  analogWrite(ENB_PIN, speedB);
}

void setup() {
  Serial.begin(115200);
  pinMode(ENA_PIN, OUTPUT);
  pinMode(IN1_PIN, OUTPUT);
  pinMode(IN2_PIN, OUTPUT);
  pinMode(IN3_PIN, OUTPUT);
  pinMode(IN4_PIN, OUTPUT);
  pinMode(ENB_PIN, OUTPUT);
  Serial.println("L298N Motor Driver Initialized");
}

void loop() {
  // Drive forward
  Serial.println("Moving Forward");
  setMotors(200, 1, 200, 1);
  delay(2000);

  // Stop
  Serial.println("Stopping");
  setMotors(0, 0, 0, 0);
  delay(1000);

  // Drive backward
  Serial.println("Moving Backward");
  setMotors(200, -1, 200, -1);
  delay(2000);

  // Stop
  Serial.println("Stopping");
  setMotors(0, 0, 0, 0);
  delay(1000);

  // Speed ramp up
  Serial.println("Ramping Speed Forward");
  for (int spd = 0; spd <= 255; spd += 15) {
    setMotors(spd, 1, spd, 1);
    delay(100);
  }
  delay(500);
  setMotors(0, 0, 0, 0);
  delay(1500);
}

Afficher tout le codeAfficher moins de code

Wiring diagram and example code generated by Codey.online — https://www.codey.online