Le contrôleur de pont / Moteur en H

Si vous souhaitez mettre en œuvre des projets avec des moteurs nécessitant plus de puissance ou devant être à vitesse variable, vous utilisez généralement des modules avec un pont en H. Ces modules se trouvent sous la rubrique Pilote de moteur ou Pas à pas DC.

Dans de nombreux cas, surtout si vous les recherchez dans les boutiques en ligne, vous les trouverez sous forme de ponts en H double ou de ponts en H doubles. Mais qu'est-ce qu'un pont en H exactement et comment est-il utilisé exactement, cette question de base et toutes les autres questions sur l'utilisation de ces composants devraient être clarifiées dans cet article de blog.

Le matériel et les logiciels de ce blog

Les composants de Tableau 1 servir de matériel de référence pour ce blog, mais en principe n'importe quel pont en H ou microcontrôleur peut être utilisé.

Tableau 1 : Matériel pour le test

Pour pouvoir répliquer ce blog, vous avez besoin des logiciels et bibliothèques suivants:

• IDE Arduino (https://www.arduino.cc/en/Main/Software), il est préférable de télécharger la dernière version ici

Le pont en H ou le régulateur à quatre quadrants

Si vous commencez à chercher le pont en H sur Internet, vous trouverez généralement deux définitions. L'un est le circuit dit en pont, l'autre le contrôleur à quatre quadrants. Les deux sont des ponts en H, mais diffèrent par quelques détails. À proprement parler, un pilote de moteur ou pas à pas DC n'est pas un pont en H, mais un contrôleur à quatre quadrants. Pourquoi il en est ainsi doit être clarifié en comparaison.

Le pont en H - circuit en pont

Le premier pont en H de ce blog sera le circuit du pont. Ceci est également connu dans les milieux spécialisés sous les termes de circuit H ou quart, demi ou pont complet. Il est également appelé à tort dans certains forums un pont de mesure de Wheatstone, mais ce n'est pas correct. Il y en a aussi, mais il y a autre chose par là.

Le pont en H, appelé ci-dessous le circuit en pont, tire son nom de la disposition des composants électriques, principalement des résistances, voir illustration 1.

Illustration 1: Structure de base du circuit en pont, de Wikipedia MovGP0

Si vous prenez le circuit illustré ci-dessus comme base, un circuit en pont n'est rien de plus qu'une connexion en parallèle de deux diviseurs de tension. Cependant, il y a une branche entre les deux diviseurs de tension, c'est pourquoi le circuit de base est comme un "H" et le nom de pont en H en est dérivé.

Ce pont peut être utilisé à la fois pour la tension continue et alternative, mais cela dépend si vous souhaitez mesurer des résistances, des condensateurs ou des bobines. Une autre propriété du circuit en pont est que, en fonction du réglage des résistances, vous pouvez non seulement faire varier le courant et la tension, mais également changer la polarité! Selon le nombre de résistances variables, le circuit en pont est également appelé quart (une résistance), moitié (deux résistances) ou pont complet (toutes les résistances).

Le problème à ce stade est qu'il n'est pas si facile de changer les résistances d'un moteur aussi rapidement.

Le pont en H - régulateur à quatre quadrants

En ce qui concerne le problème ci-dessus, nous arrivons directement au prochain H-Bridge sur notre blog. Ceci est également appelé le contrôleur à quatre quadrants et assume exactement la tâche nécessaire pour contrôler un moteur. Ce pont en H, ci-après dénommé contrôleur à quatre quadrants, peut être trouvé dans de nombreux appareils avec un moteur. Ceci est utilisé du plus petit véhicule à, par exemple, l'ICE de la Deutsche Bahn.

Si vous regardez de près le régulateur à quatre quadrants, voir Figure 2, la structure de base est similaire au circuit en pont.

Illustration 2: Structure de base du régulateur à quatre quadrants, de Wikipedia Biezl

La différence est que les résistances du circuit en pont ont été remplacées par des MOSFET et des diodes de blocage. Le moteur est situé dans l'interconnexion des deux circuits parallèles. Semblable à la modification des résistances du circuit en pont, cela peut changer la polarité. La tension et le courant doivent être correctement réglés aux bornes de connexion.

Cela clarifie déjà le fonctionnement approximatif du contrôleur à quatre quadrants. Il faut maintenant clarifier comment le régulateur à quatre quadrants tire son nom. Selon la façon dont les MOSFET (T1 à T4) sont commutés, l'un des quatre états, les quadrants, peut être utilisé pour le moteur. Tableau 2 répertorie les quatre quadrants, avec les MOSFET pour T1 à T4 Figure 2 sont signifiés.

Table 2: Les quatre quadrants

En fonction des MOSFET commutés, vous pouvez choisir n'importe quel sens de rotation et le type d'accélération du moteur. Comme déjà écrit ci-dessus, la tension et le courant doivent provenir de la source de tension et ne peuvent pas être modifiés dans le contrôleur à quatre quadrants lui-même.

Le conducteur de moteur en pratique

Maintenant que la théorie a été expliquée, le pilote de moteur doit maintenant être assemblé et utilisé dans la pratique. Les composants pour cela peuvent être trouvés dans Tableau 1. En principe, tous nos microcontrôleurs à l'exception de l'ESP-01 sont adaptés à cette tâche.

La première étape est le Nano V3.0. Peu importe que vous utilisiez maintenant le câble USB, voir le Nano figure 3, ou via une alimentation externe, par ex. également via le 5V disponible du pilote de moteur utilisé ici, voir Figure 4, opérez. Les moteurs doivent toujours être alimentés par une batterie ou une batterie rechargeable.

Illustration 3: Nano avec alimentation USB

 Illustration 4: Nano avec alimentation 5V du pont en H

Veuillez noter que si vous utilisez des tensions supérieures à 12 V sur le pilote du moteur, le cavalier 5 V sur le pilote du moteur doit être retiré et une source de tension séparée pour le microcontrôleur est requise.

Pour une simple démonstration de la façon de conduire un petit moteur, vous pouvez Code 1 utilisation.

//-----------------------------------------------------
// Controlling a DC-Motor with Nano V3.0
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 23. Feb 2021
// Update: 23. Feb 2021
//-----------------------------------------------------

//PWM and motor configuration
// Motor A
const int motor1Pin1 = 9;
const int motor1Pin2 = 8;
const int enable1Pin = 10;

void setup() {
Serial.begin(115200);
while (!Serial) {
; //Wait until serial is available
}
Serial.println("Motor control with NANO V3.0");
Serial.println("(c) Joern Weise for AZ-Delivery");
Serial.println("--------------------");
Serial.println("Set outputs");

//Set pins as outputs
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(enable1Pin, OUTPUT);

Serial.println("Setup finished");
}

void loop() {
Serial.println("----- Motor clockwise speedup-----");
digitalWrite(motor1Pin1,HIGH);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,LOW);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}

Serial.println("----- Motor clockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}

Serial.println("----- Motor counterclockwise speedup-----");
digitalWrite(motor1Pin1,LOW);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,HIGH);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}
Serial.println("----- Motor counterclockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}
}

Code 1: Code de démonstration pour Nano V3.0

En principe, le code ne fait pas grand-chose de spectaculaire. Il démarre le moteur une fois dans le sens des aiguilles d'une montre et l'accélère jusqu'à la vitesse maximale. Immédiatement après, le moteur est de nouveau freiné jusqu'à l'arrêt. Pour montrer que cela ne fonctionne pas que dans un sens, le même contrôle est effectué à nouveau dans le sens antihoraire.

Une fois la fonction de boucle exécutée, le processus recommence. Pour que vous puissiez comprendre rapidement ce qui se passe où, de nombreux commentaires ont été ajoutés au code source.

Cela nous amène à la famille ESP à ce stade. Qu'il s'agisse d'un contrôleur de la famille ESP32 ou ESP8266, la connexion est ici aussi presque identique. Le câblage de l'alimentation avec câble USB, voir Figure 5, ou avec la connexion 5V du pilote de moteur, voir Graphique 6, se font aussi rapidement.

Un mot de plus sur la carte de commande de moteur L298N utilisée ici. Par rapport aux cartes L293D, qui conviennent également, un dissipateur thermique pour des courants plus élevés et donc des moteurs plus grands est déjà installé ici. Après avoir initialement utilisé un convertisseur de niveau logique pour les micro-contrôleurs Espressif afin d'ajuster la tension de sortie des GPIO 3,3 V des ESP à 5 V, nous avons découvert dans d'autres expériences que la tension à la broche Enable du MotorDriver est une sorte de référence la tension pour les signaux PWM est; Ainsi, un cycle de service de 100% fournit la pleine tension de sortie pour les moteurs, même à 3,3V. La LLC peut donc être supprimée.

Illustration 5: MicroController de la famille ESP32 avec alimentation USB

llustration 6: MicroController de la famille ESP32 avec alimentation 5V

À ce stade également, le cavalier 5 V doit être retiré pour les tensions supérieures à 12 V sur le pilote du moteur et une source de tension séparée pour le microcontrôleur est nécessaire.

Malheureusement, nous ne pouvons pas reprendre complètement l'exemple de Nano V3.0, voir Code 2, car le signal PWM doit être programmé différemment et nous utilisons également d'autres broches.

//-----------------------------------------------------
// Controlling a DC-Motor with ESP
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 23. Feb 2021
// Update: 23. Feb 2021
//-----------------------------------------------------

//PWM and motor configuration
// Motor A
const int motor1Pin1 = 27;
const int motor1Pin2 = 26;
const int enable1Pin = 14;
const int motor1channel = 0;

// Setting PWM properties
const int freq = 30000;
const int resolution = 8;

void setup() {
Serial.begin(115200);
while (!Serial) {
; //Wait until serial is available
}
Serial.println("Motor control with ESP");
Serial.println("(c) Joern Weise for AZ-Delivery");
Serial.println("--------------------");
Serial.println("Set outputs");

//Set pins as outputs
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(enable1Pin, OUTPUT);

Serial.println("Configurate motorchannel");
ledcSetup(motor1channel, freq, resolution);
//Configurate PWM for motor 1
ledcAttachPin(enable1Pin, motor1channel);
//Attach channel 1 to motor 1
Serial.println("Setup finished");
}

void loop() {
Serial.println("----- Motor clockwise speedup-----");
digitalWrite(motor1Pin1,HIGH);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,LOW);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}
Serial.println("----- Motor clockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}

Serial.println("----- Motor counterclockwise speedup-----");
digitalWrite(motor1Pin1,LOW);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,HIGH);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}
Serial.println("----- Motor counterclockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}
}

Code 2: Démocode pour MicroController der ESP32-Familie

Comme pour le Nano V3.0, il y a beaucoup de commentaires dans ce code, ce qui vous permet de voir rapidement ce qui se passe où. Portez une attention particulière à la fonction de configuration, où le PWM est déclaré. Par "ledcSetup (motor1channel, freq, resolution) ;" vous déclarez un canal PWM avec une résolution de 8bit et une fréquence de30kHz. Juste après, le canal PWM est lié à la broche de sortie par "ledcAttachPin (iPWMPin, motor1channel) ;".

Comme vous pouvez le constater, la commande d'un moteur au moyen d'un pont en H ou mieux d'un driver de moteur n'est pas une grande affaire de sorcellerie. Le principe de la commande est simple, la logique pure, quand le moteur doit faire quoi, doit être traitée proprement dans votre code. Vous trouverez un exemple simple dans l'article du blog intitulé "Controlling a Robot with MQTT - [Part 3]". Cependant, un tel pont en H est nécessaire pour permettre aux moteurs de tourner à une vitesse et dans une direction raisonnables.

Vous pouvez d'ores et déjà vous réjouir des prochaines contributions au thème central Voitures-robots, où vous retrouverez très probablement un H-Bridge ou un Motor Driver.

Ce projet et d'autres sont disponibles sur GitHub à l'adresse suivante: https://github.com/M3taKn1ght/Blog-Repo.