AdaFruit Motor Shield Utiliser

De MCHobby - Wiki
Aller à : navigation, rechercher

Premièrement: Installer la librairie Arduino

avant de pouvoir utiliser le Shield Motor (Motor shield), vous devez installer la librairie AF_Motor pour Arduino - cette librairie indique à Arduino comment communiquer vec le motor shield. Ce n'est pas une option mais une nécessité!

  1. Premièrement, téléchargez la librairie depuis le GitHub d'AdaFruit
  2. Décompressez l'archive (fichier Zip) sur votre bureau
  3. Renommer le répertoire décompressé en "AFMotor"
  4. Assurez vous que le répertoire AFMotor contienne bien les fichier AFMotor.cpp et AFMotor.h . Sinon vérifiez les étapes précédentes.
  5. Déplacez le répertoire AFMotor folder dans le répertoire des librairies Arduino (répertoire_arduinos_ketch/libraries). Pour Windows, cela doit être quelque-chose comme "Mes Documents/Arduino/libraries", pour Mac quelque chose comme "Documents/arduino/libraries". Si c'est la première fois que vous installez une librairie, vous devrez certainement créer le répertoire "libraries". Assurez-vous de l'appeler exactement "libraries", pas de capitale, pas d'autre nom.
  6. A l'intérieur du répertorie "librairies", il doit y avoir le répertoire "AFMotor", et qu'à l'intérieur de "AFMotor" il y ait AFMotor.cpp, AFMotor.h et quelques autres fichiers
  7. Quittez Arduino IDE et redémarrez le. Vous devriez voir un sous-menu appelé File->Examples->AFMotor->MotorParty

Alimenter un moteur continu, exigences en tension et courant

Les moteurs ont besoin de beaucoup d'énergie, plus particulièrement les moteurs meilleurs marchés puisqu'ils sont moins performant. La première chose importante à connaître est la tension d'alimentation que le moteur va utiliser. Si vous avez de la chance, votre moteur dispose d'une fiche technique.
Certain moteurs hobbyistes (de jouet) ne sont prévus que pour une tension de 1.5V, mais il est courant pour un moteur continu ("DC Motor" en anglais) d'avoir une tension de fonctionnement 6 à 12V. Ce shield est conçu pour contrôler des moteurs de 4.5V à 25V.

Exigence en courant

La seconde chose à connaître est la quantité de courant dont votre moteur aura besoin. Le circuit intégré L293D contrôlant le moteur ("Motor driver" en anglais) sont conçu pour fournir 600mA per moteur avec un pic de courant à 1.2 Ampère.
Notez qu'une fois que le courant tend vers 1A vous aurez probablement besoin d'équiper le "motor driver" d'un dissipateur de chaleur, sinon vous subirez des défaillances thermiques, voir griller votre circuit intégré.

Utiliser un SN754410

Certaines personnes utilise un circuit intégré SN754410 pour contrôler les moteurs. Ils utilise le SN754410 à la place du L293D parce que le brochage est identique ("Pin Compatible" en anglais), dispose de diodes de protections en sortie et supporte 1A par moteur avec un pic à 2A.

Après une lecture attentive de la fiche technique et quelques discussions avec des techniciens, il apparait que ces diodes de protections sont conçues pour fournir uniquement un protection contre les décharges électrostatiques (ESD Protection). Les utiliser comme diodes de protections en roule-libre est du domaine du Hack et les performances ne sont absolument pas garantie... le risque pour le pont-H est bien réel.

C'est pour cette raison que le kit n'est pas livré avec des SN754410 mais avec des L293D qui intègrent des vraie diodes de protection "en roue libre" ("kickback-protection diodes" en anglais). Si vous désirez quand même prendre le risque d'utiliser des SN754410 parce que vous avez besoin de plus de courant, vous pouvez maintenant acheter ces composants et remplacer mes L293D en connaissant les risques potentiels.

Besoin de plus de puissance?

Vous pouvez acheter d'autres L293D et les souder pile au dessus des premiers déjà présent sur la carte ('piggyback' en anglais).

Voila, comment vous pouvez doubler la courant supporté par le L293D! Vous pouvez empiler plus de deux L293D mais cela ne devrait pas apporter beaucoup plus de bénéfice.

PiggyBack-componant.jpg
Source: tinyenormous.com

Restez néanmoins vigilant avec les courants mis en œuvre car si vous disposez de deux fois plus de courant, vous avez aussi besoin de dissiper au total plus de chaleur qu'avec un seul L293D.
Tout le monde sait qu'il fait beaucoup plus chaud à deux sous la couette que tout seul. Ce principe s'applique aussi au L293D empilés ;-) .

Les moteurs et les piles de 9v

Vous ne pouvez pas faire fonctionner efficacement des moteurs avec des piles de 9 volts, ne gaspillez donc pas vos piles de 9v et votre temps!

Utilisez des piles de type Plomb Acide (Lead Acid) ou accumilateur NiMH.

99% des 'problèmes moteur incompréhensible' (bizarres) sont causés par des parasites (bruit) du circuit de puissance qui passe dans le circuit d'alimentation Arduino (1*) et/ou d'une alimentation pas suffisamment puissante!

1*: Cela signifie qu'une alimentation est partagée (commune) entre le circuit de commande (Arduino) et le circuit de puissance (les moteurs).

Alimentation moteur: Comment configurer Arduino + Shield

Les Servos sont alimentés par le régulateur 5V de la carte Arduino. C'est parfait pour les moteurs hobbyistes suggérés. Si vous avez besoin de quelque-chose de plus costaud, sectionnez la piste qui va à la broche + des connecteurs servo et branchez votre propre alimentation 5-6V!

Les moteurs continu (DC) sont alimentés depuis 'de circuit d'alimentation haute tension' (high voltage supply) et NON depuis le régulateur 5V d'Arduino.

Il y a deux endroits où vous pouvez obtenir votre 'alimentation haute tension' pour les moteurs. La première est la prise jack de votre Arduino (surlaquelle est raccordé votre bloc d'alimentation) et la deuxième est bornier à 2 vis sur le shield (celui portant le libellé EXT_PWR sur la carte).

La prise Jack de votre Arduino dispose d'une diode de protection, il n'est donc pas possible de faire une erreur fatale si vous utilisez un bloc d'alimentation mal polarisé. Cependant, le bornier EXT_PWR ne dispose pas de diode de protection (pour une vrai bonne raison). Soyez extrêmement prudent et n'inversez pas la polarité sinon vous allez détruire le shield moteur et/ou votre Arduino!

Voici comment cela fonctionne:

{{{2}}}
Crédit: AdaFruit Industries www.adafruit.com Traduction par MCHobby]]

Une seule alimentation

Si vous désirez utiliser une seule alimentation pour Arduino et vos moteurs, raccordez simplement la prise jack sur votre Arduino (ou sur le bornier PWR_EXT). Placez ensuite le cavalier sur le motor shield.

Si vous disposez encore d'un vielle Arduino Diecimila, vous devrez également placer le cavalier (jumper) sur la position EXT.

Notez que vous pourriez avoir des problèmes de "resets" (redémarrage) de votre Arduino si votre alimentation n'est pas capable de fournir une puissance constante. Cette méthode d'alimentation n'est pas celle qui est recommandée pour alimenter vos projets motorisés.

USB pour Arduino + alimentation moteur

Si vous désirez alimenter votre Arduino par USB et les motors depuis une alimentation externe, raccordez votre cable USB. Connectez ensuite l'alimentation moteur sur le bornier PWR_EXT du shield. NE PLACEZ PAS LE CAVALIER (jumper) sur le shield. C'est la méthode d'alimentation recommandée pour vos projets motorisés. (Si vous disposez encore d'un ancien Arduino Diecimila, n'oubliez pas de placer le cavalier d'alimentation sur USB. Si vous avez un Décimelia, vous pouvez exécuter la procédure suivante: raccorder l'alimentation sur votre Arduino, et placer le cavalier sur le motor shield)

Deux alimentations séparées

Voici une méthode recommandée pour alimenter vos projets moteurs.

Si vous désirez avoir 2 alimentations continu séparées pour alimenter votre Arduino et vos moteurs. Raccorder l'alimentation pour votre Arduino dans la prise Jack, et connectez l'alimentation des moteurs sur le bornier PWR_EXT. Le cavalier doit être retiré du moteur shield.

Si vous avez encore un ancien Arduino Diecimila, placer le cavalier de votre Arduino sur EXT.

Quoi qu'il en soit...

Servo Moteur

{{{2}}}
Crédit: AdaFruit Industries www.adafruit.com

Les servo moteurs pour Hobbyiste représentent certainement la façon la plus simple de mettre le shield moteur en oeuvre.

Le shield dispose de deux connecteurs (pinHeader) de 3 broches.

Un servo moteur dispose d'un connecteur femelle à 3 broches avec un empattement de 2.54mm. Ces 3 connexion reprennent +5V, masse(GND) et le signal d'entrée

Le shield moteur dispose de 2 sorties PWM (précision de 16 bits) raccordées sur 2 connecteurs de 3 broches mâles. Ces connecteurs permettent de raccorder facilement des servo moteurs et de démarrer rapidement. Ces servos nécessitent pas mal d'énergie, une pile de 9v ne résisterait donc pas plus que quelques minutes!

Ce qu'il y a de sympa avec les contrôleurs PWM intégrés à la carte, c'est qu'il sont très précis et font la majorité de leurs tâches sans que l'on s'en rende compte. Vous pouvez utiliser la librairie Servo incluse dans l'environnement Arduino.

Utiliser des servi est simple, vous pouvez lire le tutoriel Arduino officiel qui reprend la document nécessaire pour l'utilisation de Servo avec quelques exemples de sketchs pour Arduino IDE

Moteur Continu

{{{2}}}
Crédit: AdaFruit Industries www.adafruit.com

Les moteur à courant continu (CC ou "DC" en anglais) sont utilisés dans toutes sortes de projet robotique. Le shield moteur est capable de controler jusqu'à 4 moteurs bi-directionnels. Cela signifie qu'il peuvent fonctionner en marche avant et marche arrière. La vitesse peut également varier d'un incrément de 0.5% grace à l'utilisation d'un signal PWM de grande précision. Cela signifie que la vitesse reste constance et ne variera pas!

Notez que le circuit Pont-H n'est pas conçu pour contrôler un courant supérieur à 600 mA (ou un pic supérieur à 1.2A), il convient donc pour les "petits" moteurs. Vérifiez la fiche technique de vos moteurs pour vous assurer qu'ils conviennent bien.

Pour connecter un moteur, soudez simplement deux fils sur les bornes du moteur et connectez les ensuite sur l'un des borniers M1, M2, M3, ou M4 (au choix).

Exécutez ensuite les étapes suivantes dans votre sketch Arduino


  1. Assurez vous d'avoir inclus <AFMotor.h>
  2. Créez un objet AF_DCMotor avec AF_DCMotor(numéro_motor, fréquence), pour initialiser le pont-H et les latch.
    Le constructeur accepte deux arguments.
    Le premier est le port (bornier) sur lequel le moteur est connecté (1, 2, 3 ou 4).
    fréquence est la rapidité du signal contrôlant la vitesse.
    Pour les moteurs 1 et 2 vous pouvez opter pour MOTOR12_64KHZ, MOTOR12_8KHZ, MOTOR12_2KHZ, ou MOTOR12_1KHZ. Un signal à haute vitesse comme 64KHz ne sera pas audible mais une signal basse vitesse tel que 1KHz nécessitera moins de puissance.
    Les Moteurs 3 et 4 peuvent uniquement fonctionner avec un signal à 1KHz et ignorerons donc le paramètre fournit.
  3. Ensuite, vous pouvez sélectionner la vitesse du moteur en utilisant setSpeed(vitesse)vitesse est compris entre 0 (arrêt) et 255 (pleine vitesse). Vous pouvez modifier la vitesse à n'importe quel moment.
  4. Pour mettre le moteur en route, appelez la fonction run(sens_rotation)' où sens_rotation est FORWARD pour avant, BACKWARD pour arrière ou RELEASE (arrêt).
    Notez que l'arrêt utilise le terme anglais 'RELEASE' qui à plutôt le sens de "relâché". C'est normal puisque le moteur n'est plus contrôlé sans pour autant être bloqué/verrouillé à l'arrêt... il peut en effet encore être entraîner à la main :-).
    Pour le reste, gardez à l'esprit qu'Arduino ne sait pas si votre moteur est cablé dans un sens ou dans l'autre... et ne sait donc pas à quoi correspond la marche avant (forward) ou la marche arrière (backward) de votre montage. Si votre montage fonctionne en marche arrière avec l'instruction run(FORWARD), il suffit d'inverser les fils de raccordement du moteur sur le bornier du shield moteur.
#include <AFMotor.h>

AF_DCMotor motor(2, MOTOR12_64KHZ); // Créer le moteur #2, PWM à 64KHz

void setup() {
  Serial.begin(9600);           // Initialiser la communication série à 9600 bauds
  Serial.println("Test Moteur!");
  
  motor.setSpeed(200);     // Mettre la vitesse à 200 (max 255)
}

void loop() {
  Serial.print("tick");
  
  motor.run(FORWARD);      // mettre en marche avant (forward)
  delay(1000);

  Serial.print("tock");
  motor.run(BACKWARD);     // Dans l'autre sens
  delay(1000);
  
  Serial.print("tack");
  motor.run(RELEASE);      // Arrêt
  delay(1000);
}

Moteur pas-à-pas

Voici un exemple avec un moteur pas-à-pas bipolaire.

{{{2}}}
Crédit: AdaFruit Industries www.adafruit.com

Un moteur pas-à-pas est genial pour un contrôle (semi-)précis, parfait pour beaucoup de robot projets CNC (commande numérique). Ce shield moteur est capable de supporter jusqu'à 2 moteurs pas-à-pas. La librairie fonctionne à l'identique avec les moteurs bipolaires et unipolaires.

Moteurs unipolaires

Pour les moteurs unipolaires: pour raccorder le moteur, vous devez d'abord savoir quel fil est connectée à quel bobine, et quelle fil se trouve au centre de la bobine. Si c'est un moteur à 5 fils alors il y a un seul fil qui est centre pour les deux bobinages. Il y a plein de tutoriels en ligne qui permet de déduire le brochage/raccordement des moteurs pas-à-pas. Les milieux de bobines doivent tous les deux être raccordés à la masse (borne GND) du bloc de raccordement moteur. Ensuite, la bobine 1 doit être connectée sur un port moteur (disons M1 ou M3) et la deuxième bobine sur l'autre port moteur (M2 ou M4).

Moteurs bipolaires

Pour les moteurs bipolaires: C'est comme pour les moteurs unipolaires excepté qu'il n'y a pas de 5ieme fil à raccorder à la masse.

Le code du programme restera exactement pareil.

Nbre de pas

Une information importante sur un moteur pas à pas est le nombre de pas par révolution. C'est donc le nombre de pas nécessaire pour que moteur fasse un tour complet.

Les fiches techniques ne fonctionnent pas cette information telle quel mais indique plutôt le nombre de degrés par pas.

Sur un moteur à 7.5 degrés/pas, le moteur à 360/7.5 = 48 pas par révolution.

Sur un moteur à 1.8 degrés/pas, le moteur à 360/1.8 = 200 pas par révolution.

Le code

Faire fonctionner un moteur pas-à-pas est juste un peu plus complexe d'un moteur continu mais cela reste encore simple.

  1. Assurez vous que vous avez inlus la librairie <AFMotor.h>
  2. Créez un object pour moteur pas-à-pas avec AF_Stepper(nbre_pas, numéro_moteur) pour initialiser le pont-H et les latch. nbre_pas combien de pas sont nécessaire au moteur pour faire une tour.
    . Numéro_moteur indique à quel port (bornier) le moteur est raccordé. Si vous utilisez les bornes M1 et M2, c'est le port 1. Si vous utilisez M3 et M4 c'est le port 2
  3. Définissez la vitesse du moteur en utilisant setSpeed(rpm) where rpm est le nombre de tours/révolutions par minute auquel vous voulez que le moteur tourne.
  4. Ensuite, à chaque fois que vous voulez mettre le moteur en mouvement, il suffit appeler la procédure step(nbre_de_pas, direction, type_de_pas).
    Vous pouvez modifier le type de pas à n'importe quel moment selon que vous avez besoin d'utiliser un minimum de puissance, un maximum de couple ou plus de précision.
    1. nbre_de_pas est le nombre de pas dont vous voulez que le moteur tourne.
    2. La direction est soit FORWARD (avant) ou BACKWARD (arrière)
    3. Type_de_pas peut être soit SINGLE, DOUBLE. INTERLEAVE ou MICROSTEP.
      "Single" signifie single-coil activation (activation d'un seul bobinage) et utilise un minimum de puissance,
      "double" signifie que les deux bobinage sont activés à la fois (pour un couple plus important),
      "interleave" signifie que les bobinages sont activées en alternance entre simple et double ("single" et "double") pour obtenir le double de résolution (mais aussi la moitié de la vitesse).
      Enfin, "Microstepping" est une méthode où les bobinage sont contrôlé en PWM pour créer un mouvement plus fluide entre les pas.
      Il y a des tonnes d'information concernant les "pour" et "contre" des différents types de contrôle de pas dans les pages de ressources (LadyAda, Anglais).
  5. Par défaut, le moteur maintient sa position après la rotation (en pas). Si vous désirez désactiver les bobinages pour permettre au moteur de tourner librement, vous pouvez appeler la procédure release()
  6. Les commandes de contrôle de pas sont 'bloquante' et rendrons la main au programme une fois tous les pas accomplis. Si quelqu'un désire être épatant, il peut écrire une librairie qui traite les opérations de pas-à-pas en tâche de fond... ca serait super cool! :)
#include <AFMotor.h>

AF_Stepper motor(48, 2);

void setup() {
  Serial.begin(9600);           // configure la connexion série a 9600 bauds
  Serial.println("Test pas-a-pas!");

  motor.setSpeed(10);  // 10 rpm (rotation par minute)  

  motor.step(100, FORWARD, SINGLE); 
  motor.release();
  delay(1000);
}

void loop() {
  motor.step(100, FORWARD, SINGLE); 
  motor.step(100, BACKWARD, SINGLE); 

  motor.step(100, FORWARD, DOUBLE); 
  motor.step(100, BACKWARD, DOUBLE);

  motor.step(100, FORWARD, INTERLEAVE); 
  motor.step(100, BACKWARD, INTERLEAVE); 

  motor.step(100, FORWARD, MICROSTEP); 
  motor.step(100, BACKWARD, MICROSTEP); 
}

Si vous voulez que les deux moteurs pas-à-pas fonctionnent en même pas, vous devez utiliser un comme comme ce qui suit:

void doublestep (int steps, int direction, int style) {
  while (steps--) {
    motor1.step(1, direction, style); 
    motor2.step(1, direction, style); 
  }
}

Ressources


Source: Motor Shield créé par LadyAda pour AdaFruit Industries. Crédit [www.adafruit.com AdaFruit Industries]

Traduit par Meurisse D. pour MCHobby.be]

Traduit avec l'autorisation d'AdaFruit Industries - Translated with the permission from Adafruit Industries - www.adafruit.com

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.