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

Salut

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

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

Bonjour,
je reviens apres une longue absence (perdu mes identifiants), anciennement pas2bol.

Pour resumer : mon projet (de longue date />/>/>/>/>/>/>/>) un robot avec une base arduino + shield xbee pour la communication serie, + tourelle avec capteur ultrason.

Aujourd'hui,au niveau de mon prog j'ai terminé le mode manuel et commencé le mode auto.
Sur le mode auto je rencontre plusieurs difficultées. j'aimerai au démarrage du prog faire un scan de 180° avec ma tourelle, de récupérer la valeur la plus haute du capteur à ultrason et de faire pivoter mon robot dans cette direction, un peut sur ce model la :
()


J'ai cree cette fonction :

void balayage()
{
  int angleMin = 0;
  int angleMax = 180;  

  for (byte degre = angleMin ; degre <= angleMax; degre += 10){ //j'incremente de 10° et je lis la valeurs du capteur
    myCam.write(degre); // servo qui supporte la caméra et le capteur
    valUltraSon = distanceObstacle(); // fonction qui lit le capteur
        if(valUltraSon > distanceMinDevant) {
      afficheAngleDegage(degre, valUltraSon); // fonction pour l'affichage

    }
  }
}

Dans la fenetre terminal ca donne ca:
Demarrage du programme...
ANGLE => 0 DEG DISTANCE => 64 CM
ANGLE => 20 DEG DISTANCE => 43 CM
ANGLE => 30 DEG DISTANCE => 55 CM
ANGLE => 40 DEG DISTANCE => 44 CM
ANGLE => 50 DEG DISTANCE => 42 CM
ANGLE => 60 DEG DISTANCE => 43 CM
ANGLE => 80 DEG DISTANCE => 41 CM
ANGLE => 90 DEG DISTANCE => 65 CM
ANGLE => 100 DEG DISTANCE => 64 CM
ANGLE => 110 DEG DISTANCE => 65 CM
ANGLE => 120 DEG DISTANCE => 66 CM
ANGLE => 130 DEG DISTANCE => 146 CM
ANGLE => 140 DEG DISTANCE => 141 CM
ANGLE LE PLUS DEGAGE =

Tout ce qui est inferieur a 40cm n'est pas pris en compte car j ai reglé le seuil du capteur a 40cm

Comment recuperer la valeur la plus haute du capteur(ici 146cm), qui indiquerait l'espace le plus degagé?
Mon idée est de creer un tableau de 18 éléments pour stocker les valeurs du capteur et d'en récuperer la plus grande.

Je ne sais pas si tout est clair, alors n'hésitez pas />/>/>/>/>/>
Merci

C'est deja mieux

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

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

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

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;

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

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

En fait puisque tu as ton robot qui fonctionne tu as deux façon pour résoudre ton problème.

La première : tu expérimentes et tu notes tes valeurs, comme ce que tu as fais pour obtenir le délais de 3150.
et à partir de là si tu veux faire une rotation de X degrès tu fais X*3150/360 avec te moteurs à fond à chaques fois.
Et si tu veux le faire avec tes moteurs qui vont à une autre vitesse il faut que tu refasse l'expérience qui te donne le delay pour que ton robot fasse un tour complet.

La deuxième : Tu fais une étude théorique en prennant quelques valeurs tiré de l'expérimentale... Il faut par exemple que tu mesures la vitesse de ton robot en ligne droite lorsque tes moteurs sont alimentés à fond, (la linéarité de la vitesse en fonction de ta consigne si tu veux être sûr d'être précis,) que tu mesures le rayon de tes roues, l'entraxe entre tes roues. A partir de là, en faisant une étude cinématique tu peux déterminer la position et l'orientation de ton robot en fonction de la vitesse de rotation de tes roues et du temps qui passe( Si il n'y a pas de glissement biensur )

La deuxieme solutions est bien trop compliquée pour mon niveau. Avec toutes ces infos j'devrais pouvoir faire qq chose.
Merci a vous messieurs

J'étais justement dessus, ça donne ca :

 void simpleBalayage()
{
  Serial.println("");
  Serial.println("     CALCULE DE L ANGLE DE DEGAGEMENT");
  Serial.println("");
  int angleMin = 0;
  int angleMax = 180; 
  int valUltraSon = 0;
  int valUltraSonMax = 0;
  int degMax = 0;

  for (byte degre = angleMin ; degre <= angleMax; degre += 10){
    myCam.write(degre);
    
    valUltraSon = distanceObstacle();
    
    if(valUltraSon > distanceMinDevant) {
      afficheAngleDegage(degre, valUltraSon);

      if(valUltraSon > valUltraSonMax) {
        valUltraSonMax = valUltraSon;
        degMax = degre;
      }
    }
  }
  Serial.println(" ");
  Serial.println("*********************************************");
  Serial.print("     ANGLE DE DEGAGEMENT : ");
  Serial.print(degMax); 
  Serial.println(" DEG");
  Serial.println("*********************************************");
  Serial.println(" ");
}

ça tourne nickel! />/>/>
j'ai hâte de mettre ca en pratique. Reste la partie moteur à faire, j'espere que cela ne va pas être trop compliqué mais j'ai déja ma peite idée..
Merci pour ton aide Christian.
+

Le tableau n'est pas nécessaire.

Avant la boucle , tu inititalise une variable int angleSup = 0;
Dans la boucle, tu compares chaque valeur mesurée valUltraSon avec cet angleSup et tu mémorise le plus grand
if(valUltraSon > angleSup ) { angleSup = valUltraSon;}
En fin de boucle tu as le maximum absolu

Merci Christian pour ta réponse.
Alors ca fonctionne bien, mais il faudrait également que je récupere l'angle associé à la valeur du capteur, de sorte que le robot pivote dans cette direction.
J'ai fait ca, est ce correcte?

void simpleBalayage()
{
  Serial.println("SIMPLE BALAYAGE");
  int angleMin = 0;
  int angleMax = 180; 
  int valUltraSon = 0;
  int valUltraSonMax = 0;
  int degMax = 0;


  for (byte degre = angleMin ; degre <= angleMax; degre += 10){
    myCam.write(degre);
    valUltraSon = distanceObstacle();
    if(valUltraSon > distanceMinDevant) {
      afficheAngleDegage(degre, valUltraSon);

      if(valUltraSon > valUltraSonMax) {
        valUltraSonMax = valUltraSon;
        degMax = degre;
        
        Serial.print("  ANGLE : ");
        Serial.println(degMax);
        Serial.print("ESPACE DE DEGAGEMENT : ");
        Serial.print(valUltraSonMax);
       
      }
    }
  }
}

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.

C'est tres intéressant. Mais avant tout il me faut recuperer la valeur de la variable "degMax" dans la fonction balayage qui correspond a un angle de 0 a 180 degres, et renvoyer cette valeur au moteur donc dans ma logique :
- si pour 360° il me faut un delais de 3150,
- pour 1° il me faut un delais de 8.75 (3150/360)
ce qui donne par ex pour un angle de 120° un delais de 1050 ( 120 * 8.75)
Apres il faudrait que je cree une fonction du genre " void espaceDegage (int vitG, int vitD, int delais)"
Moi je bloque ici.
Apres effectivement, inclure le test de l'angle.
j'sais pas si tu me suis Christian.... en tout cas encore merci
+

J'étais justement dessus, ça donne ca :

 void simpleBalayage()
{
  Serial.println("");
  Serial.println("     CALCULE DE L ANGLE DE DEGAGEMENT");
  Serial.println("");
  int angleMin = 0;
  int angleMax = 180; 
  int valUltraSon = 0;
  int valUltraSonMax = 0;
  int degMax = 0;

  for (byte degre = angleMin ; degre <= angleMax; degre += 10){
    myCam.write(degre);
    
    valUltraSon = distanceObstacle();
    
    if(valUltraSon > distanceMinDevant) {
      afficheAngleDegage(degre, valUltraSon);

      if(valUltraSon > valUltraSonMax) {
        valUltraSonMax = valUltraSon;
        degMax = degre;
      }
    }
  }
  Serial.println(" ");
  Serial.println("*********************************************");
  Serial.print("     ANGLE DE DEGAGEMENT : ");
  Serial.print(degMax); 
  Serial.println(" DEG");
  Serial.println("*********************************************");
  Serial.println(" ");
}

ça tourne nickel! />/>
j'ai hâte de mettre ca en pratique. Reste la partie moteur à faire, j'espere que cela ne va pas être trop compliqué mais j'ai déja ma petite idée..
Merci pour ton aide Christian.
+

Bonjour,

Je reviens vers vous au sujet de mes moteurs. Je ne trouve pas comment faire pour renvoyer à mes moteurs l'angle obtenu dans ma fonction "balayage".
Concernant mon chassis : chassis a chenilles avec 2 moteurs DC.

Apres quelques tests je sais que pour faire un tour complet, moteurs a fond, il me faut un delais de 3150, je pense qu il faut que je creuse dans cette direction... en tout cas, c'était mon idée />/>

Je gère mes moteurs de cette facon la :

// qq traitements....

// Vitesse minimum et maximum du moteurs gauche
const int moteurGMin = 0;
const int moteurGMax = 140;

// Vitesse minimum et maximum du moteurs droit
const int moteurDMin = 0;
const int moteurDMax = 140;

//variables de vitesse : moteurs à l'arrêt
int vitG0 = 65;
int vitD0 = 65;
int vitG = vitG0;
int vitD = vitD0;

Servo myMoteurG;
Servo myMoteurD;

void setup()
{
// qq traitements..
}

void loop()
{
}

void robotStop()
{
  vitG = vitG0; vitD = vitD0;
  myMoteurG.write(vitG0);
  myMoteurD.write(vitD0);
  Serial.println(" "); 
  Serial.print("MOTEURS STOP    ");
}

void pivotDroit()
{
  Serial.println(" "); 
  Serial.print("J PRENDS A DROITE    ");
   if(vitG > 145 && vitD < -5) {
    vitG = 145; vitD = -5;
  }
  else 
  {
  vitG = vitG + 20; 
  vitD = vitD - 20;
  myMoteurG.write(vitG);
  myMoteurD.write(vitD);  
  }
}

void pivotGauche()
{
  Serial.println(" "); 
  Serial.print("J PRENDS A GAUCHE    "); 
  if(vitG < -5 && vitD > 145) {
    vitG = -5; vitD = 145;
  }
  else
  {
  vitG = vitG - 20;
  vitD = vitD + 20; 
  myMoteurG.write(vitG);   
  myMoteurD.write(vitD);  
  }
}

void avance()
{
  Serial.println(" "); 
  Serial.print("J AVANCE    ");
  if(vitG > 145 && vitD > 145) {
    vitG = 145; vitD = 145;
  }
  else
  {
    vitG = vitG + 10;
    vitD = vitD + 10;  
    myMoteurG.write(vitG);
    myMoteurD.write(vitD);
  }  
}

void recule()
{
  Serial.println(" "); 
  Serial.print("J RECULE    ");
  if(vitG < -5 && vitD < -5) {
    vitG = -5; vitD = -5;
  }
  else
  {
    vitG = vitG - 10; 
    vitD = vitD - 10;
    myMoteurG.write(vitG);
    myMoteurD.write(vitD);
  }
}

voila... je pense que ca demande à être améliorer j'ose pas dire "optimiser" (ref post obtimiser)
Si qq un à une idée... il doit bien exister une "petite formule magique pour ca".
merci à vous et je vous souhaites un bon dimanche
cordialement P2B

Bonjour a vous,
Déjà merci de vos réponses.

Alors ChristianR, mes servos doivent normalement tourner comme un moteur (j'ai fait attention quand je les ai commandés)
Apres, mike118, comment je peux faire pour brancher le rouge ou le noir a seul endroits différents? Il faudrait que je soude un fil quelque part sur le noir (ou le rouge) facon a faire comme un T ?

Merci encore a vous pour vos reponse,
Cordialement,
Lucas

edit: Ou est la masse sur mon Arduino Uno ? Quel est le symbole qui pourrait être marqué sur ma carte ?

Salut,
pour ton servo assure toi qu'il soit bien modifié comme ici :



en ce qui concerne la masse sur l'Arduino c'est GND, par ex entre AREF et la broche 13.
+

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?

je réexplique :

-j'ai un robot picaxe 18M2 il est avec des capteur ultra-son,il peut se déplacer,detecter les ligne noires et des plots.
-j'ai un support carré de 1m30 de cotés et des plots
je veut que ce robot dégage les plot du carré.

je demande cela car j'ai déja essayer mille et un programme mais je ne trouve pas le bon
S.V.P Aidez moi .


Oui j'ai déja cherché sur google

C'est mieux.. on en sait un peut plus donc il te manque uniquement le programme?
Malheureusement moi je ne vais pas pouvoir t'aider, mais je pense que si tu cherches qq chose de deja "tout pret" ca risque d'etre difficile.
Le mieux c'est de creer ton propre code.
+

Salut,
Je pense que tu devrais developper un peut plus, c'est tres vague...
As tu cherché dans google?

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 -

Bienvenu à toi sur le forum />



Je remarque aussi que les femmes ne sont pas très intéressé par la robotique et le Do It Yourself ^^
( Bon ça serait avec plaisir qu'il y en ait une qui passe par là et me dise que je me trompe x) mais il n'y a qu'à voir le rapport homme femme sur la quantité de membres inscrits pour voir qu'il n'y a pas la parité x) )

En tout cas à bientôt sur le forum />

tout a fait d'accord!!
a+

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 à vous,

Je suis tombé dans la robotique y'a de ca 2 ans apres avoir acheté un robot tout fait,tout prêt, et tout beau mais pas terrible ! Le Rovio de chez WOWWEE.
Je dois dire que j'ai été assez deçu alors je me suis dit pourquoi pas en creer un.
Mon projet avance tout doucement, car j'ai du tout apprendre, l'électronique, le language de programmation... seul avec mon ami GOOGLE />/>
Mais c'est tellement intéressant (sauf pour ma femme).
A part ca j'ai 33 ans et une formation de comptabilité, voilà.

Longue vie à ce forum.

A bientôt.

P2B, pour info qui veut dire pas2bol