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

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+

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

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

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

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?

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

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