robot autonome, gestion spatial et temporel, erreurs général ou moniteur série

bonjour je suis toujours en terminal si , et je travaille sur un robot autonome à deux chenille se déplaçant celons une trajectoire prédéfini et s’arrêtant devant les obstacles.

j’ai fais le corps du programme c’est à dire le résonnement du système sans les capteurs et les effecteurs.
je pensait avoir finit cette première étape de travaille, pour vérifier cela j’ai repris les variable de position et d’angle dans le moniteur série, pour constater si oui ou non les calcules s’éfectues correctement.
Evidemment vous vous y attendiez les résultats ne sont pas là. :slightly_frowning_face:

le moniteur m’indique pour la variable degresReel “OVF” puis ne répond plus . j’ai fait des recherche et il semblerait que cela se réfère à une variable trop grande. mais cella est’il dut qu’au moniteur ou au programme en luis même?

enfin je vous demande votre aides d’une part pour résoudre ce problème et d’autre pars pour m’assurer de la viabilité de cette base de programe.

voici le programme:

// INITIALISATION DES VARIABLEs          
long unsigned int tempjeu = 0;//temps réel
long unsigned int tempprog = 0;// ?temps soustrayant les poses du aux arrets imprévus sur le parcour, permet le repére dans les etapes de parcours sans bug de saut d'étape
const int sud = 270; // orientation primaire utile à la lisibilitée 
const int nord = 90;
const int est = 0;
const int ouest = 180;
int oriente = 0;
int contact = 1; // varible on off coup d'envois 
int danger = 0;// détection d'un obstacle imprévus arrêt du véicule 
const int margesecu = 20;// distance maximal entre le robot et un obstacle inconu (unitée à vérifier)
const int margemur = 10; // distance maximal entre le robot et un obstacle de l'environnement connue (unitée à vérifier)
long unsigned int ecartp = 0; //tempjeu-tempprog
const long unsigned int finjeu = 100000; // temps de fin de jeux en mili seconde
long unsigned int calcutemp = 0; //variable de comparaison du tempprograme pour déterminé l'étape 
long unsigned int temparduino = 0; //retard du milisse avant début du programe sur 51j 
long unsigned int tempboucle = 0; // temp entre chaque boucle pour calculer la position à chaque boucle remis à O en sortent de la boucle pas danger (sinon cumul sur plusieur boucle et ereur de calcule de trajectoir)
int b = 0; //simple varible de conte 
const int n = 2; //marge de degrés minimal éxigé pour validé l'attainte d'une orientation demandé 


const int vmaxrec = 1;// vitesse max sur sol plat
const int vmaxcirc = 1;//vitesse max circulaire sur sol plat  
int parcour [2][7]{{500,400,600,200,400},             // déterminé la distance en mm 
                   {nord,sud,est,ouest,45}}; //déterminer la direction tableau servant d'interface pour stocker la trajectoire et les action à réaliser 
float x = 0; // position d'origine en x  (nb: verifier le set utilisé)
float y = 0; // position d'origine en y
float degresReel = 0; //direction de la tête du robot dans le repére x y en radiant au démarage à droite à l'est

          
//SETUP
void setup() { 
  Serial.begin(9600);
  Serial.print("millis = ");
  Serial.println(millis());
}
// BOUCLE
void loop() {
  Serial.print ("x= ");
  Serial.println(x);
  Serial.print ("y= ");
  Serial.println(y);
  Serial.print ("degresReel= ");
  Serial.println(degresReel);
  

// detection du coup d'envois 
    //lire on off et assigner 1 à contact si ON ( à ajouté) 
      if ((contact == 1)&&(tempjeu == 0)){//si jeux tout juste lancé initialisé temparduino 
      temparduino = millis();
      tempjeu =millis()-temparduino;
      }
    
// aprés coup d'envois
    if (temparduino != 0){
     tempjeu = millis()-temparduino;
     //prise valeur capteur..... (à ajouté)
     // si x y proche murs alors réduire marge de sécurité sur côté concerné, variable(x,y,margemur; margesecu;non cpateur)
     // si capteurs inférieur à marge alors danger = 1 sinon danger = 0
       
    //si danger ou jeux fini
         if ((danger == 1)||(tempjeu > finjeu)){ // si danger ou jeux fini
          ecartp = ecartp+tempjeu-(millis()-temparduino);// commencer à calculer l'écart temporelle
         //alor tout moteur = low (à ajouté)
         tempboucle = 0; //réinitialise l'écart de temp entre chaque boucle ou il y a mouvement pour ne pas cumulé le temp quand le robot et arété 
         }
         
    // lire étape de trajectoire en fonction du tempprog
        calcutemp = 0;
        tempprog = tempjeu-ecartp;
        for (int i=1; calcutemp <= tempprog; i++){calcutemp = calcutemp + (parcour[1][i])/vmaxrec; //(unité à faire ?)
        b = i;}
        oriente = parcour [2][b]; 


    //si pas de danger   
        if (danger == 0){

             //si direction changer 
             while (degresReel < 0){ degresReel += 360;} //rendre positif degresReel
             while (degresReel >= 360){degresReel -= 360;} // le réduire sous 360 
             
                  if(((oriente + n < degresReel)||(oriente + n - 360 < degresReel))&&((degresReel < oriente - n)||(degresReel < oriente - n + 360))){ //si degresReel ne convient pas à l'orientation demandé avec une marge n 
                       tempboucle = tempboucle - millis();
                        if(((oriente - 180 <= degresReel)||(oriente + 180 <= degresReel))&&(degresReel < oriente)){ // si le chemine le plus cours et ds le sens horaire 
                          // alumer les moteurs dans le sence horaire  (à faire)
                          degresReel = (((degresReel*PI)/180 - vmaxcirc * tempboucle)*180)/PI;//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal 
                          } 
                        if((oriente <= degresReel)&&((degresReel < oriente + 180)||(degresReel < oriente - 180))){ // si le chemin le plus cour et dans le sens trigo 
                          // alumer les moteurs dans le sence trigo (à faire) 
                          degresReel = (((degresReel*PI)/180 + vmaxcirc * tempboucle)*180)/PI;//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal
                          ecartp = tempjeu - tempprog;//calcule ecart tp  
                          }
                       tempboucle = millis(); 
                  }
                  tempprog = tempjeu - ecartp ;
                  if(((oriente + n >= degresReel)||(oriente + n - 360 >= degresReel))&&((degresReel >= oriente - n)||(degresReel >= oriente - n + 360))){
                    //alumer les moteurs pour avencer (à faire) 
                    tempboucle = tempboucle - millis();
                    x = x + cos((degresReel*PI)/180) * tempboucle * vmaxrec;//calculé x y théorique (unité à faire ?), possiblement remplacé par un accélérométre dans la boucle principal 
                    y = y + sin((degresReel*PI)/180) * tempboucle * vmaxrec;
                    tempboucle = millis();
                    }
                  }
        }
     }

merci d’avance pour vos éclaircissement et votre patience ,je sais que se programme commence à devenir long ?

voici le message du moniteur série

millis = 0
x= 0.00
y= 0.00
degrereel= 0.00
millis = 0
x= 0.00
y= 0.00
degrereel= ovf

le programme semble avoirs le Temp de n'affiché qu'une seul fois les position et angle d'origine
théoriquement le programme doit tout d’abord faire tourner le robot pour lui donner la direction adéquat
ce qui explique que l'erreur se retrouve sur les degrées et non la position, mais il me semble logique quel puis s'y étendre se sont les même type de variables.

dernière chose il n'y à aucune erreur au téléversement

Bonsoir,

degresReel = (((degresReel*PI)/180 - vmaxcirc * tempboucle)*180)/PI;

Ne serait-il pas plus logique d’exprimer ‘vmaxcirc’ directement en degrés plutôt qu’en radian et de faire autant de conversions?

La valeur de ‘vmaxrec’ et ‘vmaxcirc’ me semble bien trop surévalué si vous les multipliez à une valeur dérivée de millis() ou alors il est rapide le robot.

actuellement la vmaxcirc est en degrés par milliseconde si on sens tient à la formule.
pour l’instant j’ai utilisé une vitesse hazardeux faute d’avoire de valeur repére , vous aviez raison une valeur plus cohérente serait mieux (beaucoup moin vite) , je gardé les radiant car c’est se qui fait directement le lien entre la vitesse circulaire et rectiligne , cela pourais avoirs des intéré par la suite pour déterminer directement ces deux valeur en fonction de la vitesse des moteur.

je rajoute un 10^-3 deriére les vitesse pour obtenir en constante des m par seconde et des degrée par seconde tout en gardant dans le calcule des millis seconde dons je ne peux me passer .

aprés modif

// INITIALISATION DES VARIABLEs          
long unsigned int tempjeu = 0;//temps réel
long unsigned int tempprog = 0;// ?temps soustrayant les poses du aux arrets imprévus sur le parcour, permet le repére dans les etapes de parcours sans bug de saut d'étape
const int sud = 270; // orientation primaire utile à la lisibilitée en degrée
const int nord = 90;
const int est = 0;
const int ouest = 180;
int oriente = 0;
int contact = 1; // varible on off coup d'envois 
int danger = 0;// détection d'un obstacle imprévus arrêt du véicule 
const int margesecu = 200;// distance maximal entre le robot et un obstacle inconu en mm
const int margemur = 100; // distance maximal entre le robot et un obstacle de l'environnement connue en mm
long unsigned int ecartp = 0; //tempjeu-tempprog
const long unsigned int finjeu = 100000; // temps de fin de jeux en mili seconde
long unsigned int calcutemp = 0; //variable de comparaison du tempprograme pour déterminé l'étape 
long unsigned int temparduino = 0; //retard du milisse avant début du programe sur 51j 
long unsigned int tempboucle = 0; // temp entre chaque boucle pour calculer la position à chaque boucle remis à O en sortent de la boucle pas danger (sinon cumul sur plusieur boucle et ereur de calcule de trajectoir)
int b = 0; //simple varible de conte 
const int n = 2; //marge de degrés minimal éxigé pour validé l'attainte d'une orientation demandé en degré


const int vmaxrec = 1;// vitesse max sur sol plat en m par seconde 
const float vmaxcirc = 0.05;//vitesse max circulaire sur sol plat  en degré par seconde 
int parcour [2][7]{{5000,4000,6000,2000,4000},             // déterminé la distance en mm 
                   {nord,sud,est,ouest,45}}; //déterminer la direction tableau servant d'interface pour stocker la trajectoire et les action à réaliser en dgrée
float x = 0; // position d'origine en x  (nb: verifier le set utilisé)
float y = 0; // position d'origine en y
float degresReel = 0; //direction de la tête du robot dans le repére x y en radiant au démarage à droite à l'est

          
//SETUP
void setup() { 
  Serial.begin(9600);
  Serial.print("millis = ");
  Serial.println(millis());
}
// BOUCLE
void loop() {
  Serial.print ("x= ");
  Serial.println(x);
  Serial.print ("y= ");
  Serial.println(y);
  Serial.print ("degresReel= ");
  Serial.println(degresReel);
  

// detection du coup d'envois 
    //lire on off et assigner 1 à contact si ON ( à ajouté) 
      if ((contact == 1)&&(tempjeu == 0)){//si jeux tout juste lancé initialisé temparduino 
      temparduino = millis();
      tempjeu =millis()-temparduino;
      }
    
// aprés coup d'envois
    if (temparduino != 0){
     tempjeu = millis()-temparduino;
     //prise valeur capteur..... (à ajouté)
     // si x y proche murs alors réduire marge de sécurité sur côté concerné, variable(x,y,margemur; margesecu;non cpateur)
     // si capteurs inférieur à marge alors danger = 1 sinon danger = 0
       
    //si danger ou jeux fini
         if ((danger == 1)||(tempjeu > finjeu)){ // si danger ou jeux fini
          ecartp = ecartp+tempjeu-(millis()-temparduino);// commencer à calculer l'écart temporelle
         //alor tout moteur = low (à ajouté)
         tempboucle = 0; //réinitialise l'écart de temp entre chaque boucle ou il y a mouvement pour ne pas cumulé le temp quand le robot et arété 
         }
         
    // lire étape de trajectoire en fonction du tempprog
        calcutemp = 0;
        tempprog = tempjeu-ecartp;
        for (int i=1; calcutemp <= tempprog; i++){calcutemp = calcutemp + (parcour[1][i])/pow(vmaxrec,-3); //tester les diférente étape 
        b = i;}
        oriente = parcour [2][b]; //choisire l'orientation de l'étape trouvé


    //si pas de danger   
        if (danger == 0){

             //si direction changer 
             while (degresReel < 0){ degresReel += 360;} //rendre positif degresReel
             while (degresReel >= 360){degresReel -= 360;} // le réduire sous 360 
             
                  if(((oriente + n < degresReel)||(oriente + n - 360 < degresReel))&&((degresReel < oriente - n)||(degresReel < oriente - n + 360))){ //si degresReel ne convient pas à l'orientation demandé avec une marge n 
                       tempboucle = tempboucle - millis();
                        if(((oriente - 180 <= degresReel)||(oriente + 180 <= degresReel))&&(degresReel < oriente)){ // si le chemine le plus cours et ds le sens horaire 
                          // alumer les moteurs dans le sence horaire  (à faire)
                          degresReel = (((degresReel*PI)/180 - pow(vmaxcirc,-3) * tempboucle)*180)/PI;//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal 
                          } 
                        if((oriente <= degresReel)&&((degresReel < oriente + 180)||(degresReel < oriente - 180))){ // si le chemin le plus cour et dans le sens trigo 
                          // alumer les moteurs dans le sence trigo (à faire) 
                          degresReel = (((degresReel*PI)/180 + pow(vmaxcirc,-3) * tempboucle)*180)/PI;//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal
                          ecartp = tempjeu - tempprog;//calcule ecart tp  
                          }
                       tempboucle = millis(); 
                  }
                  tempprog = tempjeu - ecartp ;
                  if(((oriente + n >= degresReel)||(oriente + n - 360 >= degresReel))&&((degresReel >= oriente - n)||(degresReel >= oriente - n + 360))){
                    //alumer les moteurs pour avencer (à faire) 
                    tempboucle = tempboucle - millis();
                    x = x + cos((degresReel*PI)/180) * tempboucle * pow(vmaxrec,-3);//calculé x y théorique (unité à faire ?), possiblement remplacé par un accélérométre dans la boucle principal 
                    y = y + sin((degresReel*PI)/180) * tempboucle * pow(vmaxrec,-3);
                    tempboucle = millis();
                    }
                  }
        }
     }

le moniteur série n'indique plus ovf mais les variable de position et d'angle restent à 0 au lieux de progressé avec le programme , les variable de danger et de lancement de jeux sont pourtant bien nul ne bloquant pas son avancement .

Si degreesReel est en radian, certaines lignes et calculs laissent penser le contraire.

if(((oriente - 180 <= degresReel)||(oriente + 180 <= degresReel))&&(degresReel < oriente))
degresReel = (((degresReel*PI)/180 - pow(vmaxcirc,-3) * tempboucle)*180)/PI;
while (degresReel >= 360){degresReel -= 360;} // le réduire sous 360
 const int sud = 270; // orientation primaire utile à la lisibilitée en degrée
const int nord = 90;
const int est = 0;
const int ouest = 180

non je veux dire que degrereel est en degree mais est calculé en radiant d'ou les pi ans les calcule que vous
me montrer

cela m'évite d'utiliser des radiants dans les intervalles , est donne quelque chose de beaucoup plus instinctif notamment quand on donne des orientations plus complexe dans le tableau de parcours au début du programme.

Donc si degreesReel est en degrés et que vmaxcirc est aussi en degrés, votre formule est fausse.

degresReel = (((degresReel*PI)/180 - pow(vmaxcirc,-3) * tempboucle)*180)/PI;

Édit :

je rajoute un 10^-3 deriére les vitesse pour obtenir en constante des m par seconde et des degrée par seconde

La aussi une erreur dans l'utilisation de POW()

la formule de base du Mouvement circulaire rectiligne dont je suis sur est:

position angulaire en radiant = position angulaire d'origine en rad + vitesse angulaire en rad/s*temp en seconde

donc si la vitesse est en degree par seconde le temp en miliseconde et l'angle en degree

(degrerelpi)/180 = (degrerelpi)/180 + (pivmaxcirc)/180pow(tempboucle ,-3)

on simplifie

degrereel = degrereel + Vmaxcirc*pow(tempboucle ,-3)

je pensse que cela est mieux

Oui mais 'pow(tempboucle ,-3)' n'est pas égal à 'tempboucle*pow(10,-3)'.
Méfie toi des float et autre pow(), les résultats ne sont pas toujours ceux que l'on attend :confused: si on les utilise de façon incorrectes.

j’ai rectifier quelque erreur d’unité:

// INITIALISATION DES VARIABLEs          
long unsigned int tempjeu = 0;//temps réel
long unsigned int tempprog = 0;// ?temps soustrayant les poses du aux arrets imprévus sur le parcour, permet le repére dans les etapes de parcours sans bug de saut d'étape
const int sud = 270; // orientation primaire utile à la lisibilitée en degrée
const int nord = 90;
const int est = 0;
const int ouest = 180;
int oriente = 0;
int contact = 1; // varible on off coup d'envois 
int danger = 0;// détection d'un obstacle imprévus arrêt du véicule 
const int margesecu = 200;// distance maximal entre le robot et un obstacle inconu en mm
const int margemur = 100; // distance maximal entre le robot et un obstacle de l'environnement connue en mm
long unsigned int ecartp = 0; //tempjeu-tempprog
const long unsigned int finjeu = 100000; // temps de fin de jeux en mili seconde
long unsigned int calcutemp = 0; //variable de comparaison du tempprograme pour déterminé l'étape 
long unsigned int temparduino = 0; //retard du milisse avant début du programe sur 51j 
long unsigned int tempboucle = 0; // temp entre chaque boucle pour calculer la position à chaque boucle remis à O en sortent de la boucle pas danger (sinon cumul sur plusieur boucle et ereur de calcule de trajectoir)
int b = 0; //simple varible de conte 
const int n = 2; //marge de degrés minimal éxigé pour validé l'attainte d'une orientation demandé en degré


const float vmaxrec = 0.05;// vitesse max sur sol plat en m par seconde 
const int vmaxcirc = 1;//vitesse max circulaire sur sol plat  en degré par seconde 
int parcour [2][7]{{5000,4000,6000,2000,4000},             // déterminé la distance en mm 
                   {nord,sud,est,ouest,45}}; //déterminer la direction tableau servant d'interface pour stocker la trajectoire et les action à réaliser en dgrée
float x = 0; // position d'origine en x  (nb: verifier le set utilisé)
float y = 0; // position d'origine en y
float degresReel = 0; //direction de la tête du robot dans le repére x y en radiant au démarage à droite à l'est

          
//SETUP
void setup() { 
  Serial.begin(1200);
  
}
// BOUCLE
void loop() {
  Serial.print ("x= ");
  Serial.println(x);
  Serial.print ("y= ");
  Serial.println(y);
  Serial.print ("degresReel= ");
  Serial.println(degresReel);
  Serial.print("millis = ");
  Serial.println(millis());

// detection du coup d'envois 
    //lire on off et assigner 1 à contact si ON ( à ajouté) 
      if ((contact == 1)&&(tempjeu == 0)){//si jeux tout juste lancé initialisé temparduino 
      temparduino = millis();
      tempjeu =millis()-temparduino;
      }
    
// aprés coup d'envois
    if (temparduino != 0){
     tempjeu = millis()-temparduino;
     //prise valeur capteur..... (à ajouté)
     // si x y proche murs alors réduire marge de sécurité sur côté concerné, variable(x,y,margemur; margesecu;non cpateur)
     // si capteurs inférieur à marge alors danger = 1 sinon danger = 0
       
    //si danger ou jeux fini
         if ((danger == 1)||(tempjeu > finjeu)){ // si danger ou jeux fini
          ecartp = ecartp+tempjeu-(millis()-temparduino);// commencer à calculer l'écart temporelle
         //alor tout moteur = low (à ajouté)
         tempboucle = 0; //réinitialise l'écart de temp entre chaque boucle ou il y a mouvement pour ne pas cumulé le temp quand le robot et arété 
         }
         
    // lire étape de trajectoire en fonction du tempprog
        calcutemp = 0;
        tempprog = tempjeu-ecartp;
        for (int i=1; calcutemp <= tempprog; i++){calcutemp = calcutemp + (parcour[1][i])/(vmaxrec * pow(10,-3)); //tester les diférente étape 
        b = i;}
        oriente = parcour [2][b]; //choisire l'orientation de l'étape trouvé


    //si pas de danger   
        if (danger == 0){

             //si direction changer 
             while (degresReel < 0){ degresReel += 360;} //rendre positif degresReel
             while (degresReel >= 360){degresReel -= 360;} // le réduire sous 360 
             
                  if(((oriente + n < degresReel)||(oriente + n - 360 < degresReel))&&((degresReel < oriente - n)||(degresReel < oriente - n + 360))){ //si degresReel ne convient pas à l'orientation demandé avec une marge n 
                       tempboucle = tempboucle - millis();
                        if(((oriente - 180 <= degresReel)||(oriente + 180 <= degresReel))&&(degresReel < oriente)){ // si le chemine le plus cours et ds le sens horaire 
                          // alumer les moteurs dans le sence horaire  (à faire)
                          degresReel = degresReel - vmaxcirc * tempboucle * pow(10,-3);//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal 
                          } 
                        if((oriente <= degresReel)&&((degresReel < oriente + 180)||(degresReel < oriente - 180))){ // si le chemin le plus cour et dans le sens trigo 
                          // alumer les moteurs dans le sence trigo (à faire) 
                          degresReel = degresReel + vmaxcirc * tempboucle * pow(10,-3);//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal
                          ecartp = tempjeu - tempprog;//calcule ecart tp  
                          }
                       tempboucle = millis(); 
                  }
                  tempprog = tempjeu - ecartp ;
                  if(((oriente + n >= degresReel)||(oriente + n - 360 >= degresReel))&&((degresReel >= oriente - n)||(degresReel >= oriente - n + 360))){
                    //alumer les moteurs pour avencer (à faire) 
                    tempboucle = tempboucle - millis();
                    x = x + (cos((degresReel*PI)/180) * tempboucle * pow(10,-3) * PI * vmaxrec ) / (180 * pow(1O,-3) ;//calculé x y théorique (unité à faire ?), possiblement remplacé par un accélérométre dans la boucle principal 
                    y = y + (sin((degresReel*PI)/180) * tempboucle * pow(10,-3) * PI * vmaxrec ) / (180 * pow(10,-3);
                    tempboucle = millis();
                    }
                  }
        }
     }

des erreurs de calcules sur les exposants c’est à dire ?

Ce serait sans plus simple d’avoir un jeu d’unités cohérent et unique à travers tout le programme.
Parce que les passages incessant de degrés en radians va utiliser pas mal de ressources et est une bonne source d’erreur.

Et un conseil, utilise un dictionnaire parce lire tes commentaires, ça pique les yeux.

Pow() retourne un double et tout comme les résultats de calcul entre float ne les stocke pas dans un type inapproprié.

Édit: au pire, tu peux utiliser des constantes (comme PI) qui te permettront de faire une conversion plus rapide.
DEG_TO_RAD (=0.017453292519943295769236907684886)
RAD_TO_DEG (=57.295779513082320876798154814105)

désolé pour mon orthographe , je suis dis-orthographique, je promet de faire plus attention.

il y à moyen de passer les angles en radiant, la vitesse en rad/s,la distance en m, néanmoins le temps reste problématique le millis étant en milliseconde le pow est indispensable pour passer en seconde

Tu peux utiliser pow() mais ne colle pas le résultat dans un type int même si tu sais que ça rentre.

Après réflexions il suffirais de tout mettre en milli(seconde,radiant,mètre...) .

Les quatre variables sont stocké dans du float cela ne suffit il pas au calcule ?

Sinon j'ai regardé , et la variable PI d'arduino n'a que 6 chiffres significatif dois'je définir ma propre constante plus précise?

nouveau problème :o , la compilation ne fonctionne plus et m'indique un espace disque insuffisant, es lié à mon arduino uno ou à mon pc

Sinon j'ai regardé , et la variable PI d'arduino n'a que 6 chiffres significatif

Pas si on en crois le fichier arduino.h

#define PI 3.1415926535897932384626433832795

Les quatre variables sont stocké dans du float cela ne suffit il pas au calcule ?

C'est pas tant un problème de quantité mais de qualité. Regarde ici.
Il est préférable de faire par exemple des comparaison entre type float en utilisant la valeur 180.0 plutôt que 180.

donc je ne définit pas que mes variable en float mais aussi toute mes constantes qui s'y appliquent .

et dois'je écrire 180.0000 partout ou il y à des entiers ?

enfin malgrés qu'il puisse y avoir des résultat tel qu'on obtiend 0.99999 au lieux de 1 , l’arrondit ne peut t'il pas paraître acceptable . Si le robot effectue un écart d'un mm sur les 100 seconde de jeux qu'il dois effectuer, sa resterais négligeable