• 20 hours
  • Medium

Free online content available in this course.

Certificate of achievement available at the end this course

Got it!

Last updated on 7/13/17

Utilisez un shield moteur (2/2)

Log in or subscribe for free to enjoy all this course has to offer!

Poursuivons notre découverte du shield moteur...

Téléchargez et installez la bibliothèque Adafruit motor

Pour que ce shield fonctionne, il lui faut une série d'instructions contenues dans une bibliothèque (library) qui vous est fournie par Adafruit.

Pour que tout soit bien plus simple, je vous conseille de mettre à jour l'IDE de l'Arduino sur votre ordinateur. En effet, il y a une fonctionnalité très efficace pour télécharger et installer les bibliothèques.

Voici la procédure à suivre :

  1. Ouvrez votre IDE.

  2. Allez dans la barre de menu : Croquis -> Include Library -> Manage libraries...

  3. Dans la fenêtre du "Library manager" qui s'ouvre, tapez "Adafruit motor" dans le champ de recherche. (Si vous ne tapez que Adafruit, vous aurez un aperçu de l'apport des bibliothèques Adafruit disponibles pour la communauté.)

  4. Choisissez la version qui correspond à votre shield (c'est noté sur le shield, la récente est v2.3) et la version de la bibliothèque (le manager propose la dernière automatiquement).

  5. Cliquez sur "install".

  6. Attendez que l'installation se fasse et fermez tout (même l'IDE).

  7. Ouvrez l'IDE à nouveau, et si tout se passe bien, dans Fichier -> Exemples vous devriez voir apparaître "Adafruit Motor Shields V2 Library" (en fonction de votre version).

  8. Ayé, c'est fait ! Il ne nous reste plus qu’à découvrir les fonctionnalités de code liées au shield moteur disponibles dans cette bibliothèque..

Faites tourner un moteur

Pour la suite de ce chapitre, je pars du principe que :

  • Vous avez connecté votre shield moteur sur votre carte Arduino.

  • Vous avez la version v2 du shield moteur Adafruit.

  • Vous avez téléchargé la bibliothèque qui va bien(voir section précédente).

  • Vous avez connecté votre moteur sur la sortie M1 du shield.

SI vous alimentez l'Arduino et le shield par une source différente (ce que je vous conseille), n'oubliez pas d'enlever le jumper derrière le domino.

Commencez par lancer un nouveau programme (sketch) dans l’IDE Arduino.

Déclarez vos ressources

La première chose à faire dans votre programme, c’est d’inclure les bibliothèques pour qu'il puisse les compiler ensuite :

  • La bibliothèque "wire" qui permet la communication I2C avec le shield. Celle-ci est déjà présente par défaut dans l'IDE, donc pas besoin de la télécharger au préalable;

  • La bibliothèque "Adafruit_MotorShield" qui gère le shield moteur (que vous avez téléchargé dans la section précédente).

 

Pour inclure des bibliothèques, vous connaissez la procédure :

#include <Wire.h>
#include <Adafruit_MotorShield.h>

On doit ensuite créer un objet shield pour que l'Arduino puisse discuter avec. Cette objet a une adresse générique I2C (c'est-à-dire un code qui permet de savoir que c'est avec lui que l'Arduino discute). Cette adresse est0x60. Il est possible de modifier cette adresse avec des soudures sur le shield. Ce n'est pas l'objet de ce chapitre.

J'appelle mon objet shield "monShield", libre à vous de lui donner le nom que vous voulez.

Adafruit_MotorShield monShield = Adafruit_MotorShield();

Ensuite, on crée un objet moteur qu'on rattache à l'objet shield, en indiquant la sortie utilisée de cette façon :

Adafruit_DCMotor *monMoteur = monShield.getMotor(1);

J'ai décidé d'appeler le pointeur "monMoteur", là encore vous pouvez choisir un autre nom.

Nous en avons fini avec les déclarations liées au shield. Nous n'utilisons ici qu'un seul moteur. Nous verrons plus loin comment utiliser 2 moteurs.

Instructions dans le blocsetup()

Dans le  setup()i il faut démarrer la communication avec le shield avec la fonction :

monShield.begin();

Bien, à partir de là nous pouvons utiliser notre moteur.

Les moteurs sont programmables en vitesse et en sens de rotation.

Pour paramétrer la vitesse, on utilise la fonction  setSpeed(valeur)  où  valeur  est un entier entre 0 (arrêt) et 255 (vitesse maximum). Mais comme on utilise un pointeur (et non un objet), on ne va pas utiliser le  .  pour appeler la fonction liée à l'objet, mais la flèche  ->  (tiret et signe supérieur). Du coup pour définir la vitesse au maximum pour notre moteur, je vais coder :

monMoteur->setSpeed(255);

Maintenant que la vitesse de rotation est fixée, vous pouvez démarrer votre moteur. Pour cela, il faut utiliser la fonction  run(). Elle attend un paramètre qui peut prendre trois valeurs :

  • FORWARD qui signifie en avant ;

  • BACKWARD qui signifie en arrière ;

  • RELEASE qui signifie stop.

On les écrit en majuscules car ce sont des constantes fixées par la bibliothèque du shield.

Donc pour lancer le moteur en avant, j'écris :

monMoteur->run(FORWARD);

Là encore on utilise le signe  ->.

Voici donc le programme qui fait tourner le moteur dans un sens :

#include <Wire.h> //bibliothèque pour la communication I2C
#include <Adafruit_MotorShield.h> //bibliothèque pour le shield
Adafruit_MotorShield monShield = Adafruit_MotorShield(); //création de l'objet shield
Adafruit_DCMotor *monMoteur = monShield.getMotor(1); //création de l'objet moteur par pointeur et repérage du numéro
void setup() {
  monShield.begin(); //On lance la communication avec le shield
  monMoteur->setSpeed(255); //On définit la vitesse de rotation
  monMoteur->run(FORWARD); //On fait tourner le moteur
}
void loop() {
}

Vous pouvez téléverser et tester le programme. Le moteur devrait tourner.

J'attire votre attention sur la LED verte "power" située sur le shield. Elle indique que le shield est correctement alimenté en tension.

Faites tourner plusieurs moteurs

Alors le code qui permet de faire tourner plusieurs moteurs est en fait très simple. Au lieu de déclarer un moteur, on en déclare deux !

Comme d'habitude, les noms que vous choisirez vous permettront de mieux lire votre code !

Voici donc un code qui vous permet de démarrer deux moteurs (moteurGauchee et  moteurDroite) ensemble pendant une seconde, puis qui les arrête pendant une seconde, répété à l'infini :

#include <Wire.h> //bibliothèque pour la communication I2C
#include <Adafruit_MotorShield.h> //bibliothèque pour le shield
Adafruit_MotorShield monShield = Adafruit_MotorShield(); //création de l'objet shield
Adafruit_DCMotor *moteurGauche = monShield.getMotor(1); //création de l'objet moteurGauche par pointeur et repérage du numéro
Adafruit_DCMotor *moteurDroite = monShield.getMotor(2); //création de l'objet moteurDroite par pointeur et repérage du numéro
void setup() {
  monShield.begin(); //On lance la communication avec le shield
  moteurGauche->setSpeed(255); //On définit la vitesse de rotation
  moteurDroite->setSpeed(255); //des deux moteurs
  
}
void loop() {
  moteurGauche->run(FORWARD); //On fait tourner les moteurs
  moteurDroite->run(FORWARD); //ensemble dans le même sens
  delay(1000); // pendant 1 seconde
  moteurGauche->run(RELEASE); //Puis on les arrête
  moteurDroite->run(RELEASE); //tous les deux
  delay(1000); // pendant 1 seconde
}

Cette fois-ci, j'ai mis des instructions dans la boucle  loop()  pour que le programme se répète.

Il est bien sûr possible de créer des fonctions qui démarrent ou arrêtent les moteurs !

Tiens d'ailleurs, que diriez-vous d'un petit exercice ?

(Oui, bien sûr Lukas, on peut commencer par une petite pause aussi...)

TP : Écrivez les fonctions de déplacement de votre robot

Dans le chapitre précédent, vous avez conçu des programmes qui permettaient de faire réagir vos robots en fonction de l'environnement, grâce aux capteurs.

Nos programmes n'étaient pas complets, puisqu'il manquait le contenu des fonctions :

  • arret(),

  • avance(int v),

  • recule(int v),

  • tourneDroite(int v), et

  • tourneGauche(int v).

où  v  représente la valeur pour la vitesse du robot.

Je vous propose donc de créer ces fonctions en utilisant la bibliothèque du shield, ce qui vous permettra de les mettre dans le programme final de votre robot.

Le programme doit définir les bonnes fonctions, et les appeler successivement dans la  loop()  (oui Lukas, l'une après l'autre) et attendre 1 seconde entre chaque appel.

Vous avez largement tout ce qu'il vous faut pour réaliser cet exercice, alors au boulot !

(Cunégonde, puisque vous avez déjà fini, allez donc aider Lukas à retrouver son Arduino...)

TP : Correction

Le code là encore est simplifié par l'utilisation du shield et de sa bibliothèque d'instructions. Vous remarquerez d'ailleurs que c'est aussi le cas de votre montage, il y a beaucoup moins de fils ! C'est justement tout l'avantage des shields.

Voici donc la correction de l'exercice attendu (ou la correction attendue de l'exercice...) :

#include <Wire.h> //bibliothèque pour la communication I2C
#include <Adafruit_MotorShield.h> //bibliothèque pour le shield
Adafruit_MotorShield monShield = Adafruit_MotorShield(); //création de l'objet shield
Adafruit_DCMotor *moteurGauche = monShield.getMotor(1); //création de l'objet moteurGauche par pointeur et repérage du numéro
Adafruit_DCMotor *moteurDroite = monShield.getMotor(2); //création de l'objet moteurDroite par pointeur et repérage du numéro
void setup() {
  monShield.begin(); //On lance la communication avec le shield
  moteurGauche->setSpeed(255); //On définit la vitesse de rotation
  moteurDroite->setSpeed(255); //des deux moteurs
  
}
void loop() {
  arret();
  delay(1000);
  avance(255);
  delay(1000);
  recule(255);
  delay(1000);
  tourneDroite(255);
  delay(1000);
  tourneGauche(255);
  delay(1000);
}
void arret(){
  //fonction d'arrêt des deux moteurs
  moteurGauche->run(RELEASE);
  moteurDroite->run(RELEASE);
}
void defVitesse(int v){
  moteurGauche->setSpeed(v); //on redéfinit la vitesse
  moteurDroite->setSpeed(v); //des deux moteurs
}
void avance(int v){
  //fonction de marche avant
  defVitesse(v); //appel de la fonction pour définir la vitesse
  moteurGauche->run(FORWARD);
  moteurDroite->run(FORWARD);
}
void recule(int v){
  //fonction de marche arrière
  defVitesse(v);
  moteurGauche->run(BACKWARD);
  moteurDroite->run(BACKWARD);
}
void tourneDroite(int v){
  //fonction pour tourner à droite sur place
  defVitesse(v);
  moteurGauche->run(FORWARD);
  moteurDroite->run(BACKWARD);
}
void tourneGauche(int v){
  //fonction pour tourner à gauche sur place
  defVitesse(v);
  moteurGauche->run(BACKWARD);
  moteurDroite->run(FORWARD);
}

Vous remarquez que j'indique qu'il s'agit de tourner sur place. En effet, vous pouvez être plus subtile dans la rotation :

  • Si vous arrêtez une roue et laissez l'autre en marche, la rotation se fera autour le la roue arrêtée.

  • Si vous définissez une roue à une vitesse et l'autre à une vitesse moindre, votre robot tournera sur une courbe plutôt que sur place ou autour de sa roue.

  • Vous pouvez aussi vous contenter de garder une roue à une vitesse constante, et d'augmenter ou de diminuer la vitesse de l'autre, ce qui vous permet des trajectoires plus fines.

Et bien voilà une affaire qui roule !

Les connexions pour servo-moteurs

Vous trouverez sur le shield, deux connexions pour servo-moteurs. Elle ne sont pas pilotées par la bibiothèque du shield. En fait c'est juste que ces connexions sont reliées au pins 9 (servo 2) et 10 (servo 1) de l'Arduino. Il vous suffit de brancher correctement les fils du servo-moteur (le gnd vers le haut et le fil de commande vers les pins numériques) pour que votre servo soit correctement connecté au +5V et gnd de l'Arduino. Ce n'est donc pas l'alimentation des moteurs qui sera utilisée.

Pour piloter des servos, on utilise la bibliothèque "Servo" proposée par l'IDE.

Vous trouverez les explications liées aux servo-moteurs (fonctionnement et programmation) dans mon cours d'initiation.

En résumé

Je pense que vous avez bien avancé sur votre robot mobile !

En effet dans ce chapitre vous avez :

  • Appris à réaliser quelques soudures ;

  • Connecté le shield moteur à l'Arduino ;

  • Téléchargé et utilisé les bibliothèques pour utiliser ce shield ;

  • Appris à piloter un moteur, puis deux moteurs ;

  • Appris à simplifier votre programme pour piloter un moteur à l'aide de fonctions.

Vous pourriez aussi ajouter à votre robot des LED qui s'allument en fonction de ses mouvements pour améliorer le côté visuel.

Dans le chapitre suivant, je vous propose de lui ajouter des sons !

Example of certificate of achievement
Example of certificate of achievement