Tutoriel: d’utilisation du shield contrôleur de moteurs L293D avec Arduino
Principe de fonctionnement
Le shield L293D s’emboîte directement sur une carte Arduino (Uno, Mega…) et rajoute des fonctions de commande de moteur à courant continu et pas à pas : réglage de la vitesse (par pas de 0.5%) et du sens de rotation des moteurs.
Il peut gérer simultanément grâce à 4 ponts en H :
4 moteurs à courant continu DC ou 2 moteurs pas à pas (unipolaires ou bipolaires) en mode une seule bobine, double bobine, demi pas, ou micro pas.
Il gère en même temps 2 servomoteurs de modélisme (standard 5V).
Une librairie permet de gérer les accélérations et freinages des moteurs pas à pas.
Le PWM peut aussi commander un solénoïde, une intensité d’éclairage, un relais…avec les 8 demi ponts.
Caractéristiques techniques
L’alimentation des moteurs est possible entre 4.5 V et 36V.
Il y a 4 canaux de haute tension, haute intensité avec 0.6A par pont (1.2A en courant de crête) avec protection thermique.
Un bouton de reset.
Des résistances de pull down désactivent les moteurs au cours de la mise sous tension.
2 interfaces d’alimentation pour séparer la partie logique de la partie puissance (moteurs)
Le shield comporte 2 puces L293D, drivers de moteurs, et un registre à décalage 74HC595. Celui ci étend 3 pins de l’Arduino vers 8 pins pour contrôler la direction des drivers de moteurs.
Les sorties output enable des L293D sont directement connectées aux sorties PWM de l’Arduino (modulation de largeur d’impulsions), pour le contrôle de la vitesse de rotation des moteurs.
Une entrée 5V permet de ne pas utiliser le 5V de la carte Arduino pour alimenter les servo moteurs et éviter de faire chauffer la carte.
Pins utilisés
Les pins digitales utilisées par le shield sont les 3, 4, 5, 6, 7, 8, 9, 10, 11, 12.
Le registre à décalage utilise les pins 4 7 8 12.
Les pins 9 et 10 ne servent qu’aux servo-moteurs.
Pour la liaison série on utilise 0 (RX) et 1 (TX). Le SPI est utilisé.
Les signaux PWM de l’Arduino pour contrôler les moteurs utilisent les pins pwm 3 5 6 et 11
Pins libres d’utilisation
Les pins analogiques de l’Arduino ne sont pas utilisées : toutes sont disponibles (A0 – A5) en analogique ou en numérique.
L’I2C peut aussi être utilisé (A4 = SDA et A5 = SCL)
Pins digitales libres : 2 (un trou sur la board pour y mettre un fil), 13 (avec une led).
Branchements
Alimenter la carte en courant. Dans ce cas d’une alimentation séparée pour Arduino et pour le shield, retirer le jumper marqué PWR sur la carte.
La Led verte indique l’alimentation en courant des ponts.
Avec un moteur DC à deux fils, brancher entre M1_A et M1_B par exemple.
Inverser les fils pour inverser le sens de rotation, ou inverser dans le programme Arduino.
Il est important de prévoir une alimentation suffisamment puissante pour faire tourner vos moteurs, la carte Arduino ne sort que des signaux logiques de contrôle, pas des signaux de puissance. Prévoir 1.2V de plus que la tension nominale des moteurs et une intensité plus élevée que leur consommation maximale (les moteurs tireront seulement ce dont ils ont besoin).
Une alimentation séparée permet de résoudre des problèmes de chute de tension qui peuvent réinitialiser la carte. Attention à la polarité
Un ou deux servomoteurs sont à brancher sur servo_1 ou servo_2 (connecteur à 3
pins)
S signal -> jaune
+ Power -> rouge
– Gnd -> brun
Programmation : Pour 1 moteur DC, 2 servos, 1 lampe
La librairie ‘Servo.h’ permet de piloter des servomoteurs.
Les commandes forward, backward, brake et release font respectivement tourner le moteur dans un sens, dans l’autre, le freinage et l’arrêt.
Speed = 0 permet d’arrêter la rotation (output flottant et désactivé)
PWM varie de 0 à 255 (arrêt à pleine puissance).
Pour ne pas brusquer le moteur, il est important de l’arrêter avant de l’inverser : mettre un delay(500).
Ce programme simple gère des moteurs DC (1-4) et des servos (1-2) ou des lampes. Si les moteurs font du bruit (à cause de l’utilisation de analogWrite() PWM) , utiliser la librairie Adafruit qui est mieux optimisée.
Il fait tourner de 0 à 180 ° les deux servomoteurs en aller / retour.
Il allume un éclairage (1 led verte + 470 Ohm en série) en mode PWM
Il fait tourner un moteur DC à fond en avant, l’arrête et repart à mi vitesse en sens inverse.
Le code
//=================================================
// Shield L293D pour Arduino
// megma.ma Micro-Electroniques Générales au Maroc
// Adpapté de :
// Adafruit program et arduino.cc user "Krodal". June 2012
// Open Source / Public Domain, pour Arduino 1.0.1
//=================================================
// Sorties pont en H -> moteurs DC, relais, éclairage
// Pas de moteur pas à pasavec de programme
// Les 2 servos utilisent la librairie Servo.h
// 4 moteurs DC au maximum (ou 8 sorties)
//==================================================
#include <Servo.h> //Librairie pour les 2 servomoteurs// Pins Arduino pour le registre à décalage 4 7 8 12 #define MOTORLATCH 12 #define MOTORCLK 4 #define MOTORENABLE 7 #define MOTORDATA 8// Bus 8-bit en sortie du registre à décalage 74HC595 // Utilisés pour fixer la direction des ponts de commande #define MOTOR1_A 2 //ce ne sont apsdes pins Arduino #define MOTOR1_B 3 #define MOTOR2_A 1 #define MOTOR2_B 4 #define MOTOR3_A 5 #define MOTOR3_B 7 #define MOTOR4_A 0 #define MOTOR4_B 6// Pins Arduino pour les signaux PWM (moteurs et servos) 3 5 6 9 10 11 #define MOTOR1_PWM 11 #define MOTOR2_PWM 3 #define MOTOR3_PWM 6 #define MOTOR4_PWM 5 #define SERVO1_PWM 10 #define SERVO2_PWM 9 // Codes pour les fonctions de moteur #define FORWARD 1 //4 modes de commande #define BACKWARD 2 //avant arrière frein stop #define BRAKE 3 #define RELEASE 4 // Declaration classes de Servo Servo servo_1; Servo servo_2; //Initialisations void setup() { Serial.begin(9600); Serial.println("Motor Shield L293D"); servo_1.attach(SERVO1_PWM); //Attacher ls pins des servos servo_2.attach(SERVO2_PWM); //et centrage des servos } //Programme principal void loop() { // Bouger les 2 servo de 0 à 180 degrés servo_1.write(0); //Servo 1 delay(1000); servo_1.write(180); delay(2000); servo_2.write(0); //Idem pour le servo 2 delay(1000); servo_2.write(180); delay(2000); //Solenoide ou relais entre M3_A et GND par exemple motor_output(MOTOR3_A, HIGH, 255); //Allumer delay(2000); motor_output(MOTOR3_A, LOW, 255); //Eteindre //Moteur DC connectés entre M1_A(+) and M1_B(-) motor(1, FORWARD, 255); //Tourner à fond en avant delay(2000); motor(1, RELEASE, 0); //Stop le moteur avant de l'inverser delay(500); motor(1, BACKWARD, 128); //Mi-vitesse en marche arrière delay(2000); motor(1, RELEASE, 0); //Avec BRAKE et RELEASE , speed est ignoré } //=== Fonction motor // Choisir le moteur (1-4), la commande et la vitesse (0-255). // Les commandes sont : FORWARD, BACKWARD, BRAKE, RELEASE. void motor(int nMotor, int command, int speed) { int motorA, motorB; if (nMotor >= 1 && nMotor <= 4) { switch (nMotor) { case 1: motorA = MOTOR1_A; motorB = MOTOR1_B; break; case 2: motorA = MOTOR2_A; motorB = MOTOR2_B; break; case 3: motorA = MOTOR3_A; motorB = MOTOR3_B; break; case 4: motorA = MOTOR4_A; motorB = MOTOR4_B; break; default: break; } switch (command) { case FORWARD: //Tourner en avant motor_output (motorA, HIGH, speed); motor_output (motorB, LOW, -1); // -1: no PWM set break; case BACKWARD: //Tourner en arrière motor_output (motorA, LOW, speed); motor_output (motorB, HIGH, -1); // -1: no PWM set break; case BRAKE: //Freiner motor_output (motorA, LOW, 255); // 255: fully on. motor_output (motorB, LOW, -1); // -1: no PWM set break; case RELEASE: //Stop motor_output (motorA, LOW, 0); // 0: output floating. motor_output (motorB, LOW, -1); // -1: no PWM set break; default: break; } } } //=== Fonction motor_output // Utilise le driver pour piloter des sorties // Mettre la variable high_low sur HIGH / LOW pour des lampes // On une speed = 0 // speed varie de 0-255 pour les 2 pins (0 = arrêt, 255 = maxi) // à mettre sur -1 pour ne pas régler de PWM du tout void motor_output (int output, int high_low, int speed) { int motorPWM; switch (output) { case MOTOR1_A: case MOTOR1_B: motorPWM = MOTOR1_PWM; break; case MOTOR2_A: case MOTOR2_B: motorPWM = MOTOR2_PWM; break; case MOTOR3_A: case MOTOR3_B: motorPWM = MOTOR3_PWM; break; case MOTOR4_A: case MOTOR4_B: motorPWM = MOTOR4_PWM; break; default: // Utilise speed comme flag d'erreur, -3333 = invalid output. speed = -3333; break; } if (speed != -3333) //La valeur speed est valide { // Set the direction with the shift register // on the MotorShield, even if the speed = -1. // In that case the direction will be set, but not the PWM. shiftWrite(output, high_low); // Ajuster le PWM seulemernt s il est valide if (speed >= 0 && speed <= 255) { analogWrite(motorPWM, speed); } } } // Fonction shiftWrite // The parameters are just like digitalWrite(). // The output is the pin 0...7 (the pin behind the shift register). // The second parameter is HIGH or LOW. void shiftWrite(int output, int high_low) { static int latch_copy; static int shift_register_initialized = false; // Do the initialization on the fly, // at the first time it is used. if (!shift_register_initialized) { // Set pins for shift register to output pinMode(MOTORLATCH, OUTPUT); pinMode(MOTORENABLE, OUTPUT); pinMode(MOTORDATA, OUTPUT); pinMode(MOTORCLK, OUTPUT); // Set pins for shift register to default value (low); digitalWrite(MOTORDATA, LOW); digitalWrite(MOTORLATCH, LOW); digitalWrite(MOTORCLK, LOW); // Enable the shift register, set Enable pin Low. digitalWrite(MOTORENABLE, LOW); // start with all outputs (of the shift register) low latch_copy = 0; shift_register_initialized = true; } // The defines HIGH and LOW are 1 and 0. // So this is valid. bitWrite(latch_copy, output, high_low); // Use the default Arduino 'shiftOut()' function to // shift the bits with the MOTORCLK as clock pulse. // The 74HC595 shiftregister wants the MSB first. // After that, generate a latch pulse with MOTORLATCH. shiftOut(MOTORDATA, MOTORCLK, MSBFIRST, latch_copy); delayMicroseconds(5); // For safety, not really needed. digitalWrite(MOTORLATCH, HIGH); delayMicroseconds(5); // For safety, not really needed. digitalWrite(MOTORLATCH, LOW); }
Avis
Il n’y a pas encore d’avis.