Contrôleur de moteurs L293D et Arduino

Utilisation de capteurs et composants électroniques avec Arduino.
Une fiche de tutoriel pour chaque.

Contrôleur de moteurs L293D et Arduino

Messagepar tiptop » Lun 25 Nov 2013 21:03

Tutoriel d'utilisation du shield contrôleur de moteurs L293D avec Arduino

Image

Composants utilisés

Principe de fonctionnement
Image

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.
Image

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.
Image

Image
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é

Image
Un moteur pas à pas comportant 4 fils est à brancher sur
  • M1_A -> noir (bobine 1)
  • M1_B ->brun (bobine 1)
  • M2_A ->orange (bobine 2)
  • M2_B. ->jaune (bobine 2)

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

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
Code: Tout sélectionner
//=================================================
// Shield L293D pour Arduino
// tiptopboards.com 23 11 2013
// 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);
}


Astuces techniques
La puce L293D autorise le fonctionnement parallèle, on peut souder par dessus ce circuit intégré une ou deux autres puces identiques pour augmenter le courant (piggyback) ainsi que monter un radiateur de refroidissement sur le CI.

Le freinage avec le L293D n'est pas parfait, car ce circuit intégré utilise des transistors et pas des mosfets. On peut freiner un moteur en appliquant un court voltage inversé. Ici on met les deux outputs à la masse.

La plupart des "pannes étranges" avec des moteurs sont provoquées par une alimentation insuffisante.

Programmation pour des Stepper (moteurs pas à pas)

On utilise un moteur bipolaire à 4 fils, qui peut être positionné sur un angle précis : idéal pour des projets de robotique, CNC.
la librairie fonctionne de façon identique pour des moteurs uni polaires et bi polaires.
Image

Installer la librairie AFMmotor.h disponible en téléchargement ici https://github.com/adafruit/Adafruit-Mo ... ld-library

Elle comporte ces 5 exemples :
  • AFMotor_ConstantSpeed
  • AFMotor_MultiStepper
  • Motor Party
  • Motor_Test
  • Stepper_test

Principe du programme :
Créer un objet moteur pas à pas avec AF_Stepper (step, stepper#) pour le configurer
step est le nombre de pas. Ex avec un moteur de 7.5 degrés / pas, il faut 360/7.5 = 48 pas pour faire un tour complet.
stepper# est le port qui est connecté.

Réglez la vitesse du moteur avec SetSpeed(rpm)

Pour tourner, utiliser la fonction step( #steps , direction , steptype )
#steps est le nombre de pas à tourner
direction est FORWARD ou BACKWARD
Le steptype est SINGLE (simple bobinage), DOUBLE (deux bobines activées à la fois pour couple maximum), INTERLEAVE (demi pas, alterne entre simple et double, pour deux fois plus de résolution mais vitesse moitié) ou MICROSTEP (pour un mouvement fluide entre les pas, les bobines sont en pwm).
Voir ici http://fr.wikipedia.org/wiki/Moteur_pas_%C3%A0_pas pour ces différents modes de commande.

Par défaut, le moteur tient la position d'arrêt, sauf si on fait un release().

Réglages
  • Si la vitesse est trop élevée le stepper va vibrer sans tourner (il ne suit pas).
  • Si on perd des pas, passer en mode DOUBLE, plus puissant
  • Le mode MICROSTEP est plus fluide, mais les courants sont modulés en PWM et démarrent doucement, le moteur a moins de couple au départ du pas, il peut aussi faire un peu de bruit de vibration.

Branchement de moteurs bipolaires
Image
Identifier les 2 bobines des moteurs à l'Ohmmètre.

Stepper 1 sur port 1, 200 pas par tour (angle 1.8 deg/step)
  • A+ -> jaune(bobine 1)
  • A- -> orange (bobine 1)
  • B+ -> marron (bobine 2)
  • B- -> noir (bobine 2)

Stepper 2 sur port 2, 48 pas par tour (angle 7.5 deg/step)
  • C+ -> bleu (bobine 1)
  • C- -> jaune(bobine 1)
  • D+ -> marron(bobine 2)
  • D- -> rouge(bobine 2)

On utilise ici ce code
Code: Tout sélectionner
//==================================================
// Commande de moteur pas à pas (stepper) 4 fils
// avec un Shield L293D pour Arduino
// Rolland 23 11 2013 tiptopboards.com
//  Moteurs pas à pas (48 ou 200 pas par tour par exemple)
// demo_L293_stepper
//==================================================
#include <AFMotor.h>  //Télécharger et installer cette librairie
 //Brancher les 2 bobines du moteur, ici sur le port 2 (C et D)
// 1.8d eg/step donc 360/10.8 = 200 pas par tour
//AF_Stepper motor(200, 2);  //Pas à pas de 200 pas par tour, sur port 2 (C et D)

//Moteur 7.5 degrés/pas donc 360/7.5 = 48 pas par tout
AF_Stepper motor(48, 1);  //Stepper de 48  pas par tour, sur port 1 (A et B))


void setup () {
  Serial.begin(9600); // Serial monitor sur l'écran du PC
  Serial.println("Moteur pas a pas et L293D");
  motor.setSpeed(60); // Vitesse de rotation de 60 tour/min
}

void loop () {
  Serial.println("Simple");
  motor.step(200, FORWARD, SINGLE);   //Une seule bobine
  motor.step(200, BACKWARD, SINGLE);
  delay(100);
 
  Serial.println("Double");
  motor.step(200, FORWARD, DOUBLE); //Deux bobines, plus de couple
  motor.step(200, BACKWARD, DOUBLE);
  delay(100);
 
  Serial.println("Combine");
  motor.step(200, FORWARD, INTERLEAVE);   //Combiné mais moitié moins vite
  motor.step(200, BACKWARD, INTERLEAVE);
  delay(100);
 
  Serial.println("Micropas");    //Mouvement pwm plus lissé
  motor.step(200, FORWARD, MICROSTEP);
  motor.step(200, BACKWARD, MICROSTEP);
  delay(100);
}


Références
Le playground Arduino (en anglais) Motor Shield http://playground.arduino.cc/Main/AdafruitMotorShield

Quels types de moteurs choisir http://forums.adafruit.com/viewtopic.php?f=31&t=26873

En anglais http://content.solarbotics.com/products ... e-1-2.html
tiptopboards - admin
Avatar de l’utilisateur
tiptop
Administrateur du site
 
Messages: 88
Inscription: Mar 13 Aoû 2013 20:38
Localisation: 38

Re: Contrôleur de moteurs L293D et Arduino

Messagepar zalone » Lun 21 Mar 2016 17:39

Bonjour,
Je me familiarise depuis quelques temps au montage sur l'Arduino (retraité depuis peu). :D
Ce tuto est excellent il fonctionne bien .Se n'ai pas le cas de ceux que j'ai trouvé sur la toile.
Ma question se porte sur le code. :?:
J'aimerai faire tourner les deux moteurs à courant continu mais je sais pas encore coder.
Merci de me donner un petit tuto sur se sujet il serait le bienvenue.
Dans l'absolu je voudrais faire un petit robot autonome avec un capteur HC-SR04

https://www.youtube.com/watch?v=t3kXWSctj2Q

En vous remerciant de m’éclairer, jack.
zalone
 
Messages: 1
Inscription: Ven 18 Mar 2016 22:25
Localisation: la sôNE isère


Retourner vers Capteurs et composants

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 4 invités