25 réponses à ce sujet

[P2B]

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

[ChristianR]

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

[P2B]

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

[ChristianR]

presque...
L'affichage
Serial.print(" ANGLE : ");
Serial.println(degMax);
Serial.print("ESPACE DE DEGAGEMENT : ");
Serial.print(valUltraSonMax);
doit se faire une seule fois, après être sorti de la boucle for.

[P2B]

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.
+

[P2B]

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

[ChristianR]

Je ne trouve pas comment faire pour renvoyer à mes moteurs l'angle obtenu dans ma fonction "balayage".
Concernant mon chassis : châssis a chenilles avec 2 moteurs DC.

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.

[P2B]

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
+

[Mike118]

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
+

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 )

[P2B]

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

[P2B]

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;

[ChristianR]

Difficile à dire sans voir le code, mais (angleRotation / 360.0) fournit un petit résultat avec décimale entre 0 et 1, tandis que (angleRotation * dureeReference) retourne un grand entier qui peut provoquer un dépassement.

une variable qui est déclarée int ne doit pas dépasser 32767.
http://arduino.cc/en/Reference/Int
Si je prends angle = 360 et durée = 100 ça retourne 36000 et ça dépasse la capacité de la variable.

[P2B]

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

[ChristianR]

où est défini vitGStop ?

[P2B]

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

Fichier(s) joint(s)

•  IMG_0672.JPG   327,27 Ko   34 téléchargement(s)
•  IMG_0673.JPG   320 Ko   27 téléchargement(s)

[ChristianR]

Quand le capteur regarde devant, il renvoie 90° ?

[P2B]

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.

[P2B]

C'est deja mieux

[R1D1]

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.

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.

[P2B]

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