J'ai trouver le futur nom du robot ! />

A.R.I.M

Autonomous Robotics Intelligent Mechanics

Par contre quelqu'un sait comment modifier le nom du sujet ? ^^ J'ai essayer d'éditer le premier message du sujet mais sa marche pas...
Cdt GeekMaxou

je crois que c'est "utiliser l'éditeur complet". A confirmer

Salut,
J'ai trouvé ça sur le forum, ça peut peut-être t'intéresser. Sur la vidéo du milieu il fabrique ses propre chaine et ca à l'air éfficace.

En tout cas, beau projet.

A+

oups http://letsmakerobots.com/node/22612

Et hop petite photo 3D des roulements si je garde l'idée des chenilles... ^^




Edit: si quelqu'un a une idéé pour les chenille (elle doivent avoir une largeur minimum de 5cm...) a moindre coût, sa sera sympa />
++ Maxime

Salut,
J'ai trouvé ça sur le forum, ça peut peut-être t'intéresser. Sur la vidéo du milieu il fabrique ses propre chaine et ca à l'air éfficace.

En tout cas, beau projet.

A+

Salut,

Je suis d'accord avec Microrupteurman2, faisant de la robotique pour mon loisir, je trouve que l'arduino est bien concue surtout avec ce systeme de shield.
Niveau programmation, n'ayant pas de connaisance particuliere, je trouve le language très accesible pour le commun des mortels /> , d'autant plus comme le dit Microrupteurman2 c'est une très grande communauté et on trouve de tout sur le net.
L'Arduino peut-être un tremplin pour ensuite aller plus loin et cible une catégorie de personne comme moi.

A+

Salut,

Pour info, j'utilise un chassis à chenille avec ce type de moteurs :
http://www.lynxmotion.com/p-94-gear-head-motor-12vdc-501-120rpm-6mm-shaft.aspx
et sur un terrain accidenté, c'est franchement pas terrible!

A+

Pour le deplacement de ton robot (gauche droite etc), tu peux tres bien utiliser 2 servos reliés à ton Arduino.
Par contre il te faudra certainement les modifier.
A ce sujet tu trouveras ce qu'il te faut sur le forum.

Amuse toi bien.

bonjour,

En cherchant un peut j'ai trouvé ca:
http://www.arobose.com/shop/cartes-d-extension-robot/99-diviseur-de-tension-analogique.html
a+

Bonjour "P2B",
je le connais bien c'est le "rovio".
Je ne le possède pas pour l'instant mais je devrais en trouvé un plus tard. />/>

Es tu content de son fonctionnement ?
donne moi des infos dessus, ton opinion d'utilisateur? />/>

Respectueusement ...

Franck

Perso j'en suis pas vraiment satisfait.

Il fonctionne bien en LOCAL, l'interface est bien faite, la prise en main est simple.
Par contre en 3G c'est une vraie "cata"; perte de signal, images décalées, pas de son meme avec un réseau 3G a fond.

Il existe une appli. pour iphone mais la prise en main est plus difficile.

J'ai également dû le renvoyer car la batterie ne tenait pas la charge.
Et pour finir le transfo. de la base est HS /> .et il n'a pas tourné depuis un bon bout de temps.

En tout cas j'aime bien son design.

A+
P2B

Merci

Salut,

Je sais pas ou tu en es. Je suis sur un robot un peut sur le même type que le tien.
Dans mon poste que voici http://www.robot-maker.com/forum/topic/8368-besoin-daide-arduino/
tu trouveras certainement des infos.
A+

Bonjour,

Savez vous s'il existe un shield Arduino pour tester son niveau de batterie. J'ai vu qu'on pouvait faire ça à travers un pont diviseur lien : http://skyduino.wordpress.com/2012/08/09/arduino-mesurer-la-tension-dun-batterie

Cordialement.
P2B

Salut

Super collection!
Moi je possède celui ci
a+

ou bien ca ?

 // OPTIMISATION DE L ANGLE
    if((degre < 30 && degre > 150) && (valUltraSon < distanceMinCote)) {
      
    }

Tout simplement, IMPRESSIONANT!

On est bien loin des legos de mon enfance...

Ce n'est pas évident à vérifier : le prog est long et complexe ce qui fait que même si il est remarquablement bien documenté il va être difficile d'y trouver les éventuelles erreurs (à première vue ça m'a l'air impeccable).

En ce qui concerne les erreurs de mesure, peut être qu'en ajoutant un ou deux "delay()" ça arrangerait le problème.. mais je dis ça et je ne dis rien car c'était juste une idée en passant. ^^

Edit : bravo pour les annotations c'est un détail mais ça aide beaucoup pour la relecture.

Merci pour ta réponse.
Après avoir pas mal cherché il semblerait que le probleme venait de là :
Dans la fonction "robotPivoteVersDegagement()"

 if (servoCamMax < 90) { 
    angleRotation = (91 - servoCamMax);  // ici j'avais mis 90 à la place de 91 et lorsque j'avais un angle de 90 ca faisait (90 - 90)
    dureeRotation = (angleRotation / 360.0) * dureeReference;  // et ici le resultat donnait : (0/360) * 3150 

Avant de continuer j'aimerai "ameliorer" un peut le code. Je voudrais que le robot continue de rouler si c'est un bord de couloir (0-10° et 170-180°) qui ne gène pas encore le robot.
Parceque pour l'instant ça fonctionne mais il met du temps a passer un seuil de porte.

J'ai pensé faire qq chose comme ca :

if((degre < 10) && (valUltraSon >= distanceMinCote))
// continue d'avancer

Merci

Bonjour,
Désole d'incister, mais qq'un pourrait'il jeter un coup d'oeil a mon code et me dire si c'est ok.
J'ai besoin de savoir pour avancer, car la suite de mon projet est de fusionner le mode manuel avec ce mode auto?.

Bon week end a tous.
Bien cordialement.
P2B

De ton bloque de pile a l'arduino t'as relié ca comment? avec un jack? si c'est le cas vérifie le + et le -

Salut,

Je vais laisser de cote pour l'instant "l'optimisation des angles", je ne trouve pas.
Je mets en ligne mon code concernant mon mode automatique si qq'un peut me dire s'il est correct le cas echeant me dire les erreurs ou les modif a faire.

Bien cordialement

P2B.

je n'arrive pas à le mettre en piece jointe alors voici en extrait de code dsl.

/* //////////////////////////////////////////////////////////////////////////////////////////////////////////
 *  PARTIE 2 : MODE AUTO
 * //////////////////////////////////////////////////////////////////////////////////////////////////////////
 *
 * LE 08/002/2013 PAR P2B
 *
 *  PROFIL DU ROBOT :
 *        CHASSIS A CHENILLE AVEC 2 MOTEURS DC 12V
 *        UNE TOURELLE SUR LAQUELLE EST MONTEE UN CAPTEUR A ULTRASONS.
 *
 *  BUT DU PROGRAMME : 
 *        COMME INDIQUE DANS LE TITRE, LE MODE AUTOMATIQUE DU ROBOT.
 *        POUR POUVOIR SE DEPLACER LE ROBOT EFFECTUE UN BALAYAGE CONSTANT DU CAPTEUR JUSQU A RENCONTRER UN OBSTACLE.
 *        LORSQU'UN OBSTACLE EST DETECTE A UN SEUIL DE 40 CM, LE ROBOT EFFECTUE UN SECOND BALAYAGE PLUS LENT
 *        AVEC UNE LECTURE DU CAPTEUR TOUS LES 10 DEGRES.
 *        ENSUITE, LE ROBOT RECUPERE LA VALEUR DU CAPTEUR LA PLUS HAUTE AINSI QUE L'ANGLE CORRESPONDANT.              
 *
 * //////////////////////////////////////////////////////////////////////////////////////////////////////////
 *  CONFIGURATION
 */////////////////////////////////////////////////////////////////////////////////////////////////////////

// ********  BIBLIOTHEQUE(S) UTILISEE(S)  ********
#include <Servo.h>

// ********  LES ENTREES ET SORTIES  ********
int dPinSRF05 = 2;
int dPinServoCam = 3;
int dPinBuzzer = 4;
int dPinRelaisMoteurs = 7;
int dPinMoteurG = 11;
int dPinMoteurD = 10;

// ********  OBJETS SERVO POUR LE CONTROLE DES MOTEURS  ********
Servo myCam; // SERVO QUI SUPPORTE LE CAPTEUR
Servo myMoteurG;    // LE MOTEUR GAUCHE
Servo myMoteurD;    // LE MOTEUR DROIT

// ********  VARIABLES GLOBALES  ********
int valUltraSon = 0;    // LE CAPTEUR SRF05
int valServoCam = 0;    // VALEUR DE L ANGLE DU SERVO QUI SUPPORTE LE CAPTEUR
int servoCamMax = 0;    // VALEUR MAXI DE L ANGLE DU SERVO QUI SUPPORTE LE CAPTEUR

// SEUILS DE SECURITE DU CAPTEUR
int distanceMinDevant = 30;
int distanceMinCote = 15;
int distanceSecurite = 15;

int vitGStop = 100;   // MOTEUR GAUCHE A L'ARRET
int vitDStop = 100;   // MOTEUR DROIT A L ARRET
int vitG = vitGStop;  // VITESSE DU MOTEUR GAUCHE
int vitD = vitDStop;  // VITESSE DU MOTEUR DROIT

boolean robotBouge = false;

/* /////////////////////////////////////////////////////////////////////////////////////////////////////////
 *  INITIALISATION
 */////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  Serial.begin(9600);

  pinMode(dPinServoCam, OUTPUT);
  pinMode(dPinBuzzer, OUTPUT);
  pinMode(dPinRelaisMoteurs, OUTPUT); 
  pinMode(dPinMoteurG, OUTPUT);
  pinMode(dPinMoteurD, OUTPUT);

  myCam.attach(dPinServoCam);
  myMoteurG.attach(dPinMoteurG);  
  myMoteurD.attach(dPinMoteurD);

  Serial.println("*********************************************");
  Serial.println("                  i ROBOT ");
  Serial.println("*********************************************");
  Serial.println(" ");
  delay(100);  

  // PETITES NOTES AU DEMARAGE
  for (int i = 1; i <= 3 ; i++) {
    playNote('c', 100); 
    playNote('d', 100);  
    delay(50);
  }
  //  ALLUMAGE DU RELAIS MOTEURS
  digitalWrite(dPinRelaisMoteurs, HIGH);
  Serial.println("RELAIS MOTEURS 'ON'");

  // CALCULE DE L ESPACE DEGAGE
  positionCentrale();
  simpleBalayage();
  robotPivoteVersDegagement();
  positionCentrale();
  robotAccelere(20, 20);
}

/* /////////////////////////////////////////////////////////////////////////////////////////////////////////
 *  PROGRAMME
 */////////////////////////////////////////////////////////////////////////////////////////////////////////

void loop()
{
  doubleBalayage();

  // DISTANCE DE SECURITE (REGLE A 15 CM)
  if(valUltraSon <= distanceSecurite) {
    valUltraSon = distanceObstacle();
    robotRecule(60, 60);
    delay(500);
    robotStop();
  }
  // SI LE ROBOT NE BOUGE PAS
  if (!robotBouge) {
    simpleBalayage();
    robotPivoteVersDegagement();    
    robotAccelere(20, 20);
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// SIMPLE BALAYAGE DU CAPTEUR AVEC ANALYSE DE L ESPACE LE PLUS DEGAGE
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void simpleBalayage()
{
  int valUltraSonMax = 0;
  int angleMin = 0;
  int angleMax = 180;  

  Serial.println("");
  Serial.println("     CALCULE DE L ANGLE DE DEGAGEMENT");
  Serial.println("");

  // BOUCLE POUR INCREMENTER LE SERVO "myCam" DE 0 A 180 DEG
  for (byte degre = angleMin ; degre <= angleMax; degre += 5) {
    myCam.write(degre);
    valUltraSon = distanceObstacle();

    // DISTANCE DE SECURITE (REGLE A 15 CM)
    if(valUltraSon <= distanceSecurite) {
      robotRecule(60, 60);
      delay(500);
      robotStop();
    }
    // TESTE LE SEUIL DU CAPTEUR (REGLE A 40 CM), ET AFFICHE UNIQUEMENT LES VALEURS SUPERIEUR AU SEUIL
    if(valUltraSon > distanceMinDevant) {
      afficheAngleDegage("LECTURE DU CAPTEUR", degre, valUltraSon);

      // COMPARAISON DE CHAQUE VALEUR MESURE 'valUltraSon' AVEC 'valUltraSonMax' ET ON RECUPERE LA PLUS GRANDE
      if(valUltraSon > valUltraSonMax) {
        valUltraSonMax = valUltraSon;
        servoCamMax = degre;
      }
    }
  }
  Serial.println(" ");
  Serial.println("*********************************************");
  Serial.print("  ANGLE DE DEGAGEMENT    : ");
  Serial.print(servoCamMax); 
  Serial.println(" DEG");
  Serial.print("  DISTANCE DE DEGAGEMENT : ");
  Serial.print(valUltraSonMax);
  Serial.println(" CM");
  Serial.println("*********************************************");
  Serial.println(" ");
  delay(100);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////
// DOUBLE BALAYAGE DU CAPTEUR AVEC DETECTION D OBSTACLE : SEUIL A 40 CM DEVANT ET 10 CM SUR LES COTES
///////////////////////////////////////////////////////////////////////////////////////////////////////

void doubleBalayage()
{
  int angleMin = 30;
  int angleMax = 135;
  boolean obstacle = false;

  // BOUCLE POUR DECREMENTE DE 140 A 40 DEGRE AVEC UN PAS DE 10
  for (byte degre = angleMax; degre >= angleMin ; degre -= 10) {
    myCam.write(degre);
    valUltraSon = distanceObstacle();

    // TESTE LE SEUIL DU CAPTEUR "distanceMinDevant" 
    if((robotBouge) && (valUltraSon < distanceMinDevant)) {
      obstacle = true; 
      robotStop();
      break;
    }
  }
  if(not obstacle) {
    // BOUCLE POUR INCREMENTER DE 40 A 140 DEGRE AVEC UN PAS DE 10
    for (byte degre = angleMin ; degre <= angleMax; degre += 10) {
      myCam.write(degre);
      valUltraSon = distanceObstacle();

      // TESTE LE SEUIL DU CAPTEUR
      if((robotBouge) && (valUltraSon < distanceMinDevant)) {
        obstacle = true; 
        robotStop();
        break;
      }
    }
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// EFFECTUER UNE MESURE AVEC LE CAPTEUR A ULTRASONS
///////////////////////////////////////////////////////////////////////////////////////////////////////////

int distanceObstacle() 
{
  int duree = 0;
  int distance = 0;
  
  pinMode(dPinSRF05, OUTPUT);              
  digitalWrite(dPinSRF05, LOW);         
  delayMicroseconds(2);
  digitalWrite(dPinSRF05, HIGH);      
  delayMicroseconds(10);
  digitalWrite(dPinSRF05, LOW);       
  pinMode(dPinSRF05, INPUT);
  
  duree = pulseIn(dPinSRF05, HIGH);              
  distance = duree / 58;

  if (distance < distanceMinDevant) { 
    playNote('c', 10);
  }    
  delay(50); // ON DOIT ATTENDRE 50 ms AVANT LE PROCHAIN TRIGGER (VOIR DOC FABRICANT)
  return(distance);                     
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// CALCULE DE L ESPACE DEGAGE
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void robotPivoteVersDegagement()
{
  // LE ROBOT EFFECTUE UN TOUR SUR LUI MEME LORSQUE :
  // vitReferenceG = 40, vitReferenceD = 60, dureeReference = 3150  
  int angleRotation;
  float dureeRotation;
  int vitReferenceG = 40;       
  int vitReferenceD = 60;       
  int dureeReference = 3150; 

  // VERIFIER LES BROCHES MOTEUR G ET MOTEUR D
  // SI L ANGLE EST INFERIEUR A 90 LE ROBOT PIVOTE A GAUCHE
  if (servoCamMax < 90) {
    angleRotation = (89 - servoCamMax); 
    dureeRotation = (angleRotation / 360.0) * dureeReference;
  }
  // SI L ANGLE EST SUPERIEUR A 90 LE ROBOT PIVOTE A DROITE
  else if (servoCamMax > 90) {
    angleRotation = (servoCamMax - 89);
    dureeRotation = (angleRotation / 360.0) * dureeReference;
  }
  if (servoCamMax < 90) {
    robotPivoteG(vitReferenceG, vitReferenceD, dureeRotation);
  }
  else if (servoCamMax > 90) {
    robotPivoteD(vitReferenceG, vitReferenceD, dureeRotation);
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// POSITION CENTRALE DU CAPTEUR
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void positionCentrale()
{
  myCam.write(90);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// LE ROBOT PIVOTE A GAUCHE
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void robotPivoteG(int G, int D, float duree)
{
  vitG = vitGStop - D;
  vitD = vitDStop + G;
  afficheVitesse("TOURNE A GAUCHE", vitG, vitD);
  myMoteurG.write(vitG);
  myMoteurD.write(vitD);
  delay(duree);
  robotStop();
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// LE ROBOT PIVOTE A DROITE
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void robotPivoteD(int G, int D, float duree)
{  
  vitG = vitGStop + G;
  vitD = vitDStop - D;
  afficheVitesse("TOURNE A DROITE", vitG, vitD);
  myMoteurG.write(vitG);
  myMoteurD.write(vitD);
  delay(duree);
  robotStop();  
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// LE ROBOT EST A L ARRET
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void robotStop()
{
  vitG = vitGStop;
  vitD = vitDStop; 
  myMoteurG.write(vitG); 
  myMoteurD.write(vitD); 
  robotBouge = false;  
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// LE ROBOT ACCELERE
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void robotAccelere(int vitG, int vitD)
{
  vitG = vitGStop + vitG;
  vitD = vitDStop + vitD;
  myMoteurG.write(vitG);
  myMoteurD.write(vitD);
  Serial.println("");
  afficheVitesse("MARCHE AVANT : ", vitG, vitD);
  robotBouge = true;  
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// LE ROBOT RECULE
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void robotRecule(int vitG, int vitD)
{
  vitG = vitGStop - vitG;
  vitD = vitDStop - vitD;
  myMoteurG.write(vitG);
  myMoteurD.write(vitD);
  afficheVitesse("MARCHE ARRIERE : ", vitG, vitD);
  robotBouge = true;  
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// AFFICHAGES
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void afficheVitesse(char commentaire[ ], int vitG, int vitD)
{
  Serial.println (commentaire);
  Serial.print ("G => ");
  Serial.println (vitG);
  Serial.print ("D => ");
  Serial.println (vitD);
}

void afficheAngleDegage(char commentaire[ ], int angle, int distance)
{
  //Serial.println (commentaire);
  Serial.print("  ANGLE =>    ");
  Serial.print (angle);
  Serial.print (" DEG");
  Serial.print ("    DISTANCE => ");
  Serial.print (distance);
  Serial.println (" CM");         
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// PARAMETRES DU PIEZO
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void playNote(char note, int duration)
{
  char names[ ] = { 
    'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C'   };  // Do Ré Mi Fa Sol La Si Do
  int tones[ ] = { 
    1915, 1700, 1519, 1432, 1275, 1136, 1014, 956   };  // Demi-période en ms
  // Play the tone corresponding to the note name
  for (int i = 0; i < 8; i++)
  {
    if (names[i] == note) {
      playTone(tones[i], duration);
    }
  }
}

void playTone(int tone, int duration)
{
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(dPinBuzzer, HIGH);
    delayMicroseconds(tone);
    digitalWrite(dPinBuzzer, LOW);
    delayMicroseconds(tone);
  }
}

[code]

Y a une chose que je n'arrive pas a comprendre c'est pourquoi mon capteur de temps a autre ne me renvois pas la bonne distance? Ca fausse tout

Il suffit de tester l'angle de l'obstacle pour savoir de quel côté il est
(angle 0-90, ou 90-180°)
Arrêter la roue du côté opposé à l'obstacle pour tourner et l'éviter, la seconde roue continue normalement.

On peut optimiser le mouvement
* continuer de rouler si c'est un bord de couloir (0-10° et 170-180°) qui ne gène pas encore le robot
* tourner juste un peu si l'obstacle est très latéral (10-45° et 125-170°)
* tourner franchement si c'est devant (45-135°).

Par exemple :
10-45° -> arrêt bref de la roue gauche, pour tourner un peu à droite,
45-80° -> arrêt plus long de la roue gauche, pour tourner nettement à droite,

80-110° -> demi-tour car ça passe pas !

110-135° -> arrêt plus long de la roue droite, pour tourner nettement à gauche,
135-180° -> arrêt bref de la roue droite , pour tourner un peu à gauche.

l'idéal serait de prendre en compte la distance de l'obstacle et l'encombrement du robot pour calculer si ça passe.

Apres quelques tests plus ou moins concluant, le robot arrive a se diriger seul.
Cependant pour qu'il soit encore plus efficace il faudrait comme le dit ChristianR que je prenne en compte l'encombrement du robot.
je cite : "continuer de rouler si c'est un bord de couloir (0-10° et 170-180°) qui ne gène pas encore le robot"

je pensais le rajouter dans la fonction doubleBalayage :

void doubleBalayage()
{
  int angleMin = 40;
  int angleMax = 140;
  int valUltraSon = 0;
  boolean obstacle = false;

    for (byte degre = angleMax; degre >= angleMin ; degre -= 10){
    myCam.write(degre);
    delay(50);
    valUltraSon = distanceObstacle();

    // TESTE LE SEUIL DU CAPTEUR
    if((robotBouge) && (valUltraSon < distanceMinDevant))
    {
      obstacle = true; 
      robotStop();
      break;
    } 
  }
  if(not obstacle)
  {
        for (byte degre = angleMin ; degre <= angleMax; degre += 10)
    {
      myCam.write(degre);
      delay(50);
      valUltraSon = distanceObstacle();

      // TESTE LE SEUIL DU CAPTEUR 
      if((robotBouge) && (valUltraSon < distanceMinDevant))
      {
        obstacle = true; 
        robotStop();
        break;
      }
    }
  } 
}

Mais je ne vois pas trop comment m'y prendre si qq'un a une idee?
Merci

C'est bon j'ai reussi ! />
mais j'ai encore un problème />
je sais pas ou mettre le "speed"
si vous pouvez m'aider />
Merci

salut,
peux tu poster ce que tu as fait?

Hum ... est-ce qu'il ne serait pas plus simple de décrocher la tête du servo, de faire tourner un programme qui met le servo à l'angle que tu veux (par exemple zéro), puis de raccrocher la tête sur le servo ? J'ai fait comme ça sur mon robot, pour que 45° corresponde à "face" et 0 et 90 à des angles sur les côtés.

l'idée est bonne, si j'ai le temps je testerais ca demain.
merci.
buena noche

C'est deja mieux

Quand le capteur regarde devant, il renvoie 90° ?

oui. Pour corriger l'erreur des 90° j ai rajoute ca :

void robotPivoteVersDegagement()
{
  int angleRotation;
  long dureeRotation;
  // Lorsque vitReferenceG = 40, vitReferenceD = 60, dureeReference = 3150,
  // le robot effectue un tour sur lui même 
  int vitReferenceG = 40;       
  int vitReferenceD = 60;       
  int dureeReference = 3150; 

  if (degMax < 90) {
    angleRotation = (90 - degMax);
    dureeRotation = (angleRotation / 360.0) * dureeReference;
    }
else if (degMax > 90) {
    angleRotation = (degMax - 90);
     }
  if (degMax < 90) {    
    robotPivoteD(vitReferenceG, vitReferenceD, dureeRotation);
  }
  else if (degMax > 90) {
    robotPivoteG(vitReferenceG, vitReferenceD, dureeRotation);
  }
}

J ai pas encore essayé, le robot est en charge.

où est défini vitGStop ?

dans les variables globales

// ********  VARIABLES GLOBALES  ********
int valUltraSon = 0;
int valServoCam = 0;
int degMax = 0;
int distanceMinDevant = 40; // SEUIL DU CAPTEUR

int vitGStop = 100;   // MOTEUR GAUCHE A L'ARRET
int vitDStop = 100;   // MOTEUR DROIT A L ARRET
int vitG = vitGStop;  // VITESSE DU MOTEUR GAUCHE
int vitD = vitDStop;  // VITESSE DU MOTEUR DROIT

Peut etre que ca pourra t'aider a mieux comprendre voici ce que j'ai dans la console terminale :


CALCULE DE L ANGLE DE DEGAGEMENT

ANGLE => 15 DEG DISTANCE => 41 CM
ANGLE => 145 DEG DISTANCE => 54 CM
ANGLE => 150 DEG DISTANCE => 54 CM
ANGLE => 155 DEG DISTANCE => 54 CM
ANGLE => 160 DEG DISTANCE => 54 CM
ANGLE => 165 DEG DISTANCE => 54 CM
ANGLE => 170 DEG DISTANCE => 53 CM
ANGLE => 175 DEG DISTANCE => 54 CM
ANGLE => 180 DEG DISTANCE => 59 CM

*********************************************
ANGLE DE DEGAGEMENT : 180 DEG
DISTANCE DE DEGAGEMENT : 59 CM
*********************************************

********** VERIFICATION FONCTION **********
ANGLE MOTEUR 180 DUREE 1575.00

PIVOTE A DROITE
G => 140
D => 40

A savoir le robot est dans la position suivante, il y a un obstacle à droite et devant le robot.

il y a plusieurs erreurs :
- l'angle de rotation : retourne 180, ce qui n'est pas faux, mais ca correspond a la valeur du servo sur lequel est monté le capteur tout en sachant que le capteur se trouve au centre du chassis , voir photos,(j sais pas si c'est clair..).
Ce qui veut dire que j'ai 90° de plus.
- il me dit qu'il pivote à droite alors qu'il devrait indiqué gauche
- il indique droite alors que les moteurs pivotent a gauche

un casse tete! />/>
p

Je crois que je vais m'arracher les cheveux!!

j'ai fait ca mais ca ne fonctionne pas ou aléatoirement, y'a surement une erreur de calcul?

void robotPivoteVersDegagement()
{
  int angleRotation;
 float dureeRotation;
  // Lorsque vitReferenceG = 40, vitReferenceD = 60, dureeReference = 3150,
  // le robot effectue un tour sur lui même 
  int vitReferenceG = 40;       
  int vitReferenceD = 60;       
  int dureeReference = 3150; 

  angleRotation = degMax;
  dureeRotation = (angleRotation / 360.0) * dureeReference;
  Serial.print("");
  Serial.println("********** VERIFICATION FONCTION ********** ");
  Serial.print(" ANGLE MOTEUR ");
  Serial.print(angleRotation);
  Serial.print("  DUREE  ");
  Serial.println(dureeRotation);
  Serial.println("");
  
  if (angleRotation < 90) {    
    robotPivoteD(vitReferenceG, vitReferenceD, dureeRotation);
  }
  else if (angleRotation > 90) {
    robotPivoteG(vitReferenceG, vitReferenceD, dureeRotation);
  }
}

coté moteur ca donne ça :

void robotPivoteG(int G, int D, float duree)
{
  vitG = vitGStop - D; // sens arriere = 40
  vitD = vitDStop + G; // sens avant = 140
  afficheVitesse("PIVOTE A GAUCHE", vitG, vitD);
  myMoteurG.write(vitG);
  myMoteurD.write(vitD);
  delay(duree);
  
  robotStop();
}

void robotPivoteD(int G, int D, float duree)
{  
  vitG = vitGStop + G;
  vitD = vitDStop - D;
  afficheVitesse("PIVOTE A DROITE", vitG, vitD);
  myMoteurG.write(vitG);
  myMoteurD.write(vitD);
  delay(duree);
  robotStop();  
}

Bonjour à tous,

Je profite de ma journée de RTT, pour travailler un peut en plus ma femme n'est pas là!! ROYALE!
bref...
Une question pourquoi cela fonctionne :

dureeRotation = (angleRotation / 360.0) * dureeReference;

et pas ça :

dureeRotation = (angleRotation * dureeReference) / 360.0;