Arduino


Construction d'un petit robot commandé par le port série de l'ordinateur

Publié le 05/05/2019



Dans cette nouvelle publication, nous allons créer un petit robot "basique".
Il pourra avancer, reculer, tourner à gauche et à droite.
Il pourra allumer ses phares, et un clignotant s'éclairera lorsqu'il tournera à gauche ou à droite.

Deux moteurs seront utilisés pour effectuer les mouvements. Il s'agit de simples moteurs continue contrôlés par un L293D.
Ce composant L293D peux contrôler jusqu'à 4 moteurs.

Ce petit robot sera, dans un premier temps, contrôlé par le port série de l'ordinateur. Dans une prochaine publication, je le couplerai à un petit joystick et une liaison sans fils.

Pour l'alimentation des moteurs, il faut prévoir une batterie extérieure car ses derniers sont gourmands en courant.

Le chassis du robot est monté sur les deux roues, qui sont indépendantes, et portent sur un bouchon de bouteille d'eau (qui sert de guide et permet une glisse quasi-parfaite).

Dans la vidéo, vous verrez la séquence suivante exécutée par le robot: ++++-----+++++------44444466666688882222

Cette séquence envoyée sur le port série va faire clignoter les phares, faire tourner sur lui même le robot à gauche, puis à droite. Enfin il va avancer, puis reculer.

+ permet d'allumer les phares
- permet d'éteindre les phares
4 correspond au pad numérique gauche
6 correspond au pad numérique droite
8 correspond au pad numérique avant
2 correspond au pad numérique arrière

Il y a également la possibilité d'exécuter les mouvements suivants:
7 correspond au pad numérique avant gauche
9 correspond au pad numérique avant droite
1 correspond au pad numérique arrière gauche
3 correspond au pad numérique arrière droite

Liste des composants nécessaires pour la réalisation du circuit :

  • Ruban Led1
  • Led jaune2
  • Moteur sur roue2
  • Boitier1
  • Bouchon bouteille d'eau1
  • Batteries/piles 9v1
  • L293D1


Schéma du montage électronique :


Pour les personnes possédant Fritzing, voici le schéma électronique.


Voici le code à télécharger dans votre Arduino:

String readString;

const byte PIN1_MOTEUR2=13;        //pin de commande moteur 1
const byte PIN2_MOTEUR2=12;         // pin de commande moteur 1
const byte PINP_MOTEUR2=11;        // pin PWM moteur 1

const byte PIN1_MOTEUR1=8;        //pin de commande moteur 2
const byte PIN2_MOTEUR1=7;        // pin de commande moteur 2
const byte PINP_MOTEUR1=10;        // pin PWM moteur 2

const byte PIN6_LED=6;            // pin de commande des phares
const byte PIN4_CLIGNOTANT_DROIT=4;            // pin de commande du clignotant droit
const byte PIN5_CLIGNOTANT_GAUCHE=5;            // pin de commande du clignotant gauche


const byte MOTEUR_GAUCHE = 1;
const byte MOTEUR_DROIT = 2;

const byte VITESSE_LENT = 25;
const byte VITESSE_MODERE = 50;
const byte VITESSE_NORMAL = 100;

const byte PUISSANCE_MOTEUR = 50;

const byte DELAY_RECULE = 200;

int pin1Moteur1=PIN1_MOTEUR1; //pin de commande moteur 1
int pin2Moteur1=PIN2_MOTEUR1; // pin de commande moteur 1
int pinPMoteur1=PINP_MOTEUR1;// pin PWM moteur 1
int pin1Moteur2=PIN1_MOTEUR2; // pin de commande moteur 2
int pin2Moteur2=PIN2_MOTEUR2; // pin de commande moteur 2
int pinPMoteur2=PINP_MOTEUR2; // pin PWM moteur 2

void setup() 
{
  // put your setup code here, to run once:
  Serial.begin(9600); //initialise la communication s?rie
  /*pinMode(pin1Moteur1,OUTPUT);
  pinMode(pin2Moteur1,OUTPUT);
  pinMode(pinPMoteur1,OUTPUT);
  pinMode(pin1Moteur2,OUTPUT);
  pinMode(pin2Moteur2,OUTPUT);
  pinMode(pinPMoteur2,OUTPUT);*/

  pinMode(PIN6_LED,OUTPUT);
  pinMode(PIN4_CLIGNOTANT_DROIT,OUTPUT);
  pinMode(PIN5_CLIGNOTANT_GAUCHE,OUTPUT);
  
  pinMode(PIN1_MOTEUR1,OUTPUT);
  pinMode(PIN2_MOTEUR1,OUTPUT);
  pinMode(PINP_MOTEUR1,OUTPUT);

  pinMode(PIN1_MOTEUR2,OUTPUT);
  pinMode(PIN2_MOTEUR2,OUTPUT);
  pinMode(PINP_MOTEUR2,OUTPUT);

  /*ReculeGauche(PUISSANCE_MOTEUR, 1000);Serial.println("Arriere gauche");
  Recule(PUISSANCE_MOTEUR, 1000);Serial.println("Arriere");
  ReculeDroite(PUISSANCE_MOTEUR, 1000);Serial.println("Arriere droit");
  Gauche(PUISSANCE_MOTEUR, 1000);Serial.println(" gauche");
  Droite(PUISSANCE_MOTEUR, 1000); Serial.println("droit");
  AvanceGauche(PUISSANCE_MOTEUR, 1000);Serial.println("avant gauche");
  Avance(PUISSANCE_MOTEUR, 1000);Serial.println("avant");
  AvanceDroite(PUISSANCE_MOTEUR, 1000);Serial.println("avant droit");
  Arret();*/
}

void loop() 
{
    char c=0;
    
    if (Serial.available() >0)
    {
      c = Serial.read();
      Serial.print("Touche=");
      Serial.println(c);
    
    
      switch(c)
      {
        case 49: ReculeGauche(PUISSANCE_MOTEUR, 1000);Serial.println("Arriere gauche");break;
        case 50: Recule(PUISSANCE_MOTEUR, 1000);Serial.println("Arriere");break;
        case 51: ReculeDroite(PUISSANCE_MOTEUR, 1000);Serial.println("Arriere droit");break;
        case 52: Gauche(PUISSANCE_MOTEUR, 1000);Serial.println(" gauche");break;
        case 54: Droite(PUISSANCE_MOTEUR, 1000); Serial.println("droit");break;
        case 55: AvanceGauche(PUISSANCE_MOTEUR, 1000);Serial.println("avant gauche");break;
        case 56: Avance(PUISSANCE_MOTEUR, 1000);Serial.println("avant");break;
        case 57: AvanceDroite(PUISSANCE_MOTEUR, 1000);Serial.println("avant droit");break;
        case '+': digitalWrite(PIN6_LED,1);delay(250);break;
        case '-': digitalWrite(PIN6_LED,0);delay(250);break;
        default: Arret();Serial.println("avant droit");break;
      }

      c=0;
    }
 }

void actionMoteur(byte moteur,int sens,byte pourcentage)
{
  byte pin1,etat1,pin2,etat2,pinP,puissance; //variable de la fonction

  Serial.print(moteur);
  Serial.print("-");
  Serial.print(sens);
  Serial.print("-");
  Serial.println(pourcentage);
  
  //test num?ro du moteur
  if (moteur==MOTEUR_GAUCHE)
  {
      // On d?finit les PIN correspondant au moteur 1
      pin1=PIN1_MOTEUR1;
      pin2=PIN2_MOTEUR1;
      pinP=PINP_MOTEUR1;
  }
  else 
  {
      // On d?finit les PIN correspondant au moteur 2
      pin1=PIN1_MOTEUR2;
      pin2=PIN2_MOTEUR2;
      pinP=PINP_MOTEUR2;
  }
  
  // Test sens du moteur 1 (avant),-1 (arri?re) ou tout autre valeur (stoppe le moteur)
  if (sens==1)
  {
      etat1=1;
      etat2=0;
  }
  else if (sens==-1)
  {
      etat1=0;
      etat2=1;
  }
  else 
  {
      etat1=0;
      etat2=0;
  }
  
  puissance=map(pourcentage,0,100,0,255);
  
  analogWrite(pinP,puissance);
  digitalWrite(pin1,etat1);
  digitalWrite(pin2,etat2);
  
  // Affichage sur le moniteur s?rie (facultatif)
  Serial.print(F("Moteur : "));
  if (moteur==MOTEUR_GAUCHE)
    Serial.print(F("Gauche"));
  else
    Serial.print(F("Droit"));
    
  if (sens==-1 || sens==1)
  {
      Serial.print(F(" sens : "));
      if (sens==1)
        Serial.print(F("Avant"));
      else
        Serial.print(F("Arri?re"));
  }
  else 
  {
      Serial.print(" ! stop ! ");
      Serial.print(sens);
  }
  Serial.print(" puissance : ");
  Serial.println(pourcentage);
}

void Gauche(byte puissance, int ellapseTime)
{
   Serial.print(F("Gauche <------"));
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,1);
   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);  
   delay(ellapseTime);
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0);   
}

void Droite(byte puissance, int ellapseTime)
{
   Serial.print(F("Droite ------>"));
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   digitalWrite(PIN4_CLIGNOTANT_DROIT,1);
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0);
   delay(ellapseTime);
   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);
}

void Recule(byte puissance, int ellapseTime)
{
   Serial.print(F("Recule"));
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0);
   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);  
   delay(ellapseTime);
}

void ReculeGauche(byte puissance, int ellapseTime)
{
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,1);
   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);  
   
   Serial.print(F("Avance Gauche"));
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(DELAY_RECULE);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(ellapseTime/2);
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(DELAY_RECULE/2);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(ellapseTime/2);

   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0); 
}

void ReculeDroite(byte puissance, int ellapseTime)
{
   digitalWrite(PIN4_CLIGNOTANT_DROIT,1);
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0);
   
   Serial.print(F("Avance Droite"));
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(DELAY_RECULE);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(ellapseTime/2);
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(DELAY_RECULE/2);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(ellapseTime/2);

   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);
}

void AvanceGauche(byte puissance, int ellapseTime)
{
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,1);
   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);  
   
   Serial.print(F("Avance Gauche"));
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(DELAY_RECULE);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(ellapseTime/2);
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, 1, puissance);
   delay(DELAY_RECULE/2);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(ellapseTime/2);

   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0); 
}

void AvanceDroite(byte puissance, int ellapseTime)
{
   digitalWrite(PIN4_CLIGNOTANT_DROIT,1);
   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0);
   
   Serial.print(F("Avance Droite"));
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(DELAY_RECULE);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(ellapseTime/2);
   actionMoteur(MOTEUR_GAUCHE, 1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(DELAY_RECULE/2);
   Arret();
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(ellapseTime/2);

   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);
}

void Avance(byte puissance, int ellapseTime)
{
   Serial.print(F("Avance"));
   actionMoteur(MOTEUR_GAUCHE, -1, puissance);
   actionMoteur(MOTEUR_DROIT, -1, puissance);
   delay(ellapseTime);

   digitalWrite(PIN5_CLIGNOTANT_GAUCHE,0);
   digitalWrite(PIN4_CLIGNOTANT_DROIT,0);   
}


void Arret()
{
   //Serial.print(F("******* ARRET *******"));
   //actionMoteur(MOTEUR_GAUCHE, 0, 0);
   //actionMoteur(MOTEUR_DROIT, 0, 0);

   analogWrite(PINP_MOTEUR1,0);
  digitalWrite(PIN1_MOTEUR1,0);
  digitalWrite(PIN2_MOTEUR1,0);
   analogWrite(PINP_MOTEUR2,0);
  digitalWrite(PIN1_MOTEUR2,0);
  digitalWrite(PIN2_MOTEUR2,0);
}



Voici le projet zippé.


Nombre de vue(s): 266

Forum


Vos avis/remarques...


Veuillez vous connecter pour laisser vos commentaires...