Piloter les moteurs

par · Publié · Mis à jour

La propulsion de l’Alphabot est de type différentielle : deux moteurs indépendants propulsent et dirigent le robot.

Chaque moteur est piloté par les moyens techniques suivants :

 

Voici les correspondances entre les ports de communications des microcontrôleurs et les états qu’ils doivent prendre (LOW ou HIGH) pour obtenir le comportement moteur attendu :

Arrêt
(moteur libre)		 Avant Arrière Arrêt
(moteur freiné)
Moteur

Gauche

 Moteur

Droite
Nom de
l’interface		 In1 In3 LOW HIGH LOW pas possible !
Port
Arduino		 A0  A2
Port
Raspberry		  P12  P20
Nom de
l’interface		 In2 In4 LOW LOW HIGH pas possible !
Port
Arduino		  A1  A3
Port
Raspberry		  P13  P21

Contrôle des mouvements

Arduino

Les mouvements du robot peuvent être contrôlés à l’aide de quelques commandes simples.

Bibliothèque

Il existe une bibliothèque Arduino pour faciliter l’utilisation de l’AlphaBot.

  • Télécharger l’archive zip : AlphaBot_arduino.zip.
  • Dézipper l’ensemble dans un dossier (avec 7zip par exemple)
  • Copier le contenu de ce dossier dans Mes Documents/Arduino/libraries .

Initialisation

Au début du programme, en dehors de toute fonction, ajouter ces lignes :

#include "AlphaBot.h"
AlphaBot Robot = AlphaBot(); // instanciation de l'objet "virtuel" Robot

Commandes

  • Régler la vitesse du robot : Robot.SetSpeed(250);
  • Avancer/Reculer tout droit : Robot.Forward(duree_en_ms); / Robot.Backward(duree_en_ms);
  • Tourner sur place : Robot.Left(duree_en_ms);  / Robot.Right(duree_en_ms);
  • Décrire un cercle : Robot.LeftCircle(duree_en_ms);  / Robot.RightCircle(duree_en_ms);
  • Alimenter les moteurs : Robot.MotorRun(VitGauche, VitDroite); // Vitesses des moteurs de -255 à 255
  • Stopper (freiner) : Robot.Brake();

Utilisation des codeurs

Chaque roue étant équipée d’un codeur incrémental, il est donc possible de commander le mouvement en distance plutôt qu’en temps.

Le code suivant propose quelques exemples de fonctions permettant de piloter les moteurs en utilisant les codeurs incrémentaux placés sur les roues.

Attention : les contrôleurs des moteurs n’autorisent pas le freinage ! Il y a donc un fort risque de dépassement des positions visées !

 

Voir le code
/*************************************** 
Contrôle avancé des moteurs
en utilisant les codeurs incrémentaux

avancer(pas)
reculer(pas)
tournerG(pas)
tournerD(pas)

****************************************/

const int CodeurG = 2;
const int CodeurD = 3;

volatile long PosG = 0; // positions angulaires des roues (relatives) en pas
volatile long PosD = 0;
long objPosG = 0;       // positions angulaires visées (relatives) en pas
long objPosD = 0;


int VitNom = 255;         // vitesse nominale du robot (-255 à 255)
int VitG = 0;           // Vitesses des roues (-255 à 255)
int VitD = 0;


void setup()
{
  Serial.begin(115200);
  pinMode(0, INPUT_PULLUP);
  pinMode(1, INPUT_PULLUP);
  pinMode(A0, OUTPUT);
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  pinMode(A3, OUTPUT);
  attachInterrupt(0, frontG, CHANGE);
  attachInterrupt(1, frontD, CHANGE);
}

void loop()
{  
  avancer(100);
  delay(10000);
  tournerD(50);
  delay(10000);
}

void avancer(long pas){
  VitG = VitNom;
  VitD = VitNom;
  objPosG = pas;
  objPosD = pas;
  run();
  }
  
void reculer(long pas){
  VitG = -VitNom;
  VitD = -VitNom;
  objPosG = pas;
  objPosD = pas;
  run();
  }

void tournerG(long pas){
  VitG = VitNom;
  VitD = -VitNom;
  objPosG = pas;
  objPosD = pas;
  run();
  }
  
void tournerD(long pas){
  VitG = -VitNom;
  VitD = VitNom;
  objPosG = pas;
  objPosD = pas;
  run();
  }
  
void run(){
  PosG = 0;
  PosD = 0;
  runG();
  runD();
  }

/**************** contrôle moteur G ***************/
void runG(){
  analogWrite(5, abs(VitG));
  if (VitG > 0) {
    digitalWrite(A1, LOW);
    digitalWrite(A0, HIGH);
    }
  else if (VitG < 0){
    digitalWrite(A1, HIGH);
    digitalWrite(A0, LOW);
    }
  else {
    digitalWrite(A1, HIGH);
    digitalWrite(A0, HIGH);
    }
  }

void freinG(){ 
  digitalWrite(5, LOW); 
  }


/**************** contrôle moteur D ***************/
void runD(){
  analogWrite(6, abs(VitD));
  if (VitD > 0) {
    digitalWrite(A2, LOW);
    digitalWrite(A3, HIGH);
    }
  else if (VitD < 0){
    digitalWrite(A2, HIGH);
    digitalWrite(A3, LOW);
    }
  else {
    digitalWrite(A2, HIGH);
    digitalWrite(A3, HIGH);
    }
  }
  
void freinD(){
  digitalWrite(6, LOW);
  }


/******************** codeurs *******************/
void frontG()   {
   ++PosG;
   if (PosG == objPosG) freinG();
}

void frontD()   {
   ++PosD;
   if (PosD == objPosD) freinD();
}

 

 

 

Vous aimerez aussi...

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *