Bonjour à tous,

 

Mon robot est actuellement pilotable par l'intermédiaire d'un smartphone.

Je souhaite utiliser une télécommande de casque VR tel que ci-dessous

 

Cette télécommande peut télécommander un smartphone, une tablette (le volume, changement de page, avance recule d'une vidéo, etc...)

 

Ma question est :

Comment coupler cette télécommande avec le HC-06 arduino, afin que je puisse télécommander le robot.

 

J'ai aussi envisager une télécommande radio.

 

Qu'en pensez vous ?

 

Merci

MIRACLE !!! Ca fait huit jours que je cherche.

 

Il faut modifier dans NEWPING.H  #define TIMER_ENABLED true  et le Définir sur "false" pour désactiver.

Bonjour à tous,

 

Cela fait un bail que je n'ai pas posté. Mon robot à bien avancé et fonctionne pas trop mal.

 

Je souhaiterais le sonoriser. J'ai trouvé sur la toile un code sonore D2R2 qui fonctionne une fois chargé sur ma MEGA

 

J'ai donc rajouté a mon code robot (qui fonctionne)  les informations du code D2R2

 

Et là j'ai les messages d'erreur ci-dessous

 

Salut à tous,

 

Voilà mon dernier code avec des déplacements un peu plus cool. J'ai l'impression que mes servos ne sont pas assez puissant, car lorsque le bras est tendu un des servos lâche et remonte ensuite.

[code]

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

/*#define NO_OF_FIELDS 6*/

Servo base, shoulder, foreArm, wristFlex, wristRotate, claw;

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

// variable contenant la position des servomoteurs

int pos_base = 0;
int pos_shoulder = 0;
int pos_foreArm = 0;
int pos_wristFlex = 0;
int pos_wristRotate = 0;
int pos_claw = 0;

//Déclaration des constantes
#define UPDATE_TIME 15

int Max_pos_base = 170;
int Max_pos_shoulder = 175;
int Max_pos_foreArm = 45;
int Max_pos_wristFlex = 175;
int Max_pos_wristRotate = 175;
int Max_pos_claw = 160;

int Min_pos_base = 0;
int Min_pos_shoulder = 20;
int Min_pos_foreArm = 175;
int Min_pos_wristFlex = 0;
int Min_pos_wristRotate = 0;
int Min_pos_claw = 20;


String messageRecu = ""; // stockage du message venant du bluetooth

void setup()
{
  Serial.begin(38400);

  base.attach(2);
  shoulder.attach(3);
  foreArm.attach(4);
  wristFlex.attach(5);
  wristRotate.attach(6);
  claw.attach(7);

  //initialise all arms

  base.write(Min_pos_base);                 //  90      0 = Bras vertical,  Haut les mains = limite 170
  shoulder.write(Min_pos_shoulder);         // 150      0 = Bras pendant
  foreArm.write(Min_pos_foreArm);           //  40      40 = Coude fermé,   Coude ouvert = 179
  wristFlex.write(Min_pos_wristFlex);       //  90      0 = Poignet ouvert, limite fermé = 175
  wristRotate.write(Min_pos_wristRotate);   //  90      0 = Paume en dessous, Paume audessus limite = 175
  claw.write(Min_pos_claw);                 //   0      0 = Pince ouverte, Pince fermé = 179

  pinMode(ledpin, OUTPUT);
}

void loop()
{

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

  if (messageRecu.length() > 0)
  {
    //************************ MAITRISE BRAS I ***************************//

    if ((messageRecu.indexOf("monte bras") != -1)) { // Bras monte
      Serial.println ("monte bras");
      for (pos_base = Min_pos_base; pos_base <= Max_pos_base; pos_base += 1) {
        base.write(pos_base);
        Serial.print ("Min : "); Serial.print (Min_pos_base); Serial.print (" Max : "); Serial.print (Max_pos_base); Serial.print (" increment : "); Serial.println(pos_base);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("baisse bras") != -1)) { // Bras descend
      Serial.println ("baisse bras");
      for (pos_base = Max_pos_base; pos_base >= Min_pos_base; pos_base -= 1) {
        base.write(pos_base);
        Serial.print ("Min : "); Serial.print (Min_pos_base); Serial.print (" Max : "); Serial.print (Max_pos_base); Serial.print (" increment : "); Serial.println(pos_base);
        delay(UPDATE_TIME);
      }
      messageRecu = "";
    }
    //************************ MAITRISE BRAS II ***************************//

    else if ((messageRecu.indexOf("ouvre bras") != -1)) { // ouvre bras
      Serial.println ("ouvre bras");
      for (pos_shoulder = Min_pos_shoulder; pos_shoulder <= Max_pos_shoulder; pos_shoulder += 1) {
        shoulder.write(pos_shoulder);
        Serial.print ("Min : "); Serial.print (Min_pos_shoulder); Serial.print (" Max : "); Serial.print (Max_pos_shoulder); Serial.print (" increment : "); Serial.println(pos_shoulder);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ferme bras") != -1)) { // ferme bras
      Serial.println ("ferme bras");
      for (pos_shoulder = Max_pos_shoulder; pos_shoulder >= Min_pos_shoulder; pos_shoulder -= 1) {
        shoulder.write(pos_shoulder);
        Serial.print ("Min : "); Serial.print (Min_pos_shoulder); Serial.print (" Max : "); Serial.print (Max_pos_shoulder); Serial.print (" increment : "); Serial.println(pos_shoulder);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }

    //************************ MAITRISE COUDE  ***************************//

    else if ((messageRecu.indexOf("ferme coude") != -1)) { // ouvre coude
      Serial.println ("ferme coude");
      for (pos_foreArm = Min_pos_foreArm; pos_foreArm >= Max_pos_foreArm; pos_foreArm -= 1) {
        foreArm.write(pos_foreArm);
        Serial.print ("Min : "); Serial.print (Min_pos_foreArm); Serial.print (" Max : "); Serial.print (Max_pos_foreArm); Serial.print (" increment : "); Serial.println(pos_foreArm);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ouvre coude") != -1)) { // ferme coude
      Serial.println ("ouvre coude");
      
      for (pos_foreArm = Max_pos_foreArm; pos_foreArm <= Min_pos_foreArm; pos_foreArm += 1) {
        foreArm.write(pos_foreArm);
        Serial.print ("Min : "); Serial.print (Min_pos_foreArm); Serial.print (" Max : "); Serial.print (Max_pos_foreArm); Serial.print (" increment : "); Serial.println(pos_foreArm);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }

    //************************ MAITRISE POIGNET I  ***************************//

    else if ((messageRecu.indexOf("ferme poignet") != -1)) { // ferme poignet
      Serial.println ("ferme poignet");
      for (pos_wristFlex = Min_pos_wristFlex; pos_wristFlex <= Max_pos_wristFlex; pos_wristFlex += 1) {
        wristFlex.write(pos_wristFlex);
        Serial.print ("Min : "); Serial.print (Min_pos_wristFlex); Serial.print (" Max : "); Serial.print (Max_pos_wristFlex); Serial.print (" increment : "); Serial.println(pos_wristFlex);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ouvre poignet") != -1)) { // ouvre poignet
      Serial.println ("ouvre poignet");
      for (pos_wristFlex = Max_pos_wristFlex; pos_wristFlex >= Min_pos_wristFlex; pos_wristFlex -= 1) {
        wristFlex.write(pos_wristFlex);
        Serial.print ("Min : "); Serial.print (Min_pos_wristFlex); Serial.print (" Max : "); Serial.print (Max_pos_wristFlex); Serial.print (" increment : "); Serial.println(pos_wristFlex);
        delay(UPDATE_TIME);
      }
      messageRecu = "";
    }

    //************************ MAITRISE PAUME ROTATION  ***************************//

    else if ((messageRecu.indexOf("paume dessus") != -1)) { // paume dessus
      Serial.println ("paume dessus");
      for (pos_wristRotate = Min_pos_wristRotate; pos_wristRotate <= Max_pos_wristRotate; pos_wristRotate += 1) {
        wristRotate.write(pos_wristRotate);
        Serial.print ("Min : "); Serial.print (Min_pos_wristRotate); Serial.print (" Max : "); Serial.print (Max_pos_wristRotate); Serial.print (" increment : "); Serial.println(pos_wristRotate);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("paume dessous") != -1)) { // paume dessous
      Serial.println ("paume dessous");
      for (pos_wristRotate = Max_pos_wristRotate; pos_wristRotate >= Min_pos_wristRotate; pos_wristRotate -= 1) {
        wristRotate.write(pos_wristRotate);
        Serial.print ("Min : "); Serial.print (Min_pos_wristRotate); Serial.print (" Max : "); Serial.print (Max_pos_wristRotate); Serial.print (" increment : "); Serial.println(pos_wristRotate);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    //************************ MAITRISE PINCE  ***************************//

    else if ((messageRecu.indexOf("ferme pince") != -1)) { // ferme pince
      Serial.println ("ferme pince");
      for (pos_claw = Min_pos_claw; pos_claw <= Max_pos_claw; pos_claw += 1) {
        claw.write(pos_claw);
        Serial.print ("Min : "); Serial.print (Min_pos_claw); Serial.print (" Max : "); Serial.print (Max_pos_claw); Serial.print (" increment : "); Serial.println(pos_claw);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ouvre pince") != -1)) { // ouvre pince
      Serial.println ("ouvre pince");
      for (pos_claw = Max_pos_claw; pos_claw <= Min_pos_claw; pos_claw -= 1) {
        claw.write(pos_claw);
        Serial.print ("Min : "); Serial.print (Min_pos_claw); Serial.print (" Max : "); Serial.print (Max_pos_claw); Serial.print (" increment : "); Serial.println(pos_claw);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    //************************ POSITION DEFENSE  ***************************//

    else if ((messageRecu.indexOf("defense") != -1)) { // position defense
      Serial.println ("defense");
      base.write(90);              //  90      0 = Bras vertical,  Haut les mains = limite 170
      shoulder.write(150);         // 150      0 = Bras pendant
      foreArm.write(90);           //  40      40 = Coude fermé,   Coude ouvert = 179
      wristFlex.write(90);         //  90      0 = Poignet ouvert, limite fermé = 175
      wristRotate.write(90);       //  90      0 = Paume en dessous, Paume audessus limite = 175
      claw.write(160);               //   0      0 = Pince ouverte, Pince fermé = 179
    }
    messageRecu = "";
  }
}
[/code]

Je n'ai pas de boucle FOR dans la position DEFENSE car je souhaite un effet agressif pour ce code.

Bien sûr la commande vocale ne fonctionne toujours pas.

 

A+

Ok Mike,

 

On va commencer par A. Je vais aller visiter tout ça et tenter de modifier mes codes, que je te soumettrais plus tard.

 

Merci à vous tous.

Re-salut à tous,

 

On était bien quand même confiné, on pouvait bosser sur nos projets. Bref....

 

Voici le code test que j'utilise pour le bras. ATTENTION !!! Les commentaires ne sont pas les bons et la programmation est les ordres sont des ordres tests.  

 

Le code fonctionne avec le scope, c'est à dire lorsque je lui donne un ordre il l’exécute. Mais avec l'application que j'utilise sur mon mobile ou la tablette. RIEN...

Alors que la même application que j'utilise pour ma base, ça marche.

 

J'ai aussi inversé les modules HC-06 de ma base vers le bras pour tester, il ne veut rien savoir.

 

Il y aussi un second truc qui me préoccupe, c'est la rapidité des mouvements. C'est trop sec. Les servos vont pas tenir longtemps comme ça et je vous dis le nombre de fois ou je dois resserrer les boulons.

[code]

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

/*#define NO_OF_FIELDS 6*/

Servo base, shoulder, foreArm, wristFlex, wristRotate, claw;

SoftwareSerial hc06(A0, A1);   // RX,TX
//DEFINITION CAPTEUR BLUETOOTH
unsigned char Bluetooth_val;        //définition de la valeur val
int val;
int ledpin = 1;
String messageRecu = ""; // stockage du message venant du bluetooth

void setup()
{
  Serial.begin(38400);

  base.attach(2);
  shoulder.attach(3);
  foreArm.attach(4);
  wristFlex.attach(5);
  wristRotate.attach(6);
  claw.attach(7);

  //initialise all arms

  base.write(0);               //  90      0 = Bras vertical,  Haut les mains = limite 170
  shoulder.write(0);           // 150      0 = Bras pendant
  foreArm.write(179);          //  40      40 = Coude fermé,   Coude ouvert = 179
  wristFlex.write(0);          //  90      0 = Poignet ouvert, limite fermé = 175
  wristRotate.write(0);        //  90      0 = Paume en dessous, Paume audessus limite = 175
  claw.write(0);               //   0      0 = Pince ouverte, Pince fermé = 179

  pinMode(ledpin, OUTPUT);
}

void loop()
{

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

  if (messageRecu.length() > 0)
  {

    if ((messageRecu.indexOf("monte") != -1)) { // marche arrière
      Serial.println ("monte");
      base.write(90);
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("descend") != -1)) { // tourne à gauche brièvement
      Serial.println ("descend");
      base.write(0);
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("recule") != -1)) { //tourne à droite brièvement
      Serial.println ("recule");
      shoulder.write(0);
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("sto") != -1)) { // moteur stop
      Serial.println ("stop");

      messageRecu = "";
    }
    else if ((messageRecu.indexOf("salut") != -1)) { // moteur stop
      Serial.println ("demi-tour");

      messageRecu = "";
    }
    else if ((messageRecu.indexOf("avance") != -1)) { // moteur stop
      Serial.println ("avance");
      shoulder.write(90);
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("ouvre") != -1)) { // marche avant
      Serial.println ("ouvre");
      claw.write(175);
      messageRecu = "";

    }

    else if ((messageRecu.indexOf("ferme") != -1)) { // marche avant
      Serial.println ("ferme");
      messageRecu = "";
      claw.write(10);
    }
    else if ((messageRecu.indexOf("defense") != -1)) { // marche avant
      Serial.println ("defense");
      base.write(90);              //  90      0 = Bras vertical,  Haut les mains = limite 170
      shoulder.write(150);         // 150      0 = Bras pendant
      foreArm.write(45);          //  40      40 = Coude fermé,   Coude ouvert = 179
      wristFlex.write(90);          //  90      0 = Poignet ouvert, limite fermé = 175
      wristRotate.write(90);       //  90      0 = Paume en dessous, Paume audessus limite = 175
      claw.write(0);               //   0      0 = Pince ouverte, Pince fermé = 179
      messageRecu = "";
    }
  }
}
[/code]

Cordialement

Pour MIKE, merci pour le mail. J'ai rien compris, car j’étais sur le forum.

 

Pour Sandro

 

Merci pour cette excellente réponse, clair et explicite. En effet cela me parait cohérent. J'ai monté  mon bras sur un support  et il pend comme pend le bras d'une personne, flasque.
 Dès le chargement du programme le bras se met en position de défense comme un boxeur qui correspondrait au 90° que tu dit.

 

J'ai testé ton avis et c'est effectivement ça. J'ai aussi testé la commande vocale. Marche pas. J'ai pourtant utilisé le même programme que pour la base.

En y réfléchissant bien je me demande si je vais continuer sur cette voie là. Cà fait plus d'un mois que je galère avec ce bras.

 Merci, cordialement et a+

Re,

 

Petite question. Est-ce qu'un servo à un cerveau.

Je m'explique. J'ai vidé la mémoire de ma MEGA avec un programme RESET. (Setup vide et Loop vide)

Mon bras se met en position relaché.

 

je charge ce programme

[code]

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

/*#define NO_OF_FIELDS 6*/

Servo base, shoulder, foreArm, wristFlex, wristRotate, claw;

SoftwareSerial hc06(0, 1);   // RX,TX
//DEFINITION CAPTEUR BLUETOOTH
unsigned char Bluetooth_val;        //définition de la valeur val
String messageRecu = ""; // stockage du message venant du bluetooth

int ledPin = 13;

void setup()
{
  Serial.begin(38400);

  base.attach(2);
  shoulder.attach(3);
  foreArm.attach(4);
  wristFlex.attach(5);
  wristRotate.attach(6);
  claw.attach(7);
/*
  //initialise all arms

  base.write(0);              //  90      0 = Bras horizontal
  shoulder.write(0);          // 150      0 = Bras pendant
  foreArm.write(180);         //  40      40 = Coude fermé
  wristFlex.write(0);         //  90      0 = Poignet ouvert limite fermé 175
  wristRotate.write(0);       //  90    180 = Paume au dessus
  claw.write(175);            //  0       0 = Pince ouverte
*/
  pinMode(ledPin, OUTPUT);
}

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");
  //initialise all arms

    }
    else if ((messageRecu.indexOf("gauche") != -1)) { // tourne à gauche brièvement
      Serial.println ("a gauche");

    }
    else if ((messageRecu.indexOf("droite") != -1)) { //tourne à droite brièvement
      Serial.println ("a droite");

      /*     avance();*/
    }
    else if ((messageRecu.indexOf("sto") != -1)) { // moteur stop
      Serial.println ("stop");
 
    }
    else if ((messageRecu.indexOf("demi-tour") != -1)) { // moteur stop
      Serial.println ("demi-tour");
  
    }
    else if ((messageRecu.indexOf("quart-de-tour") != -1)) { // moteur stop
      Serial.println ("quart-de-tour à gauche");
 
    }
    else if ((messageRecu.indexOf("retourne") != -1)) { // marche avant
      Serial.println ("Retourne");
 

      Serial.println (messageRecu);
    }

    else if ((messageRecu.indexOf("avance") != -1)) { // marche avant
      Serial.println (messageRecu);
 

      Serial.println (messageRecu);
    }
    else if ((messageRecu.indexOf("viens ici") != -1)) { // marche avant
      Serial.println (messageRecu);


      Serial.println (messageRecu);

    }
  }
}
[/code]

Le bras n'est pas censé bougé puisque je ne lui donne pas d'instruction. Pourtant dès que j'alimente en courant, le bras se met dans une position assez agressive d'ailleurs.  Pourquoi ?

 

Cordialement

 

Malheureusement le test proposé par oracid ( qui est un très bon test pour éliminer les problèmes qui viendraient du code ) n'aidera sans doutes pas ici si c'est bien un problème " électrique " comme je le dis ... 
 

 

 

C'est bien un problème électrique. Merci Mike..

 

La batterie que j'utilisais était une batterie 24V   2000 mAh  que je réduisais à 5V.  Ampérage pas assez puissant, apparemment.

J'ai donc utiliser des batteries 3,7V 2500 mAh et là plus de problème, ça marche. 

 

Je vais passer à la programmation vocal et télécommande du bras dans le même principe que ma Base.

 

A+

Salut,

 

Voilà la connexion. De plus je viens de flinguer ma UNO suite à une mauvaise manip. j'ai rebranché le shield V5  provisoirement sur une MEGA. 

 

 

Non, le 5V est uniquement branché sur le schield et l'arduino n'est pas alimenté.

 

A+

Salut,

 

J'ai modifié le code. Le bras effectue la séquence 3 à 4 fois puis par en sucette.

[code]
#include <Servo.h>
Servo servoBaseG;  // create servo object to control a servo
Servo servoEpauleG;  // create servo object to control a servo

Servo servoCoudeG;  // create servo object to control a servo
Servo servoPoigneHBG;  // create servo object to control a servo
Servo servoPoigneROG;  // create servo object to control a servo
Servo servoPinceG;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int posBaseG =0;    // variable to store the servo position
int posEpauleG =90;  // variable to store the servo position
int posCoudeG = 60;   // Coude
int posPoigneHBG =0;   // Poignet Haut Bas
int posPoigneROG = 45;   // Poignet Vertical
int posPinceG = 90;        // 0 Pince Ouverte

void setup() {
  servoBaseG.attach(2);            // attaches the servo on pin 7 to the servo object
  servoEpauleG.attach(3);          // attaches the servo on pin 8 to the servo object
  servoCoudeG.attach(4);           // attaches the servo on pin 9 to the servo object
  servoPoigneHBG.attach(5);       // attaches the servo on pin 10 to the servo object
  servoPoigneROG.attach(6);       // attaches the servo on pin 11 to the servo object
  servoPinceG.attach(7);          // attaches the servo on pin 12 to the servo object
}

void loop() {


    // in steps of 1 degree
    servoBaseG.write(posBaseG);                                // tell servo to go to position in variable 'pos'
    delay(20);                                                 // waits 15ms for the servo to reach the position

    servoEpauleG.write(posEpauleG);                            // tell servo to go to position in variable 'pos'
    delay(20);                                                 // waits 15ms for the servo to reach the position

    // in steps of 1 degree
    servoCoudeG.write(posCoudeG);                              // tell servo to go to position in variable 'pos'
    delay(20);                                                 // waits 15ms for the servo to reach the position
 

    servoPoigneHBG.write(posPoigneHBG);                            // tell servo to go to position in variable 'pos'
    delay(20);                                                     // waits 15ms for the servo to reach the position

    servoPoigneROG.write(posPoigneROG);                            // tell servo to go to position in variable 'pos'
    delay(20);                                                     // waits 15ms for the servo to reach the position

    servoPinceG.write(posPinceG);                                  // tell servo to go to position in variable 'pos'
    delay(20);                                                     // waits 15ms for the servo to reach the position

  
}
[/code]

Un bras humain au repos en général ça pend. Donc la variable de départ de chaque servo doit avoir une position bien défini. Laquelle ?

A terme le bras ne doit fait pas de séquence répétitive mais être piloté par la voix ou par les boutons sur le smartphone. Éventuellement camera mais j'en suis très loin. Pour l'instant je veux seulement qu'il réponde à des commandes basiques sans m'assommer ou détruire tout ce qui traîne sur ma table de travail.

 

La batterie est une batterie récupérée sur un un balai électrique hors d'usage. A pleine charge elle peut délivrer 24V pour 2000 Ah. Je souhaite l'utiliser pour alimenter tout le robot.

 

Cordialement

Salut à toutes et à tous,

 

Dans la continuation de mon robot je souhaite lui adjoindre des bras. j'ai donc acheté 2 bras similaire à celui-ci

Je le regrette déjà. Trop lourd, le moteur de base pas assez costaud.

 

J'ai quand même essayé de le faire bouger. Catastrophe... Ce truc là part dans tous les sens. j'ai bien sûr essayé de nombreux codes

trouvés sur la toile mais je n'ai pas réussi à les faire fonctionner. Par contre j'a trouvé un petite programme tous simple rien que pour tester les moteurs.

[code]
//  http://www.arduino.cc/en/Tutorial/Sweep


#include <Servo.h>
Servo servoBaseG;  // create servo object to control a servo
Servo servoEpauleG;  // create servo object to control a servo

Servo servoCoudeG;  // create servo object to control a servo
Servo servoPoigneHBG;  // create servo object to control a servo
Servo servoPoigneROG;  // create servo object to control a servo
Servo servoPinceG;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int posBaseG =0;    // variable to store the servo position
int posEpauleG =45;  // variable to store the servo position
int posCoudeG = 90;   // variable to store the servo position
int posPoigneHBG = 110;   // Poignet ????
int posPoigneROG = 180;   // Poignet Vertical
int posPinceG = 0;        // 0 Pince Ouverte

void setup() {
  servoBaseG.attach(7);            // attaches the servo on pin 7 to the servo object
  servoEpauleG.attach(8);          // attaches the servo on pin 8 to the servo object
  servoCoudeG.attach(9);           // attaches the servo on pin 9 to the servo object
  servoPoigneHBG.attach(3);       // attaches the servo on pin 10 to the servo object
  servoPoigneROG.attach(4);       // attaches the servo on pin 11 to the servo object
  servoPinceG.attach(12);          // attaches the servo on pin 12 to the servo object
}

void loop() {


    // in steps of 1 degree
    servoBaseG.write(posBaseG);                                // tell servo to go to position in variable 'pos'
    delay(20);                                                 // waits 15ms for the servo to reach the position

    servoEpauleG.write(posEpauleG);                            // tell servo to go to position in variable 'pos'
    delay(20);                                                 // waits 15ms for the servo to reach the position

    // in steps of 1 degree
    servoCoudeG.write(posCoudeG);                              // tell servo to go to position in variable 'pos'
    delay(20);                                                 // waits 15ms for the servo to reach the position
 

    servoPoigneHBG.write(posPoigneHBG);                            // tell servo to go to position in variable 'pos'
    delay(20);                                                     // waits 15ms for the servo to reach the position


    servoPoigneROG.write(posPoigneROG);                            // tell servo to go to position in variable 'pos'
    delay(20);                                                     // waits 15ms for the servo to reach the position

    servoPinceG.write(posPinceG);                                  // tell servo to go to position in variable 'pos'
    delay(20);                                                     // waits 15ms for the servo to reach the position

  
}
[/code]

 Malgré cela mon bras à tendance à s’énerver lorsque je le branche.

 

Les moteurs sont connectés à un Sensor Shield v5.0 sur un UNO. Le shield est connecté sur une batterie 12V . Entre la batterie et le shield un réducteur de tension règlé à 5V. J'ai vu aussi qu'il fallait régler l'ampérage.

 

La UNO est branché sur 9V

 

Si une généreuse âme pouvait m'aider, merci d'avance.

 

Encore une question. Si on pouvait m’orienter vers un bras plus enclin à répondre à mon souhait.

 

Cordialement

 

 

Salut,

Pas compris pourquoi tu l'as eu par mail. Bref.

 

En tous cas le code fonctionne. C'est valable pour un détecteur. Je vais essayer de bidouiller pour plusieurs.

 

Cordialement 

 

Ca marche voir ici

 

Cordialement

Salut à tous,

 

Alors j'ais creusé un peu ton code. MAIS !!!  çà ne marche pas.  Y veut rien savoir. le scoop affiche toujours zéro. J'ai même changé le matériel, on ne sait jamais. Rien n'y fait.

 

Je repartage le code  amélioré ROBOT II

 

A+

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

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

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

 

 

 

 

 

Merci a toi,

Voici le dernier schema que j'utilise.  Schema connectique.pdf   186,83 Ko   178 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   163 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.

 

 

 

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.

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

 

 

 

 

 

 

 

Merci pour la réponse. Effectivement il faut débrancher le module avant la programmation de la carte. Le module m'affiche les distances.

 

Sur ma carte arduino est insérée une sensor shield. Un schéma me dit qu'il faut brancher 2 fils sur le même pin.( Connection Ultrasonic Sensor Module).  Comment faire ? Un raccord ?

J'aurais bien mis le diagramme mais pas moyen de mettre d'image.

 

Cordialement

Salut à tous,

 

Pour commencer je viens de me procurer un petit Kit robot.   

 

Le montage technique est fait et quelques modules fonctionnent. Mais il y a des hics...

 

1. On me demande de brancher sur le "Sensor Shield" des câbles sur des pins déjà utilisés. (LCD  Parrallel , pin 8) qui est déjà occupé par le servo moteur du capteur à ultrasons. Puis-je brancher sur d'autres pins.

 

2. J'ai 3 traqueurs de lignes, mais le diagramme de connexion que pour 1 traqueur. Où je branches les autres ?

 

3. Le module  bluetooth me pose des soucis. Premièrement il clignote sans arrêt, et lors du téléversement du programme j'ai un message d'erreur ci-dessous.