74 réponses à ce sujet

[Mike118]

Pour poster du contenu sur robot maker je t'invite à lire cet article pour poster du contenu sur le forum robot maker:  Tu y trouveras entre autre comment poster une image 

[GD ONE]

Salut à tous et merci pour votre aide que je garantie précieuse.

Voilà mon petite robot pour ma formation.

 

J'ai dégoté un un petit plan et j'ai branché mes fils comme indiqués.

 

Les moteurs tournent d'un coté. Normal, puisque j'ai chargé le code fourni avec la machine. Je n'ai pas trouvé le code correspondant au schema ci-dessus.

Le servo et le Sensor Ultrasonic à l'air de fonctionner aussi puisqu'il n’arrête pas de tourner de gauche à droite. 

La télécommande IR aussi. Affichage des infos sur le moniteur et le bluetooth idem. 

 

L'étape suivant est la programmation. J'ai programmé avec plusieurs langages ( cobol, fortran, DB3) il y a une quarantaine d'année. Mais tout çà est plus ou moins effacé. Donc...

 

Ou puis-je trouver la formation nécessaire pour faire avancer mon projet sachant que je voudrais que mon robot avance en évitant les obstacles, pour commencer.

 

Cordialement

 

 

 

 

 

 

 

[Path]

Je crois que c'est pas déconnant d'aller sur le site arduino sur la page de référence du langage. De le lire. Et de commencer par utiliser l'arduino tout seul. Puis une led, le capteur, un moteur, les 4. Le tout en repensant le programme à chaque étape avec tout ce que arduino te permet de faire.

[Forthman]

+1 avec Path,

J'ajouterais que les exemples contenus dans l'IDE Arduino sont très bien, et sont suffisamment simple pour comprendre (enfin pour quelqu'un qui a pratiqué d'autres langages)

[Oracid]

Pour aller dans le sens de Path et de Forthman, j'ajouterais ces 2 liens d'initiations à Arduino, ici dans ce forum.
https://www.robot-ma...s/tuto-arduino/
https://www.robot-ma...no-en-samusant/

Si je me permettre un conseil, c'est d'y aller pas à pas.
Par exemple, apprendre à utiliser le capteur à ultrasons, https://www.robot-ma...ns-hc-sr04.html
Puis apprendre à commander un servo, https://www.robot-ma...omoteur-9g.html
A chaque fois un tutoriel est présent dans la fiche du produit.

Un shield de connections pour éviter un fouillis de cable est une excellente idée, c'est ce que j'utilise quotidiennement, mais d'un point de vue didactique c'est bien également de savoir utiliser une breadbord, https://www.robot-ma...dbord&results=5

[Mike118]

Salut à tous et merci pour votre aide que je garantie précieuse.

Voilà mon petite robot pour ma formation.

Mon-robot-web.jpg

 

J'ai dégoté un un petit plan et j'ai branché mes fils comme indiqués.

Diagram Rover correspondant à mon robot Ultrasonic Sensor et Sensor Shield V5.jpg

 

Les moteurs tournent d'un coté. Normal, puisque j'ai chargé le code fourni avec la machine. Je n'ai pas trouvé le code correspondant au schema ci-dessus.

Le servo et le Sensor Ultrasonic à l'air de fonctionner aussi puisqu'il n’arrête pas de tourner de gauche à droite. 

La télécommande IR aussi. Affichage des infos sur le moniteur et le bluetooth idem. 

 

L'étape suivant est la programmation. J'ai programmé avec plusieurs langages ( cobol, fortran, DB3) il y a une quarantaine d'année. Mais tout çà est plus ou moins effacé. Donc...

 

Ou puis-je trouver la formation nécessaire pour faire avancer mon projet sachant que je voudrais que mon robot avance en évitant les obstacles, pour commencer.

 

Cordialement

 

 

Je suis parfaitement d'accord avec Oracid, Forthman et Path, savoir utiliser les blocs de code 1 par 1 puis ensuite apprendre à les combiner est une bonne approche. 

 

Cependant si jamais cette méthode "académique" ne te convient pas ( savoir utiliser les différentes briques une par une avant d'essayer de les assembler ) vu que tu as un code avec déjà plein de choses qui bougent tu peux aussi essayer d'apprendre pas l'expérience et le test, dans ce cas là hésite pas à modifier le code que tu as dans tous les sens de manière méthodique pour comprendre ce que chaque ligne fait... 

Essaye de couper 1 à 1 les différents éléments que tu vois bouger.
Essaye de faire tourner les moteurs dans l'autre sens ... 

De désactiver les retours sur le moniteur , puis de les remettre en les changeant 
Etc ... 

Et si tu bloque sur l'usage d'un truc spécifique tu pourras regarder spécifiquement juste comment ce bloc fonctionne pour le modifier comme tu veux. 

Tu peux aussi poster ton code, décrire ce qui se passe en vrai, et dire ce que tu aimerais qu'il se passe ... On pourra aussi t'aider =) 

[GD ONE]

Bonjour,

J'avance, j'avance...

J'ai quand même un petit souci.. 

J'ai téléversé mon programme sur le robot. 

J'ai débranché mon robot et il a détalé comme un lapin sortant de son trou. Virant à gauche à droite, etc... J'étais ravi. Sauf que le lendemain j'ai re-éssayé. Et là !!! Surprise, il c'est mis à avoir le hoquet. Par contre connecté à la COM ça fonctionne. J'ai changé de pile (9V) pensant qu'il était gourmand en energie !!! Nada 

 

Une petite idée svp. Merci d'avance.

 

PS: J'ai pas encore tout compris du câblage et du programme, mais ça vient. Exemple: le servo à 3 fils mais on en déclare qu'un dans le programme.

[Sandro]

Bonjour,

pour ton problème de "hoquet", si tu ne nous donne pas le programme, on vas avoir du mal à t'aider. D'ailleurs, tu entends quoi exactement par hoquet? Que le robot oscille à gauche à droite sans avancer? Ou en avançant? Ou qu'il avant et recule de quelques millimètres à la fois? La encore, sans une description précise (ou une vidéo si tu trouve ça plus pratique que d'écrire une description détaillée), ça vas être dur de deviner ce qui se passe.

 

Deux tests potentiellement intéressants (mais inutiles sans le code et une description précise) serait de voir ce qui se passe si tu mets et enlève ta main de devant le capteur ultrason et/ou si tu déplace le robot à la main (en le soulevant).

 

 

Bref, je t'aide bien volontiers (et je suis probablement loin d'être le seul), mais il faut que tu nous donne les informations pour, sinon on ne vas pas pouvoir faire grand chose

 

 

PS : pour ton PS : tu ne déclare qu'un fil pour le servo car il n'y a qu'un fil que tu commande (le signal PWM qui dit au servo dans quelle position se mettre) : les deux autres fils sont la masse et le 5V qui sont branchés en permanence et avec lesquels l'Arduino ne doit rein faire

[GD ONE]

Merci a toi,

Voici le dernier schema que j'utilise.  Schema connectique.pdf   186,83 Ko   205 téléchargement(s)

 

Et le code. Il n'est pas de moi et j'ai essayé de l'adapter au diagram ci-dessus.  Obstacle_Avoidance_Car_1.0.ino   7 Ko   185 téléchargement(s)

 

Je mets un lien vers une vidéo. Ceci est le deuxième essai. Le premier fonctionnait très bien. Je trouve d'ailleurs les moteurs très puissant puisqu'il  a réussi à grimper sur un tapis à poil long. 

 

https://s.amsu.ng/n8RCSAVa02QN

 

Le robot fait des petits bonds en avant.

 

 

 

[Sandro]

Tu dis que le problème disparaît dès que tu branche l'arduino à l'ordinateur? (ça me surprend un peu). Si tu as le même problème avec l'arduino branché à l'ordi, alors ça faciliterait les choses : si tel est le cas, après chaque accolade ouvrante dans la fonction Self_Control, mets un Serial.println avec un message différent à chaque fois (ça peut juste être un chiffre) et envois nous le code modifié et ce que ça t'affichera sur le moniteur série : comme ça on saura ce que le robot est en train d'essayer de faire. C'est de manière générale une bonne méthode pour identifier un bug quand on ne sais pas trop de quelle partie du code il vient.

 

Sinon, j'ai une idée d'où pourrait venir le problème (en tout cas c'est très probablement une erreur) : dans Self_Control, quand tu fais tes mesures (avec Ultrasonic_Ranging, ask_pin_L et ask_pin_R), tu commence par les stoquer dans une variable (H, L et R), ce qui est très bien. Mais ensuite, quand tu veux utiliser ces longueurs, au lieu d'utiliser les variables, tu re-utilise les fonctions. Ce à quoi tu n'as probablement pas pensé, c'est que re-appeler ces fonctions reviens à faire une nouvelle mesure. Or, je ne pense pas que ce soit ce que tu veuilles : en effet, tu fais des mesures à gauche et à droite pour comparer sans bouger le servo entre les deux. Si tu utilise H, L et R à la place de tous les appels à ces fonctions (sauf pour calculer H, L et R), il est bien possible que ça résolve ton bug.

 

Une fois que tu as fais ça néanmoins, tu aura un petit "nouveau" bug : Quand tu es dans le cas Ultrasonic_Ranging<35, tu recule, mais tu ne mettra plus à jour la distance après avoir reculé avant de tester Ultrasonic_Ranging<60. Pour celà, deux possibilités : soit ("mauvaise" solution), tu mets à jour H juste après le premier if, soit, bien mieux, tu remplace le "if (Ultrasonic_Ranging(1) < 60)"  par "else if (Ultrasonic_Ranging(1) < 60)" : de cette manière, ce test ne sera exécuté que si le premier a échoué (ie si le range est entre 36 et 59)

[GD ONE]

Salut à tous, ça fait longtemps que je n'ai pas posté.

 

J'ai réussi à créer ma base robot (voir projet dans ma présentation) , avec une soucoupe et un pot en polypropylène acheté dans un magasin de botanique.

Sur cette soucoupe j'ai fixé une Arduino Mega 2560 surmontée d'une carte d'extension.

J'ai chiné sur internet des codes concoctés par des personnes plus doués que moi et j'ai bidouillé mon propre code.

Le robot est semi-autonome. C'est à dire qu'il est capable de se déplacer tout seul sans but précis. Il est pilotable à la voix (il est un peu sourd et n'entend pas toujours les commandes vocales) Il est aussi pilotable avec des boutons. Utilisation du logiciel  Android "ARDUINO BLUETOOTH CONTROLER" Apps Valley 

 

 Et ça donne ça. 

[code]
// Controle semi-autonome d'un robot
//

// Utilisation logiciel "ARDUINO BLUETOOTH CONTROLER" Apps Valley
// Programmé pour MEGA 2560 avec Carte d'extension

#include <HCSR04.h>
#include <NewPing.h> // bibliothèque de gestion des delays
#include <SoftwareSerial.h>

//DEFINITION CAPTEUR BLUETOOTH
SoftwareSerial hc06(0, 1);
unsigned char Bluetooth_val;        //définition de la valeur val

#define Lpwm_pin 16                 //Pin ajustement vitesse Gauche
#define Rpwm_pin 17                 //Pin ajustement vitesse Droit

//DEFINITION CONNEXION MOTEUR
int pinARG = 18;                     // définition de la broche 18 arrière gauche
int pinAVG = 19;                     // définition du broche 19 avant gauche
int pinARD = 20;                     // définition de la broche 20 arrière droite
int pinAVD = 21;                     // définition de la broche 21 avant droit

int dist_securite = 35;             // dist_securite Avant
int dist_securiteDG = 20;           // dist_securite Gauche Droite
int lgrobot = 30;                   // Largeur Robot Avant
int vdG = 0;                        // Delai des delay Gauche
int vdD = 0;                        // Delai des delay Droit

int lgpassage = 0;   // largeur de passage disponible soit largeur du robot+distance dispo à gauche=distance dispo à droite

int val;
int ledpin = 1;
String messageRecu = ""; // stockage du message venant du bluetooth
String messageRecu1 = ""; // stockage du message venant du bluetooth

const byte TRIGGERAG = A1; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOAG = A0;    // Broche ECHO du capteur ultrasonique HC-SR04
const byte TRIGGERAD = A5; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOAD = A4;    // Broche ECHO du capteur ultrasonique HC-SR04
const byte TRIGGERG = A3; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOG = A2;    // Broche ECHO du capteur ultrasonique HC-SR04
const byte TRIGGERD = A6; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOD = A7;    // Broche ECHO du capteur ultrasonique HC-SR04

// Constantes pour le timeout //
const unsigned long MESURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

// Vitesse du son dans l'air en mm/us //
const float VIT_SON = 340.0 / 1000;


//DEFINITION VITESSE MOTEUR AU DEPART
unsigned char Lpwm_val = 255;       // définition la vitesse du moteur avant gauche
unsigned char Rpwm_val = 249;       // définition la vitesse du moteur avant droit

//DEFINITION ETAT VOITURE
String Car_state = "";

void M_Control_IO_config(void)
{
  pinMode(pinARG, OUTPUT);   // définition de la broche arrière gauche en sortie
  pinMode(pinAVG, OUTPUT);   // définition de la broche avant gauche en sortie
  pinMode(pinARD, OUTPUT);   // définition de la broche arrière droite en sortie
  pinMode(pinAVD, OUTPUT);   // définition de la broche avant droit en sortie
  pinMode(Lpwm_pin, OUTPUT); // pin  5 (PWM)
  pinMode(Rpwm_pin, OUTPUT); // pin 10 (PWM)
}
void Set_Speed(unsigned char Left, unsigned char Right)
{
  analogWrite(Lpwm_pin, Left);
  analogWrite(Rpwm_pin, Right);
}
void avance()     //  Reculer
{
  digitalWrite(pinARD, LOW);
  digitalWrite(pinAVD, HIGH); // faire avancer le moteur AV droit
  digitalWrite(pinARG, LOW);
  digitalWrite(pinAVG, HIGH); // faire avancer le moteur AV gauche

  Car_state = "Avance";
}
void turnD()        // Turner à Droite
{
  digitalWrite(pinARD, LOW);  // faire reculer le moteur AR droit
  digitalWrite(pinAVD, HIGH); // faire avancer le moteur AV droit
  digitalWrite(pinARG, HIGH); // faire avancer le moteur AR gauche
  digitalWrite(pinAVG, LOW);  // faire reculer le moteur AV gauche

  Car_state = "A Droite";
}
void turnG()        //turning left(dual wheel)
{
  digitalWrite(pinARD, HIGH);  // faire avancer le moteur AV droit
  digitalWrite(pinAVD, LOW );  // faire avancer le moteur de l'avant droit
  digitalWrite(pinARG, LOW);   // faire avancer le moteur de l'arrière gauche
  digitalWrite(pinAVG, HIGH);  // faire avancer le moteur AV gauche

  Car_state = "A Gauche";
}
void stopp()         //stop
{
  digitalWrite(pinARD, HIGH);
  digitalWrite(pinAVD, HIGH);
  digitalWrite(pinARG, HIGH);
  digitalWrite(pinAVG, HIGH);

  Car_state = "Stop";
}
void recul()          // Avancer
{
  digitalWrite(pinARD, HIGH); // faire avancer le moteur de l'arrière droit
  digitalWrite(pinAVD, LOW);  // faire avancer le moteur de l'avant droit
  digitalWrite(pinARG, HIGH); // faire avancer le moteur de l'arrière gauche
  digitalWrite(pinAVG, LOW);  // faire avancer le moteur de l'avant  gauche

  Car_state = "Recule";
}

void onyva()
{

  // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Gauche//
  digitalWrite(TRIGGERAG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERAG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERAG, LOW);
  // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
  long mesureAG = pulseIn(ECHOAG, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  float distance_mmAG = mesureAG * 0.034 / 2;

  // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Droit//
  digitalWrite(TRIGGERAD, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERAD, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERAD, LOW);
  // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
  long mesureAD = pulseIn(ECHOAD, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  float distance_mmAD = mesureAD * 0.034 / 2;

  digitalWrite(TRIGGERG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERG, LOW);
  long mesureG = pulseIn(ECHOG, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  float distance_mmG = mesureG * 0.034 / 2;
  vdG = distance_mmG - dist_securiteDG;

  digitalWrite(TRIGGERD, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERD, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERD, LOW);

  // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
  long mesureD = pulseIn(ECHOD, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  float distance_mmD = mesureD  * 0.034 / 2;
  vdD = distance_mmD - dist_securiteDG;

  lgpassage = (pow(distance_mmG + lgrobot, 2) + pow(distance_mmD + lgrobot, 2));
  lgpassage = sqrt(lgpassage) / 2;
  /*
    Serial.print("lgpassage : "); Serial.print(lgpassage); Serial.print(" ----- distance_mmG : "); Serial.print(distance_mmG); Serial.print(" ---- distance_mmD : "); Serial.println(distance_mmD);
  */

  while (messageRecu1 != "sto")
  {

    if
    ((distance_mmD < dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG < dist_securite) && (distance_mmG < dist_securite))
    {
      messageRecu1 = "sto"; recul(); delay(200); stopp();
      /*  break;*/

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Gauche//
      digitalWrite(TRIGGERAG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAG, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAG = pulseIn(ECHOAG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAG = mesureAG * 0.034 / 2;

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Droit//
      digitalWrite(TRIGGERAD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAD, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAD = pulseIn(ECHOAD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAD = mesureAD * 0.034 / 2;

      digitalWrite(TRIGGERG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERG, LOW);
      long mesureG = pulseIn(ECHOG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmG = mesureG * 0.034 / 2;
      vdG = distance_mmG - dist_securiteDG;

      digitalWrite(TRIGGERD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERD, LOW);

      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureD = pulseIn(ECHOD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmD = mesureD  * 0.034 / 2;
      vdD = distance_mmD - dist_securiteDG;

      lgpassage = (pow(distance_mmG + lgrobot, 2) + pow(distance_mmD + lgrobot, 2));
      lgpassage = sqrt(lgpassage) / 2;



      if
      ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
      {
        if
        ((distance_mmD < dist_securiteDG))
        {
          messageRecu1 = "ga1";
          break;
        }
        else
        {
          messageRecu1 = "dr1";
          break;
        }
      }
    }

    if
    ((distance_mmD < dist_securiteDG))
    {
      messageRecu1 = "ga2";
      break;
    }

    if
    ((distance_mmG < dist_securiteDG))
    {
      messageRecu1 = "dr2";
      break;
    }


    if
    ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
    {
      if
      ((distance_mmD < dist_securiteDG))
      {
        messageRecu1 = "ga1";
        break;
      }
      else
      {
        messageRecu1 = "gau";
        break;
      }
    }

    if
    ((distance_mmG < distance_mmD) || (distance_mmG < lgpassage))
    {
      if
      ((distance_mmG < dist_securiteDG))
      {
        messageRecu1 = "dr1";
        break;
      }
      else
        messageRecu1 = "dro";
      break;
    }
    if
    ((distance_mmD < dist_securiteDG))
    {
      messageRecu1 = "ga2";
      break;
    }

    if
    ((distance_mmG < dist_securiteDG))
    {
      messageRecu1 = "dr2";
      break;
    }


    if
    (((distance_mmG < distance_mmAG) && (distance_mmAG < distance_mmAD) && (distance_mmAD > dist_securite) && (distance_mmD > dist_securiteDG))
        ||
        ((distance_mmD > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG > dist_securite) && (distance_mmG < dist_securite))
        ||
        ((distance_mmG < distance_mmAG) && (distance_mmAG < distance_mmAD) && (distance_mmAD < distance_mmD))
        ||
        ((distance_mmD < distance_mmAD) && (distance_mmAD > distance_mmAG) && (distance_mmAG > distance_mmG)))
    {
      messageRecu1 = "dr1";
      break;
    }
    if
    (((distance_mmD < distance_mmAD) && (distance_mmAD < distance_mmAG) && (distance_mmAG > dist_securite) && (distance_mmAG > dist_securiteDG))
        ||
        ((distance_mmG > dist_securite) && (distance_mmAG < dist_securite) && (distance_mmAD > dist_securite) && (distance_mmD < dist_securite))
        ||
        ((distance_mmD < distance_mmAD) && (distance_mmAD < distance_mmAG) && (distance_mmAG < distance_mmG))
        ||
        ((distance_mmG < distance_mmAG) && (distance_mmAG > distance_mmAD) && (distance_mmAD > distance_mmD)))
    {
      messageRecu1 = "ga1";
      break;
    }




    if
    ((distance_mmD > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG < dist_securite) && (distance_mmG > dist_securite))
    {
      messageRecu1 = "sto"; recul(); delay(200); stopp();
      /*  break;*/

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Gauche//
      digitalWrite(TRIGGERAG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAG, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAG = pulseIn(ECHOAG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAG = mesureAG * 0.034 / 2;

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Droit//
      digitalWrite(TRIGGERAD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAD, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAD = pulseIn(ECHOAD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAD = mesureAD * 0.034 / 2;

      digitalWrite(TRIGGERG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERG, LOW);
      long mesureG = pulseIn(ECHOG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmG = mesureG * 0.034 / 2;
      vdG = distance_mmG - dist_securiteDG;

      digitalWrite(TRIGGERD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERD, LOW);

      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureD = pulseIn(ECHOD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmD = mesureD  * 0.034 / 2;
      vdD = distance_mmD - dist_securiteDG;

      lgpassage = (pow(distance_mmG + lgrobot, 2) + pow(distance_mmD + lgrobot, 2));
      lgpassage = sqrt(lgpassage) / 2;



      if
      ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
      {
        if
        ((distance_mmD < dist_securiteDG))
        {
          messageRecu1 = "ga1";
          break;
        }
        else
        {
          messageRecu1 = "dr1";
          break;
        }
      }
    }





    if
    ((distance_mmD > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG > dist_securite) && (distance_mmG > dist_securite))
    {
      messageRecu1 = "sto"; recul(); delay(200); stopp();
      /*  break;*/

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Gauche//
      digitalWrite(TRIGGERAG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAG, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAG = pulseIn(ECHOAG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAG = mesureAG * 0.034 / 2;

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Droit//
      digitalWrite(TRIGGERAD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAD, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAD = pulseIn(ECHOAD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAD = mesureAD * 0.034 / 2;

      digitalWrite(TRIGGERG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERG, LOW);
      long mesureG = pulseIn(ECHOG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmG = mesureG * 0.034 / 2;
      vdG = distance_mmG - dist_securiteDG;

      digitalWrite(TRIGGERD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERD, LOW);

      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureD = pulseIn(ECHOD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmD = mesureD  * 0.034 / 2;
      vdD = distance_mmD - dist_securiteDG;

      lgpassage = (pow(distance_mmG + lgrobot, 2) + pow(distance_mmD + lgrobot, 2));
      lgpassage = sqrt(lgpassage) / 2;



      if
      ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
      {
        if
        ((distance_mmD < dist_securiteDG))
        {
          messageRecu1 = "ga1";
          break;
        }
        else
        {
          messageRecu1 = "dr1";
          break;
        }
      }
    }

    if
    ((distance_mmD > dist_securite) && (distance_mmAD > dist_securite) && (distance_mmAG < dist_securite) && (distance_mmG > dist_securite))
    {
      messageRecu1 = "dro";/* recul(); delay(200); */stopp();
      /*  break;*/
    }
    if
    ((distance_mmG > dist_securite) && (distance_mmAG > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmD > dist_securite))
    {
      messageRecu1 = "gau";/* recul(); delay(200); */stopp();
      /*  break;*/
    }
    if
    ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
    {
      if
      ((distance_mmD < dist_securiteDG))
      {
        messageRecu1 = "gau";
        break;
      }
      else
      {
        messageRecu1 = "dro";
        break;
      }
    }
  }

  Serial.print(" distance_mmG : "); Serial.print(distance_mmG); Serial.print(" distance_mmAG : "); Serial.print(distance_mmAG); Serial.print(" distance_mmD : "); Serial.print(distance_mmD);
  Serial.print(" distance_mmAD : "); Serial.println(distance_mmAD);


  if (messageRecu1.length() > 0)

    if ((messageRecu1.indexOf("rec") != -1)) { // marche arrière

      stopp(); recul(); delay(200);

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Gauche//
      digitalWrite(TRIGGERAG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAG, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAG = pulseIn(ECHOAG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAG = mesureAG * 0.034 / 2;

      // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Droit//
      digitalWrite(TRIGGERAD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERAD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERAD, LOW);
      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureAD = pulseIn(ECHOAD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmAD = mesureAD * 0.034 / 2;

      digitalWrite(TRIGGERG, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERG, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERG, LOW);
      long mesureG = pulseIn(ECHOG, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmG = mesureG * 0.034 / 2;
      vdG = distance_mmG  - dist_securiteDG;
      digitalWrite(TRIGGERD, LOW);
      delayMicroseconds(2);
      digitalWrite(TRIGGERD, HIGH);
      delayMicroseconds(10);
      digitalWrite(TRIGGERD, LOW);

      // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
      long mesureD = pulseIn(ECHOD, HIGH, MESURE_TIMEOUT);

      // Calculer la distance à partir du temps mesuré //
      float distance_mmD = mesureD  * 0.034 / 2;
      vdD = distance_mmD  - dist_securiteDG;

      lgpassage = (pow(distance_mmG + lgrobot, 2) + pow(distance_mmD + lgrobot, 2));
      lgpassage = sqrt(lgpassage) / 2;

      if
      ((distance_mmAG < dist_securite) &&  (distance_mmG > dist_securite))   {
        turnG(); delay(500); avance(); delay(5);
        return;
      }
      if
      ((distance_mmAD < dist_securite) &&  (distance_mmD > dist_securite))   {
        turnD(); delay(500); avance(); delay(5);
        return;
      }
    }

  if ((messageRecu1.indexOf("gau") != -1)) { // tourne à gauche
    Serial.println(" a gauche ");
    turnG(); delay(7); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("dro") != -1)) { //tourne à droite
    Serial.println(" a droite ");
    turnD(); delay(7); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("ga1") != -1)) { // tourne à gauche brièvement
    Serial.println(" a gauche brièvement");
    turnG(); delay(50 + vdG); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("dr1") != -1)) { //tourne à droite brièvement
    Serial.println(" a droite brièvement");
    turnD(); delay(50 + vdD); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("ga2") != -1)) { // tourne à gauche brièvement
    Serial.println(" a gauche brièvement");
    turnG(); delay(250); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("dr2") != -1)) { //tourne à droite brièvement
    Serial.println(" a droite brièvement");
    turnD(); delay(250); avance(); delay(5);
    return;
  }

  if ((messageRecu1.indexOf("sto") != -1)) { // moteur stop
    Serial.println (" stop ");
    stopp(); delay(5000);
  }


  /*
      else if ((messageRecu1.indexOf("dem") != -1)) { // moteur stop
        Serial.println (" demi-tour ");
        turnG();
        delay(2900);

      }
      else if ((messageRecu1.indexOf("qua") != -1)) { // moteur stop
        Serial.println (" quart-de-tour à gauche ");
        turnG();
        delay(725);
  */
  messageRecu1 = "";

}


void setup() {
  Serial.begin(9600);            //port serie initialise, utilisant Bluetooth comme port serie, reglage en bauds

  // Initialisation des broches Avant Gauche*/
  pinMode(TRIGGERAG, OUTPUT);
  digitalWrite(TRIGGERAG, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOAG, INPUT);

  // Initialisation des broches Avant Gauche*/
  pinMode(TRIGGERAD, OUTPUT);
  digitalWrite(TRIGGERAD, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOAD, INPUT);



  // Initialisation des broches Gauche*/
  pinMode(TRIGGERG, OUTPUT);
  digitalWrite(TRIGGERG, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOG, INPUT);

  // Initialisation des broches Droite*/
  pinMode(TRIGGERD, OUTPUT);
  digitalWrite(TRIGGERD, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOD, INPUT);

  Set_Speed(Lpwm_val, Rpwm_val); //reglage de la vitesse initialisee
  M_Control_IO_config();

  delay(3000);
}

void loop()
{

  while (Serial.available())
  {
    delay (3); // lecture car par car
    char c = Serial.read();
    messageRecu += c;
  }

  if (messageRecu.length() > 0)
  {

    if ((messageRecu.indexOf("recule") != -1)) { // marche arrière
      Serial.println ("recule");
      recul(); delay(800);
      stopp();
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("gauche") != -1)) { // tourne à gauche brièvement
      Serial.println ("a gauche");
      turnG(); delay(400);
      stopp();
      messageRecu = "";
      /*    avance();*/
    }
    else if ((messageRecu.indexOf("droite") != -1)) { //tourne à droite brièvement
      Serial.println ("a droite");
      turnD(); delay(400); stopp();
      messageRecu = "";
      /*     avance();*/
    }
    else if ((messageRecu.indexOf("sto") != -1)) { // moteur stop
      Serial.println ("stop");
      stopp();
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("demi-tour") != -1)) { // moteur stop
      Serial.println ("demi-tour");
      turnG(); delay(2200); stopp();
      messageRecu = "";
      /*   avance();*/
    }
    else if ((messageRecu.indexOf("quart-de-tour") != -1)) { // moteur stop
      Serial.println ("quart-de-tour à gauche");
      turnG(); delay(550); stopp();
      messageRecu = "";

      /*   avance();*/


    }
    else if ((messageRecu.indexOf("retourne") != -1)) { // marche avant
      Serial.println ("Retourne");
      turnG(); delay(2200); stopp();
      messageRecu = "avance";
      onyva();  //les instructions à répéter tant que la condition est vérifiée

      Serial.println (messageRecu);

    }

    else if ((messageRecu.indexOf("avance") != -1)) { // marche avant
      Serial.println (messageRecu);
      /*avance();*/
      onyva();  //les instructions à répéter tant que la condition est vérifiée

      Serial.println (messageRecu);
    }
    else if ((messageRecu.indexOf("viens ici") != -1)) { // marche avant
      Serial.println (messageRecu);
      /*avance();*/
      onyva();  //les instructions à répéter tant que la condition est vérifiée

      Serial.println (messageRecu);


      /*  else if ((messageRecu.indexOf("LEV") != -1)) { // tête levée puis retour position
          Serial.println ("tete haute");
          indicStop = 0;
          myServo2.write(80); // positionnement du servomotor de la tete
          delay (2000);
          myServo2.write(30);
          }
        else if ((messageRecu.indexOf("BAI") != -1)) { // tête baissée puis retour position
          Serial.println ("tete basse");
          indicStop = 0;
          myServo2.write(5); // positionnement du servomotor de la tete
          delay (2000);
          myServo2.write(30);
          }
        else if ((messageRecu.indexOf("LEF") != -1)) { // tête à gauche puis retour position
          Serial.println ("tete gauche");
          indicStop = 0;
          myServo1.write(100); // positionnement du servomotor de la tete
          delay (2000);
          myServo1.write(70);
          }
        else if ((messageRecu.indexOf("RIG") != -1)) { // tête à droite puis retour position
          Serial.println ("tete droite");
          indicStop = 0;
          myServo1.write(30); // positionnement du servomotor de la tete
          delay (2000);
          myServo1.write(70);
          }
        else if ((messageRecu.indexOf("MES") != -1)) { // demande de la distance à l'obstacle
          indicStop = 0;
          valeurAnalog = CentiF;// a affiner
          String valeurAnalogString = String(valeurAnalog);
          Serial.println(valeurAnalogString);
          HC06.print(valeurAnalogString); // envoi distance au bluetooth
        }*/

      /*   messageRecu = "";*/

    }
  }
}
[/code]

Il y a certainement mieux à faire et je compte sur vos conseils pour améliorer ce code. Les pieds de chaises, ont du mal à être détecté, par exemple.

 

Vidéo de la base robot

https://drive.google...AH6AblwBgatedwX

 

Cordialement

 

 

 

 

 

[Sandro]

Euh ...

tu nous donnes un code de 800 lignes et tu nous demande quoi faire pour l'améliorer?!?

 

La première chose à faire, ce serait de découper ton code en beaucoup plus de fonctions (la fonction onyva fait 550 ligne, ce qui est beaucoup trop). Quand les fonctions sont trop longues, c'est très difficile pour quelqu'un d'autre de s'y retrouver (et même pour soit même), et on peut difficilement tester les choses indépendamment, ou comparer les performances entre deux implémentations différentes.

 

La seconde chose est d'identifier l'élément limitant (éventuellement quelques uns), qui est le seul qui mérite d'être optimisé : chercher à tout optimiser est une perte de temps et une source d'ennuis. Déjà, est-ce que tu es limité par la vitesse d'exécution (dans ce cas il faut identifier quelle partie du code ralentit le plus l'exécution globale) ou par une "capacité" insuffisante (tu évoquais la détection des pieds de chaises, est-ce ça le plus gros "problème" actuel?)

 

 

Pour ma part, si tu as un problème concret (par exemple les pieds de chaises ne sont pas toujours détectés), et un découpage propre en fonctions (une fonction pour la détection d'un obstacle et une seconde pour déterminer le comportement du robot en cas d'obstacle), alors je veux bien jeter un coup d’œil et voir si je trouve des améliorations. Mais il est hors de question pour moi de lire et chercher à comprendre ton code de 800 lignes tel qu'il est écrit actuellement pour y chercher des améliorations.

 

Bonne soirée

Sandro

[GD ONE]

Merci pour la réponse.

 

Malgré que ce code fonctionne il y a plusieurs choses qui ne me plaisent pas.

 

J'ai bien tenté de mettre les mesures de distances dans une fonction pour éviter de les réécrire dans onyva() Seulement elle ne fonctionne pas dans le loop()

Je vais donc réessayer.

 

Une deuxième chose est le mouvement saccadés lors des évitements. J'aurais voulu quelque chose de plus fluide.

 

La troisième est bien évidemment l’évitement  des pieds de chaises ou de tables. Le plus important pour moi.

 

On va déjà partir sur ça.

 

Donc pour l'instant je vais tenter de mettre les fonctions de calcul des distances dans une fonction et poster éventuellement le résultat.

 

Cordialement

[Sandro]

J'ai bien tenté de mettre les mesures de distances dans une fonction pour éviter de les réécrire dans onyva() Seulement elle ne fonctionne pas dans le loop()

Je vais donc réessayer.

Tu n'est pas obligé d'appeler ces fonctions depuis loop : si pour l'instant tu fais la mesure dans onyva, alors il faut appeler la fonction dans onyva.

A priori, il n'y a aucune raison que ça ne marche pas depuis une fonction (si ta fonction ne fonctionne pas, alors poste ta fonction et la manière dont tu l'appelle, et on regardera ensemble ce qui ne vas pas.

 

 

Pour le reste, je regarderais ça quand tu aura modifié ton code pour utiliser plus de fonctions

[Oracid]

A mon avis, pour détecter un barreau de chaise, il faut définir la bonne distance de détection.

Ici, par exemple, je déplace un quadrupède dans une "forêt" de chaises ave 3 capteurs US. https://www.robot-ma...rquad/?p=105321

Plus la distance sera grande et plus facile sera la détection, mais elle sera moins précise. On ne peut pas tout avoir.

[R1D1]

Pour compléter ce que dit Sandro, il est important de faire des tests simples de tes fonctionnalités. Si tu veux mesurer une distance à partir de ton capteur, écris un code qui ne fait que ça, et teste ton code avec seulement le capteur branché sur ton Arduino. Quand tu as validé que ce code marche, tu peux créer une/des fonctions dont tu sais qu'elles font ce que tu veux comme tu le veux. En créant un ensemble de briques de code comme cela, tu simplifies le développement de ton projet et tu rends le code plus clair, ce qui te permet d'identifier les sources d'erreur plus facilement.

[Mike118]

Je t'invite à lire les sujets de :  https://www.robot-ma...eaire-motorise/et   https://www.robot-ma...ge-pour-bonsai/

 

qui sont des sujet où un débutant est guidé pas à pas pour apprendre, et fait des fonctions au fur et à mesure. 

Lire l'ensemble des échanges devrait te permettre d'apprendre beaucoup de choses.

[GD ONE]

Salut tous le monde,

 

J'ai réussi à créer une fonction pour y intégrer les mesures de distances. (miracle) cela supprime déjà 250 lignes dans le code.

 

Par contre pour les conditions "IF" je ne vois pas comment faire pour les mettre dans une fonction ou même les simplifier. Il y a probablement des testes en double, mais du moment que ça marche.

 

Mon robot est équipé de 4 détecteurs ultrason. 2 a l'avant avec un angle de 30° et 2 sur les cotés avec un angle de 45°. Je n'ai pas encore mis de détecteurs à l’arrière en cas de recul.

 

Il sont nommé  mmD et mmG pour les extrêmes et mmAD et mmAG pour les centraux.

 

Le seul problème qui me préoccupe actuellement c'est les pieds de chaises et ces mouvements saccadés pour éviter les obstacles. Le robot est capable de passer dans des endroits qui ne font pas plus de 42 cm alors que lui même en fait 32.

 

Lien vers le code modifié :  https://drive.google...jUDIbjnEa8o2yvA

 

// Controle semi-autonome d'un robot
//

// Utilisation logiciel Android "ARDUINO BLUETOOTH CONTROLER" Apps Valley
// Programmé pour MEGA 2560 avec Carte d'extension

#include <HCSR04.h>
#include <NewPing.h> // bibliothèque de gestion des delays
#include <SoftwareSerial.h>

//DEFINITION CAPTEUR BLUETOOTH
SoftwareSerial hc06(0, 1);
unsigned char Bluetooth_val;        //définition de la valeur val

#define Lpwm_pin 16                 //Pin ajustement vitesse Gauche
#define Rpwm_pin 17                 //Pin ajustement vitesse Droit

//DEFINITION CONNEXION MOTEUR
int pinARG = 18;                     // définition de la broche 18 arrière gauche
int pinAVG = 19;                     // définition du broche 19 avant gauche
int pinARD = 20;                     // définition de la broche 20 arrière droite
int pinAVD = 21;                     // définition de la broche 21 avant droit

int dist_securite = 35;             // dist_securite Avant
int dist_securiteDG = 20;           // dist_securite Gauche Droite
int lgrobot = 30;                   // Largeur Robot Avant
int vdG = 0;                        // Delai des delay Gauche
int vdD = 0;                        // Delai des delay Droit

int distance_mmD = 0;               // distance Avant Droit
int distance_mmG = 0;               // distance Avant Gauche
int distance_mmAD = 0;              // distance Avant Centre Droit
int distance_mmAG = 0;              // distance Avant Centre Gauche

int lgpassage = 0;   // largeur de passage disponible soit largeur du robot+distance dispo à gauche=distance dispo à droite

int val;
int ledpin = 1;
String messageRecu = ""; // stockage du message venant du bluetooth
String messageRecu1 = ""; // stockage du message venant du bluetooth

const byte TRIGGERAG = A1; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOAG = A0;    // Broche ECHO du capteur ultrasonique HC-SR04
const byte TRIGGERAD = A5; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOAD = A4;    // Broche ECHO du capteur ultrasonique HC-SR04
const byte TRIGGERG = A3; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOG = A2;    // Broche ECHO du capteur ultrasonique HC-SR04
const byte TRIGGERD = A6; // Broche TRIGGER du capteur ultrasonique HC-SR04
const byte ECHOD = A7;    // Broche ECHO du capteur ultrasonique HC-SR04

// Constantes pour le timeout //
const unsigned long MESURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

// Vitesse du son dans l'air en mm/us //
const float VIT_SON = 340.0 / 1000;


//DEFINITION VITESSE MOTEUR AU DEPART
unsigned char Lpwm_val = 255;       // définition la vitesse du moteur avant gauche
unsigned char Rpwm_val = 249;       // définition la vitesse du moteur avant droit

//DEFINITION ETAT VOITURE
String Car_state = "";

void M_Control_IO_config(void)
{
  pinMode(pinARG, OUTPUT);   // définition de la broche arrière gauche en sortie
  pinMode(pinAVG, OUTPUT);   // définition de la broche avant gauche en sortie
  pinMode(pinARD, OUTPUT);   // définition de la broche arrière droite en sortie
  pinMode(pinAVD, OUTPUT);   // définition de la broche avant droit en sortie
  pinMode(Lpwm_pin, OUTPUT); // pin  5 (PWM)
  pinMode(Rpwm_pin, OUTPUT); // pin 10 (PWM)
}
void Set_Speed(unsigned char Left, unsigned char Right)
{
  analogWrite(Lpwm_pin, Left);
  analogWrite(Rpwm_pin, Right);
}
void avance()     //  Reculer
{
  digitalWrite(pinARD, LOW);
  digitalWrite(pinAVD, HIGH); // faire avancer le moteur AV droit
  digitalWrite(pinARG, LOW);
  digitalWrite(pinAVG, HIGH); // faire avancer le moteur AV gauche

  Car_state = "Avance";
}
void turnD()        // Turner à Droite
{
  digitalWrite(pinARD, LOW);  // faire reculer le moteur AR droit
  digitalWrite(pinAVD, HIGH); // faire avancer le moteur AV droit
  digitalWrite(pinARG, HIGH); // faire avancer le moteur AR gauche
  digitalWrite(pinAVG, LOW);  // faire reculer le moteur AV gauche

  Car_state = "A Droite";
}
void turnG()        //turning left(dual wheel)
{
  digitalWrite(pinARD, HIGH);  // faire avancer le moteur AV droit
  digitalWrite(pinAVD, LOW );  // faire avancer le moteur de l'avant droit
  digitalWrite(pinARG, LOW);   // faire avancer le moteur de l'arrière gauche
  digitalWrite(pinAVG, HIGH);  // faire avancer le moteur AV gauche

  Car_state = "A Gauche";
}
void stopp()         //stop
{
  digitalWrite(pinARD, HIGH);
  digitalWrite(pinAVD, HIGH);
  digitalWrite(pinARG, HIGH);
  digitalWrite(pinAVG, HIGH);

  Car_state = "Stop";
}
void recul()          // Avancer
{
  digitalWrite(pinARD, HIGH); // faire avancer le moteur de l'arrière droit
  digitalWrite(pinAVD, LOW);  // faire avancer le moteur de l'avant droit
  digitalWrite(pinARG, HIGH); // faire avancer le moteur de l'arrière gauche
  digitalWrite(pinAVG, LOW);  // faire avancer le moteur de l'avant  gauche

  Car_state = "Recule";
}
void mesure_distance_obstacle()          // Mesure des Distances
{
  // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Gauche//
  digitalWrite(TRIGGERAG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERAG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERAG, LOW);
  // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
  long mesureAG = pulseIn(ECHOAG, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  distance_mmAG = mesureAG * 0.034 / 2;

  // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Droit//
  digitalWrite(TRIGGERAD, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERAD, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERAD, LOW);
  // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
  long mesureAD = pulseIn(ECHOAD, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  distance_mmAD = mesureAD * 0.034 / 2;

  digitalWrite(TRIGGERG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERG, LOW);
  long mesureG = pulseIn(ECHOG, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  distance_mmG = mesureG * 0.034 / 2;
  vdG = distance_mmG - dist_securiteDG;

  digitalWrite(TRIGGERD, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGERD, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGERD, LOW);

  // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
  long mesureD = pulseIn(ECHOD, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  distance_mmD = mesureD  * 0.034 / 2;
  vdD = distance_mmD - dist_securiteDG;

  lgpassage = (pow(distance_mmG + lgrobot, 2) + pow(distance_mmD + lgrobot, 2));
  lgpassage = sqrt(lgpassage) / 2;
  /*
    Serial.print("lgpassage : "); Serial.print(lgpassage); Serial.print(" ----- distance_mmG : "); Serial.print(distance_mmG); Serial.print(" ---- distance_mmD : "); Serial.println(distance_mmD);
  */
}

void onyva()
{
  mesure_distance_obstacle();
  
  while (messageRecu1 != "sto")
  {
    if
    ((distance_mmD < dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG < dist_securite) && (distance_mmG < dist_securite))
    {
      messageRecu1 = "sto"; recul(); delay(200); stopp();

      mesure_distance_obstacle();

      if
      ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
      {
        if
        ((distance_mmD < dist_securiteDG))
        {
          messageRecu1 = "ga1";
          break;
        }
        else
        {
          messageRecu1 = "dr1";
          break;
        }
      }
    }

    if
    ((distance_mmD < dist_securiteDG))
    {
      messageRecu1 = "ga2";
      break;
    }

    if
    ((distance_mmG < dist_securiteDG))
    {
      messageRecu1 = "dr2";
      break;
    }
    if
    ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
    {
      if
      ((distance_mmD < dist_securiteDG))
      {
        messageRecu1 = "ga1";
        break;
      }
      else
      {
        messageRecu1 = "gau";
        break;
      }
    }

    if
    ((distance_mmG < distance_mmD) || (distance_mmG < lgpassage))
    {
      if
      ((distance_mmG < dist_securiteDG))
      {
        messageRecu1 = "dr1";
        break;
      }
      else
        messageRecu1 = "dro";
      break;
    }
    if
    ((distance_mmD < dist_securiteDG))
    {
      messageRecu1 = "ga2";
      break;
    }

    if
    ((distance_mmG < dist_securiteDG))
    {
      messageRecu1 = "dr2";
      break;
    }

    if
    (((distance_mmG < distance_mmAG) && (distance_mmAG < distance_mmAD) && (distance_mmAD > dist_securite) && (distance_mmD > dist_securiteDG))
        ||
        ((distance_mmD > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG > dist_securite) && (distance_mmG < dist_securite))
        ||
        ((distance_mmG < distance_mmAG) && (distance_mmAG < distance_mmAD) && (distance_mmAD < distance_mmD))
        ||
        ((distance_mmD < distance_mmAD) && (distance_mmAD > distance_mmAG) && (distance_mmAG > distance_mmG)))
    {
      messageRecu1 = "dr1";
      break;
    }
    if
    (((distance_mmD < distance_mmAD) && (distance_mmAD < distance_mmAG) && (distance_mmAG > dist_securite) && (distance_mmAG > dist_securiteDG))
        ||
        ((distance_mmG > dist_securite) && (distance_mmAG < dist_securite) && (distance_mmAD > dist_securite) && (distance_mmD < dist_securite))
        ||
        ((distance_mmD < distance_mmAD) && (distance_mmAD < distance_mmAG) && (distance_mmAG < distance_mmG))
        ||
        ((distance_mmG < distance_mmAG) && (distance_mmAG > distance_mmAD) && (distance_mmAD > distance_mmD)))
    {
      messageRecu1 = "ga1";
      break;
    }
    if
    ((distance_mmD > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG < dist_securite) && (distance_mmG > dist_securite))
    {
      messageRecu1 = "sto"; recul(); delay(200); stopp();

      mesure_distance_obstacle();

      if
      ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
      {
        if
        ((distance_mmD < dist_securiteDG))
        {
          messageRecu1 = "ga1";
          break;
        }
        else
        {
          messageRecu1 = "dr1";
          break;
        }
      }
    }
    if
    ((distance_mmD > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmAG > dist_securite) && (distance_mmG > dist_securite))
    {
      messageRecu1 = "sto"; recul(); delay(200); stopp();
      /*  break;*/

      mesure_distance_obstacle();

      if
      ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
      {
        if
        ((distance_mmD < dist_securiteDG))
        {
          messageRecu1 = "ga1";
          break;
        }
        else
        {
          messageRecu1 = "dr1";
          break;
        }
      }
    }

    if
    ((distance_mmD > dist_securite) && (distance_mmAD > dist_securite) && (distance_mmAG < dist_securite) && (distance_mmG > dist_securite))
    {
      messageRecu1 = "dro";stopp();
      /*  break;*/
    }
    if
    ((distance_mmG > dist_securite) && (distance_mmAG > dist_securite) && (distance_mmAD < dist_securite) && (distance_mmD > dist_securite))
    {
      messageRecu1 = "gau";stopp();
      /*  break;*/
    }
    if
    ((distance_mmD < distance_mmG) || (distance_mmD < lgpassage))
    {
      if
      ((distance_mmD < dist_securiteDG))
      {
        messageRecu1 = "gau";
        break;
      }
      else
      {
        messageRecu1 = "dro";
        break;
      }
    }

if
    ((distance_mmD > dist_securite) && (distance_mmAD > dist_securite) && (distance_mmAG < dist_securite+10) && (distance_mmG > dist_securite))
    {
      messageRecu1 = "dro";stopp();
      /*  break;*/
    }
    if
    ((distance_mmG > dist_securite) && (distance_mmAG > dist_securite) && (distance_mmAD < dist_securite+10) && (distance_mmD > dist_securite))
    {
      messageRecu1 = "gau";stopp();
      /*  break;*/
    }
    
  }

  Serial.print(" distance_mmG : "); Serial.print(distance_mmG); Serial.print(" distance_mmAG : "); Serial.print(distance_mmAG); Serial.print(" distance_mmD : "); Serial.print(distance_mmD);
  Serial.print(" distance_mmAD : "); Serial.println(distance_mmAD);


  if (messageRecu1.length() > 0)

    if ((messageRecu1.indexOf("rec") != -1)) { // marche arrière

      stopp(); recul(); delay(200);

      mesure_distance_obstacle();
      if
      ((distance_mmAG < dist_securite) &&  (distance_mmG > dist_securite))   {
        turnG(); delay(500); avance(); delay(5);
        return;
      }
      if
      ((distance_mmAD < dist_securite) &&  (distance_mmD > dist_securite))   {
        turnD(); delay(500); avance(); delay(5);
        return;
      }
    }

  if ((messageRecu1.indexOf("gau") != -1)) { // tourne à gauche
    Serial.println(" a gauche ");
    turnG(); delay(7); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("dro") != -1)) { //tourne à droite
    Serial.println(" a droite ");
    turnD(); delay(7); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("ga1") != -1)) { // tourne à gauche brièvement
    Serial.println(" a gauche brièvement");
    turnG(); delay(50 + vdG); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("dr1") != -1)) { //tourne à droite brièvement
    Serial.println(" a droite brièvement");
    turnD(); delay(50 + vdD); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("ga2") != -1)) { // tourne à gauche brièvement
    Serial.println(" a gauche brièvement");
    turnG(); delay(250); avance(); delay(5);
    return;
  }
  if ((messageRecu1.indexOf("dr2") != -1)) { //tourne à droite brièvement
    Serial.println(" a droite brièvement");
    turnD(); delay(250); avance(); delay(5);
    return;
  }

  if ((messageRecu1.indexOf("sto") != -1)) { // moteur stop
    Serial.println (" stop ");
    stopp(); delay(5000);
  }

  /*
      else if ((messageRecu1.indexOf("dem") != -1)) { // moteur stop
        Serial.println (" demi-tour ");
        turnG();
        delay(2900);

      }
      else if ((messageRecu1.indexOf("qua") != -1)) { // moteur stop
        Serial.println (" quart-de-tour à gauche ");
        turnG();
        delay(725);
  */
  messageRecu1 = "";

}

void setup() {
  Serial.begin(9600);            //port serie initialise, utilisant Bluetooth comme port serie, reglage en bauds

  // Initialisation des broches Avant Gauche*/
  pinMode(TRIGGERAG, OUTPUT);
  digitalWrite(TRIGGERAG, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOAG, INPUT);

  // Initialisation des broches Avant Gauche*/
  pinMode(TRIGGERAD, OUTPUT);
  digitalWrite(TRIGGERAD, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOAD, INPUT);

  // Initialisation des broches Gauche*/
  pinMode(TRIGGERG, OUTPUT);
  digitalWrite(TRIGGERG, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOG, INPUT);

  // Initialisation des broches Droite*/
  pinMode(TRIGGERD, OUTPUT);
  digitalWrite(TRIGGERD, LOW); // La broche TRIGGER doit être à 0 au repos
  pinMode(ECHOD, INPUT);

  Set_Speed(Lpwm_val, Rpwm_val); //reglage de la vitesse initialisee
  M_Control_IO_config();

  delay(3000);
}

void loop()
{

  while (Serial.available())
  {
    delay (3); // lecture car par car
    char c = Serial.read();
    messageRecu += c;
  }

  if (messageRecu.length() > 0)
  {

    if ((messageRecu.indexOf("recule") != -1)) { // marche arrière
      Serial.println ("recule");
      recul(); delay(800);
      stopp();
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("gauche") != -1)) { // tourne à gauche brièvement
      Serial.println ("a gauche");
      turnG(); delay(400);
      stopp();
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("droite") != -1)) { //tourne à droite brièvement
      Serial.println ("a droite");
      turnD(); delay(400); stopp();
      messageRecu = "";
      /*     avance();*/
    }
    else if ((messageRecu.indexOf("sto") != -1)) { // moteur stop
      Serial.println ("stop");
      stopp();
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("demi-tour") != -1)) { // moteur stop
      Serial.println ("demi-tour");
      turnG(); delay(2200); stopp();
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("quart-de-tour") != -1)) { // moteur stop
      Serial.println ("quart-de-tour à gauche");
      turnG(); delay(550); stopp();
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("retourne") != -1)) { // marche avant
      Serial.println ("Retourne");
      turnG(); delay(2200); stopp();
      messageRecu = "avance";
      onyva();  //les instructions à répéter tant que la condition est vérifiée

      Serial.println (messageRecu);
    }

    else if ((messageRecu.indexOf("avance") != -1)) { // marche avant
      Serial.println (messageRecu);
      onyva();  //les instructions à répéter tant que la condition est vérifiée

      Serial.println (messageRecu);
    }
    else if ((messageRecu.indexOf("viens ici") != -1)) { // marche avant
      Serial.println (messageRecu);
       onyva();  //les instructions à répéter tant que la condition est vérifiée

      Serial.println (messageRecu);

    }
  }
}

 

Cordialement

Image(s) jointe(s)

• 

[Mike118]

tu peux simplifier " mesure_distance_obstacle() "  pour cela tu peux faire une fonction 

" Mesure_distance( pin ) "  qui prendra en paramètre le pin trig par exemple et qui te retournera le résultat. 

( Il faudra que tu échanges TRIGGERD et ECHOD , de sorte à ce que pour tous tes capteurs le pin trig soit toujours égale  au pin echo +1  ... de manière à ce que la simplification que je fait dans le code ci dessous marche toujours )

uint16_t mafonction ( uint8_t pin ) {

  // Lancer une mesure de distance en envoyant une impulsion de 10µs sur la broche TRIGGER Avant Gauche//
  digitalWrite(pin, HIGH);
  delayMicroseconds(10);
  digitalWrite(pin, LOW);
  // Mesurer le temps entre l'envoi de l'impulsion ultrasonique et son écho //
  long mesureAG = pulseIn(pin - 1, HIGH, MESURE_TIMEOUT);

  // Calculer la distance à partir du temps mesuré //
  return mesureAG * 0.034 / 2;

}

Si jamais la simplification ne te convient pas il y a toujours d'autre façon de faire possible permettant d'avoir le même résultat =)

 

Faire cette fonction est d'autant plus pertinent que tu va souhaiter utiliser plus de capteurs =) 

 

De la même façon tu peux faire une fonction d'initialisation pour des pins des capteurs ... 

 

 

Pour ce qui est de simplifier tes if je pense que tu pourrais simplifier la chose en changeant la structure des if. Il y a sans doute moyens de mieux combiner la chose. Une étude "logique " avec un tableau de karnaugh devrait t'aider à trouver les équations les plus optimales. 

 

[GD ONE]

Salut,

J'ai testé ton code plusieurs fois sans succès. Peut-être parce qu'ils sont connectés sur A0,A1,A2,etc... Si j'ai bien compris echo et trigger doivent être connecté sur des pin cote à cote.
Mais en partant de là j'ai quand même pu supprimer une dizaine de lignes supplémentaires.
Pour le tableau de karnaugh je vais me pencher sur la question mais cela me semble assez compliqué.
En tous cas j'ai déjà allégé mon programme de plus de 250 lignes grâce à toi, ce qui est déjà pas mal.

As-tu une idée pour que les évitement d'obstacle soient moins saccadés ?

Cordialement remerciements