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

Schéma du montage électronique :

Pour les amateurs d'impression 3D, j'ai fait quelques templates qui permettent d'imprimer divers boitiers pouvant accueillir les divers composants utilisés dans mes tutoriels.
- Pour un composant PIR, vous trouverez le boitier à imprimer ici.

    Il faut compter environ 4h pour imprimer les composants de ce boitier.


- Pour un relais, vous trouverez le boitier à imprimer ici.
    Il faut compter environ 2h pour imprimer les composants de ce boitier.




L'ensemble des impressions 3D a été réalisé sur une imprimante Creality3D Ender-3 pro avec les réglages standards suivants:

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);
}

Forum

Vos avis/remarques...

Veuillez vous connecter pour laisser vos commentaires...