PTA 2 Contrôle d’un moteur module BTS7960

Introduction

Cet article présente une implémentation Arduino permettant de contrôler un moteur à l’aide du pilote BTS7960. Le programme gère la mise en marche, l’arrêt, la variation progressive de vitesse et le changement de direction du moteur. Il intègre également la mesure de la puissance électrique consommée en utilisant un capteur de courant ACS712 et un capteur de tension.

Le BTS7960 est un pilote de moteur haute puissance largement utilisé dans les applications de robotique et d’automatisation. Il est conçu pour commander des moteurs à courant continu (DC) et offre une gestion efficace du courant et de la protection thermique. En mars 2025, on le trouve pour une dizaine d’euros.

Le module BTS7960

Caractéristiques principales

Le BTS7960 est un pont en H conçu pour piloter des moteurs nécessitant un courant élevé. Voici ses principales caractéristiques :

Tension de fonctionnement : 5,5V à 27V
Courant maximal : 43A
Protection thermique et contre les surintensités
Compatible avec les microcontrôleurs 3,3V et 5V (ESP32, Arduino, Raspberry Pi, etc.)
Commande par signal PWM jusqu’à 25 kHz
Faible résistance interne (~16 mΩ) pour une meilleure efficacité

Schéma de connexion

Le module BTS7960 est souvent disponible sous la forme d’une carte avec des connecteurs facilitant son usage. Voici les broches les plus importantes :

VCC : Alimentation logique (5V)
GND : Masse
RPWM : Signal PWM pour la rotation dans un sens
LPWM : Signal PWM pour la rotation dans l’autre sens
REN : Activation de la commande RPWM
LEN : Activation de la commande LPWM
IS : Sortie de détection de courant (facultatif)

Un exemple de connexion avec un Arduino :

Arduino  | BTS7960
-------------------
5V       | VCC
GND      | GND
9        | RPWM
10       | LPWM
8        | REN
7        | LEN

Fonctionnement

Le BTS7960 fonctionne en utilisant deux signaux PWM et deux broches d’activation.

Pour avancer : Activer LEN et envoyer un signal PWM sur LPWM
Pour reculer : Activer REN et envoyer un signal PWM sur RPWM
Pour arrêter : Désactiver LEN et REN

Un exemple de code avec Arduino :

C++

#define RPWM 9
#define LPWM 10
#define REN 8
#define LEN 7

void setup() {
  pinMode(RPWM, OUTPUT);
  pinMode(LPWM, OUTPUT);
  pinMode(REN, OUTPUT);
  pinMode(LEN, OUTPUT);
  digitalWrite(REN, HIGH);
  digitalWrite(LEN, HIGH);
}

void loop() {
  analogWrite(RPWM, 150); // Avancer à 60% de la puissance
  analogWrite(LPWM, 0);
  delay(2000);
  
  analogWrite(RPWM, 0);
  analogWrite(LPWM, 150); // Reculer à 60%
  delay(2000);
}

Avantages et inconvénients

Avantages :

✅ Haute capacité en courant (43A) ✅ Protection thermique et contre les surintensités ✅ Compatible avec Arduino, ESP32 et Raspberry Pi ✅ Utilisation simple avec deux signaux PWM

Inconvénients :

❌ Nécessite un bon refroidissement pour les courants élevés ❌ Plus encombrant qu’un simple L298N ❌ Commande plus complexe qu’un pont en H basique

Le module ACS712 20A

Le capteur de courant ACS712 20A est un capteur très populaire pour mesurer le courant électrique en toute sécurité dans divers projets électroniques et électriques. Il est utilisé aussi bien par les amateurs que par les professionnels grâce à sa simplicité d’utilisation et sa précision. Cet article explore en détail le fonctionnement, les caractéristiques techniques, le câblage et l’utilisation de ce capteur avec un microcontrôleur comme l’Arduino.

1. Présentation du Capteur ACS712 20A

L’ACS712 est un capteur de courant basé sur l’effet Hall, fabriqué par Allegro Microsystems. Il permet de mesurer des courants alternatifs (AC) et continus (DC) tout en offrant une isolation galvanique entre la charge et la sortie du capteur.

Le modèle ACS712 20A est conçu pour mesurer des courants allant jusqu’à ±20A. Il fait partie d’une gamme de capteurs comprenant aussi des modèles pour 5A et 30A.

Applications courantes :

Surveillance de la consommation électrique
Systèmes de gestion de l’énergie
Protection et diagnostic des circuits électriques
Mesure de courant dans des moteurs et des alimentations
Intégration dans des projets Arduino et Raspberry Pi

2. Caractéristiques Techniques

Voici les spécifications principales de l’ACS712 20A :

Propriété	Valeur
Modèle	ACS712ELCTR-20A-T
Plage de mesure	-20A à +20A
Sensibilité	100 mV/A
Tension d’alimentation	5V
Consommation	10 mA
Isolation galvanique	Oui
Sortie	Signal analogique
Temps de réponse	5 µs
Précision	±1,5 %
Température de fonctionnement	-40°C à 85°C

3. Fonctionnement du Capteur

L’ACS712 utilise un circuit à effet Hall pour mesurer le champ magnétique généré par le courant qui traverse son circuit intégré. Ce champ est converti en tension proportionnelle à l’intensité du courant.

La tension de sortie est centrée sur 2,5V pour un courant nul :

Si le courant circule dans un sens, la tension de sortie augmente proportionnellement.
Si le courant circule dans l’autre sens, la tension diminue proportionnellement.

Le capteur fournit une sensibilité de 100 mV/A, ce qui signifie que pour un courant de 10A, la tension de sortie sera : Vout=2.5V+(10A×0.1V/A)=3.5VV_{out} = 2.5V + (10A \times 0.1V/A) = 3.5V Et pour -10A : Vout=2.5V−(10A×0.1V/A)=1.5VV_{out} = 2.5V – (10A \times 0.1V/A) = 1.5V

4. Schéma de Câblage avec un Arduino

L’ACS712 se connecte facilement à un microcontrôleur tel qu’un Arduino. Voici le schéma de câblage typique :

Matériel nécessaire :

1x Arduino Uno
1x Capteur ACS712 20A
1x Résistance de charge
Fils de connexion

Connexions :

ACS712	Arduino
VCC (5V)	5V
GND	GND
OUT	A0 (entrée analogique)

Le courant à mesurer doit passer par les bornes IP+ et IP- du capteur.

5. Code Arduino pour Lire le Courant

Voici un exemple de code pour mesurer le courant avec un Arduino :

C++

const int capteurPin = A0;
float sensibilité = 0.1;  // Sensibilité de 100 mV/A pour ACS712 20A
float Vcc = 5.0;
float zeroCurrentVoltage = Vcc / 2;

void setup() {
    Serial.begin(9600);
}

void loop() {
    int valeurBrute = analogRead(capteurPin);
    float tension = (valeurBrute / 1023.0) * Vcc;
    float courant = (tension – zeroCurrentVoltage) / sensibilité;
    
    Serial.print("Courant mesuré : ");
    Serial.print(courant);
    Serial.println(" A");
    
    delay(1000);
}

Explication du Code

Lecture de la valeur analogique provenant du capteur.
Conversion en tension en utilisant la tension de référence (5V).
Calcul du courant en soustrayant la tension au repos (2.5V) puis en divisant par la sensibilité (0.1V/A).
Affichage des valeurs sur le moniteur série.

6. Précautions d’Utilisation

Ne dépassez jamais les 20A, au risque d’endommager le capteur.
Ajoutez un fusible en série avec le capteur pour protéger le circuit.
Evitez les interférences électromagnétiques, car l’effet Hall est sensible aux champs magnétiques externes.
Utilisez un filtre logiciel si la mesure est bruitée.

Diviseur de tension 25V

L’Arduino possède un convertisseur analogique-numérique (ADC) qui permet de mesurer une tension sur ses entrées analogiques. L’ADC de l’Arduino est généralement de 10 bits, ce qui signifie qu’il peut lire des valeurs comprises entre 0 et 1023, où 0 correspond à 0V et 1023 correspond à 5V (tension de référence).

Le code suivant montre comment lire la tension à partir de la broche analogique A0 (où la tension de 5V sera mesurée après la division) et la convertir pour obtenir la tension d’origine (25V).

C++

// Définir la broche analogique utilisée pour mesurer la tension divisée
int sensorPin = A0;  
float Vout = 0.0;  // Tension mesurée à la broche A0
float Vin = 0.0;   // Tension d'entrée calculée (avant diviseur)
int sensorValue = 0;  // Valeur lue par l'ADC de l'Arduino

void setup() {
  // Initialisation de la communication série pour afficher les résultats
  Serial.begin(9600);
}

void loop() {
  // Lire la valeur brute de l'ADC
  sensorValue = analogRead(sensorPin);

  // Calculer la tension de sortie (en V)
  Vout = (sensorValue * 5.0) / 1023.0; 

  // Calculer la tension d'entrée d'origine (avant diviseur de tension)
  // La relation entre Vout et Vin est donnée par :
  // Vout = Vin * (R2 / (R1 + R2))
  // Ici, Vout est la tension après le diviseur et Vin est la tension d'entrée
  Vin = Vout * (1 + (2500.0 / 10000.0));  // (R1=10kΩ, R2=2,5kΩ)

  // Afficher les résultats dans le moniteur série
  Serial.print("Tension mesurée : ");
  Serial.print(Vout, 3);  // Afficher la tension de sortie (Vout)
  Serial.print(" V, ");
  Serial.print("Tension d'entrée estimée : ");
  Serial.print(Vin, 3);  // Afficher la tension d'entrée estimée
  Serial.println(" V");

  // Attendre 1 seconde avant la prochaine lecture
  delay(1000);
}

Expérimentation

Matériel requis

Carte Arduino (Uno, Mega, etc.)
Module BTS7960 (pilote moteur haute puissance)
Capteur de courant ACS712 20A
Capteur de tension (pont diviseur ou module DCT Electronic)
Moteur électrique 12V
Alimentation adaptée

Définition des broches

Le BTS7960 utilise quatre broches pour le contrôle du moteur :

RPWM_ PIN (5) : Signal PWM pour la rotation dans un sens
LPWM_ PIN (6) : Signal PWM pour la rotation dans l’autre sens
REN_ PIN (7) : Action du module
LEN_ PIN (7) : Activation du module
ACS712 20A PIN A1 : Mesure de l’ampérage
Diviseur tension PIN A2 : Mesure de la tension

Schéma

Classe BTS7960 : Contrôle du moteur

Une classe BTS7960 est définie pour encapsuler les fonctionnalités du pilote moteur. Elle permet :

L’initialisation des broches avec begin()
L’arrêt du moteur avec stop()
La gestion de la vitesse avec setSpeed(int speed)
La modification de la direction avec setDirection(bool dir)
L’arrêt d’urgence emergencyStop()
Une augmentation ou réduction progressive de la vitesse avec gradualSpeedChange(int targetSpeed, int step, int delayTime)
La récupération de l’état du moteur avec getMotorState()

Mesure de la puissance électrique

Mesure de la tension

Une fonction mesurerTension(int brocheAnalogique) mesure la tension à l’aide d’un convertisseur analogique-numérique de l’Arduino.

Calibration du capteur de courant

La fonction calibrerOffset(int brocheAnalogique) mesure un offset initial du capteur ACS712 pour compenser les erreurs de mesure.

Mesure du courant

mesurerCourant(int brocheAnalogique) calcule le courant absorbé en utilisant la tension mesurée et la sensibilité du capteur.

Calcul de la puissance

La fonction puissance(String libelle) calcule la puissance instantanée P = V * I et affiche les valeurs mesurées.

Fonctionnement du programme

Le programme suit ces étapes :

Initialisation du moniteur série et du pilote moteur.
Mesure initiale de la puissance consommée (START).
Calibration du capteur de courant (CALIB).
Accélération progressive du moteur (ACCEL).
Attente de 10 secondes en régime de croisière (RUN).
Décélération progressive jusqu’à l’arrêt (BRAKE).
Arrêt complet du moteur (STOP).

Source

C++

// Définition des broches pour le BTS7960
#define RPWM_PIN 5
#define LPWM_PIN 6
#define REN_PIN 7
#define LEN_PIN 7

#define SENSITIVITY 0.1  // Sensibilité du capteur ACS712 20A (100 mV/A)

class BTS7960 {
  private:
    int RPWM;
    int LPWM;
    int REN;
    int LEN;
    int pwmValue;
    bool direction; // true: avant, false: arrière

  public:
    BTS7960(int rpwm, int lpwm, int ren, int len) {
      RPWM = rpwm;
      LPWM = lpwm;
      REN = ren;
      LEN = len;
      pwmValue = 0;
      direction = true;
    }

    void begin() {
      pinMode(RPWM, OUTPUT);
      pinMode(LPWM, OUTPUT);
      pinMode(REN, OUTPUT);
      pinMode(LEN, OUTPUT);
      digitalWrite(REN, HIGH);
      digitalWrite(LEN, HIGH);
      delay(100);
    }

    void stop() {
      digitalWrite(REN, LOW);
      digitalWrite(LEN, LOW);
    }

    void setSpeed(int speed) {
      speed = constrain(speed, 0, 255);
      pwmValue = speed;
      if (direction) {
        analogWrite(LPWM, 0);
        analogWrite(RPWM, pwmValue);

      } else {
        analogWrite(RPWM, 0);
        analogWrite(LPWM, pwmValue);
      }
    }

    void setDirection(bool dir) {
      direction = dir;
    }

    void emergencyStop() {
      analogWrite(RPWM, 0);
      analogWrite(LPWM, 0);
    }

    void gradualSpeedChange(int targetSpeed, int step, int delayTime) {
      targetSpeed = constrain(targetSpeed, 0, 255);
      while (pwmValue != targetSpeed) {
        if (pwmValue < targetSpeed) {
          pwmValue = min(pwmValue + step, targetSpeed);
        } else {
          pwmValue = max(pwmValue – step, targetSpeed);
        }
        setSpeed(pwmValue);
        delay(delayTime);
      }
    }

    String getMotorState() {
      String state = "SPE=" + String(pwmValue) + ";DIR=" + (direction ? "FORE" : "BACK") + ";RPWN=" +
                     String(RPWM) + ";LPWN=" + String(LPWM) + ";REN=" + String(REN) + ";LEN=" + String(LEN);
      return state;
    }
};


BTS7960 motor(RPWM_PIN, LPWM_PIN, REN_PIN, LEN_PIN);
float offset = 2.5; 

float mesurerTension(int brocheAnalogique) {
  int valeur_ADC = analogRead(brocheAnalogique);
  float V_out = (valeur_ADC * 5.0) / 1024.0;
  return V_out * 5.0;
}

void calibrerOffset(int brocheAnalogique) {
  float somme = 0;
  int echantillons = 100;
  for (int i = 0; i < echantillons; i++) {
    somme += (analogRead(brocheAnalogique) / 1024.0) * 5.0;
    delay(5);
  }
  offset = somme / echantillons;
}

float mesurerCourant(int brocheAnalogique) {
  int valeurBrute = analogRead(brocheAnalogique);
  float tension = (valeurBrute / 1024.0) * 5.0;
  float courant = (tension – offset) / SENSITIVITY;
  return abs(courant);
}

void puissance(String libelle) {
  float v, i, p;
  String w;
  v = mesurerTension(A2);
  i = mesurerCourant(A1);
  p = v * i;
  w = libelle + " P=" + String(p) + " V=" + String(v) + " I=" + String(i);
  Serial.println(w);
  Serial.println(motor.getMotorState());
}

void setup() {
  Serial.begin(9600);
  motor.begin();
  delay(5000);
  puissance("START ");
  calibrerOffset(A1);
  puissance("CALIB ");
  motor.setSpeed(12);
  motor.gradualSpeedChange(64, 5, 200);
  puissance("ACCEL ");
  delay(10000);
  puissance("RUN   ");
  motor.gradualSpeedChange(0, 5, 200);
  puissance("BRAKE ");
  motor.stop();
  puissance("STOP  ");
}

void loop() {
}

Conclusion

Ce projet permet de piloter un moteur à l’aide du BTS7960 tout en surveillant sa consommation électrique. Il peut être adapté à divers besoins en robotique et automatisation. Des améliorations possibles incluent l’ajout d’un système de communication pour transmettre les données en temps réel à une interface de contrôle.

Grimeco