Boucle

Bonjour,

Je dois effectuer un programme qui permet de comptabilisé les longueurs d’un nageur.Et je bloque a la fin de mon programme. Pouvez vous m’aidez a faire la dernière boucle car j’en ai aucunes idées de comment je dois la formuler. Toutes les valeurs sont les valeur trouvé grâce a des programme de test.

Voici mon code :

  int sensorX; // Valeur de l'axe X 
                       
  int sensorZ; // Valeur de l'axe Z 
                       
  int LONG = 0;   // Nombre de longueurs effectuer par le nageur
                       
  int LEXE = 10;   //Nombre de longueurs par exercice
                       
  int led = 13;  // La led est sur la broche 13
                       
  int EX = 0;  // Numéro d'exercice effectuer par le nageur
                       
  int x = 600; // Valeur d'une implusion pour rotation sur l'axe X
  
  int Z = 600; // Valeur d'une implusion pour plongeons/ sortie de l'eau sur l'axe Z
                       
  int ENT = 0;     // Numéro de l'entrainement du nageur
                       
  int Performance [35]; // Tableau de 35 performances                 
                       
  
    
  void setup()   {
                   Serial.begin(9600);
                }
     
     void loop() {
                           
           ENT++; // Ajouter 1 entrainement dans les performance du nageur 
           
           
           // La boucle "do" a pour but de réactualiser la valeur de Z en continue pour savoir si le nageur 
           // effectue un plongeons pour démarrer
       
          do {  Serial.print(sensorZ); // Afficher la valeur de l'axe Z
                sensorZ = analogRead(A0); // Acutaliser la valeur de l'axe Z
                
             } while(sensorZ >=x); // Départ, impulsion sur l'axe Z
  
  
      
     while (1)
     {
           while (LONG <= 10)  //Tant que le nombre de longueurs est inférieur a 10                       
            {
                                 do {                                                         
                                                                                                            
                                 sensorX = analogRead(A2); // Acutaliser la valeur de l'axe X
                                 
                                   Serial.print(sensorX);  // Afficher la valeur de l'axe X
                                 
        
                                 
                                 } while(sensorX >=x); // faire en boucle est-ce qu'il y a un virage ? impulsion sur l'axe X
                                                                                     
                                                  
                               LONG++; // Vu qu'il y a eu un virage comptabilisé une longueur en plus 
                               digitalWrite(led, HIGH);   // allumer la led
                               delay(1000);               // durant 1 seconde
                               digitalWrite(led, LOW);   // eteindre la led 
     }
       
        LONG = 0; // Remise a zéro du nombre de longueurs par exercices 
        
         EX++;
             digitalWrite(led, HIGH);   // allumer la led
             delay(2000);               // durant 2 seconde
             digitalWrite(led, LOW);   // eteindre la led 
             
             
             //"A ce niveau, je dois faire une boucle qui lit X et Z."
             //         "Pour vérifier si le nageur sort de l'eau ou si il recommence à nager"
             
  while (  sensorZ >=300 )                                                  // C'est la que je bloque et jusqu'a Performance [ENT]= EX; 
     
     
  do {  sensorX = analogRead(A2); // Acutaliser la valeur de l'axe X 
            
     if (sensorZ >=x);  // Sortie de l'eau ?  impulsion sur l'axe Z
     {
    
    Performance [ENT]= EX;    // Cette valeur dans la case de l'entrainement 
     }
     
     }
     }

Bonsoir, Que fait :

while (1)

dans loop() ?

Salut ..

Un petit effort sur la présentation du programme? Ca part dans tous les sens ... Il y a un formatage automatique pour avoir de belles indentations bien alignées...

C’est pour que ça fasse en continue ça :

 while (LONG <= 10)  //Tant que le nombre de longueurs est inférieur a 10                       
            {
                                 do {                                                         
                                                                                                            
                                 sensorX = analogRead(A2); // Acutaliser la valeur de l'axe X
                                 
                                   Serial.print(sensorX);  // Afficher la valeur de l'axe X
                                 
        
                                 
                                 } while(sensorX >=x); // faire en boucle est-ce qu'il y a un virage ? impulsion sur l'axe X
                                                                                     
                                                  
                               LONG++; // Vu qu'il y a eu un virage comptabilisé une longueur en plus 
                               digitalWrite(led, HIGH);   // allumer la led
                               delay(1000);               // durant 1 seconde
                               digitalWrite(led, LOW);   // eteindre la led 
     }
       
        LONG = 0; // Remise a zéro du nombre de longueurs par exercices 
        
         EX++;
             digitalWrite(led, HIGH);   // allumer la led
             delay(2000);               // durant 2 seconde
             digitalWrite(led, LOW);   // eteindre la led 
             
             
             //"A ce niveau, je dois faire une boucle qui lit X et Z."
             //         "Pour vérifier si le nageur sort de l'eau ou si il recommence à nager"
             
  while (  sensorZ >=300 )                                                 
     
     
  do {  sensorX = analogRead(A2); // Acutaliser la valeur de l'axe X 
            
     if (sensorZ >=x);  // Sortie de l'eau ?  impulsion sur l'axe Z
     {
    
    Performance [ENT]= EX;    // Cette valeur dans la case de l'entrainement 
     }
     
     }

Une fois qu’il a détecter un départ, car le nombre de longueurs et d’exercice n’est pas prédéfinie cela dépens de l’entrainement du nageur, de ses envies…

C'est ou le formatage aligné bien ? :astonished:

J’ai essayé et quelqu’un pourrais m’indiquer si ce que j’ai fais semble plausible ?

  int sensorX; // Valeur de l'axe X 
                       
  int sensorZ; // Valeur de l'axe Z 
                       
  int LONG = 1;   // Nombre de longueurs effectuer par le nageur
                       
  int LEXE = 10;   //Nombre de longueurs par exercice
                       
  int led = 13;  // La led est sur la broche 13
                       
  int EX = 0;  // Numéro d'exercice effectuer par le nageur
                       
  int x = 600; // Valeur d'une implusion pour rotation sur l'axe X
  
  int xmoyen = 300; // Valeur moyenne de l'axe x 
  
  int Z = 600; // Valeur d'une implusion pour plongeons/ sortie de l'eau sur l'axe Z
                       
  int ENT = 0;     // Numéro de l'entrainement du nageur
                       
  int Performance [35]; // Tableau de 35 performances                 
                       
  
    
  void setup()   {
                   Serial.begin(9600);
                }
     
     void loop() {
                           
           ENT++; // Ajouter 1 entrainement dans les performance du nageur 
           
           
           // La boucle "do" a pour but de réactualiser la valeur de Z en continue pour savoir si le nageur 
           // effectue un plongeons pour démarrer
       
          do {  Serial.print(sensorZ); // Afficher la valeur de l'axe Z
                sensorZ = analogRead(A0); // Acutaliser la valeur de l'axe Z
                
             } while(sensorZ >=x); // Départ, impulsion sur l'axe Z
  
  
      
     while (1)
     {
       
       do {                                                                                                                                     // faire toute la suite tant que 
           while (LONG <= 10)  //Tant que le nombre de longueurs est inférieur a 10                       
            {
                                 do {                                                         
                                                                                                            
                                 sensorX = analogRead(A2); // Acutaliser la valeur de l'axe X                                                            ..
                                 
                                   Serial.print(sensorX);  // Afficher la valeur de l'axe X                                                              ..
                                 
                                 
                                 } while(sensorX >=x); // faire en boucle est-ce qu'il y a un virage ? impulsion sur l'axe X                             ..
                                                                                     
                                                  
                               LONG++; // Vu qu'il y a eu un virage comptabilisé une longueur en plus                                                    ..
                               digitalWrite(led, HIGH);   // allumer la led                                                                              ..
                               delay(1000);               // durant 1 seconde                                                                            ..
                               digitalWrite(led, LOW);   // eteindre la led                                                                              ..
     }
       
        LONG = 0; // Remise a zéro du nombre de longueurs par exercices                                                                                  ..
        
         EX++; // Comptabilisé un  entrainement de plus                                                                                                  ..
             digitalWrite(led, HIGH);   // allumer la led                                                                                                ..
             delay(2000);               // durant 2 seconde
             digitalWrite(led, LOW);   // eteindre la led                                                                                                ..
             
          sensorX = analogRead(A2); // Acutaliser la valeur de l'axe X     
       }
       
while(sensorX >=xmoyen);                                                                                                     //  la valeur du capteur montre que la nageur est en train de nager    
           
           
  
    while (sensorZ >=x);  // Sortie de l'eau ?  impulsion sur l'axe Z
     {
    
    Performance [ENT]= EX;    // Cette valeur dans la case de l'entrainement 
     }
     
  }
  }

Bonsoir,

Waouh ton code est comme qui dirait ..... incompréhensible. Faut comprendre qu'on est pas avec toi pour t'aider à déboguer ton programme alors le minimum serait d'être très explicite dans ton code.

1- Tu n'as pas répondu à la question de @icare. On voit bien que c'est pour faire ce qui suit mais pourquoi "while(1) " ? Rep : void loop est une boucle en elle même. 2- Tu as la touche "Tab" qui te permet de faire des retours propres à la ligne mais là ton code "n'est pas aligné". 3- Il faut noter qu'on lit une valeur avant de pouvoir l'afficher. je veux parler de :

Serial.print(sensorZ); // Afficher la valeur de l'axe Z
 sensorZ = analogRead(A0); // Acutaliser la valeur de l'axe Z

Pour en revenir à ton soucis : Pour faire ta boucle bah tu lis la valeur des senseurs puis tu les stocks dans des variables :

sensorX = analogRead(A2); 
Serial.print(sensorX);
 sensorZ = analogRead(A0);
Serial.print(sensorZ);

Ensuite tu les compare à des valeurs puis tu agis en fonction.

Enfin ... je ne saisi pas le sens de ton code. peut-être que tu pourrais mieux expliquer histoire qu'on soit en phase avec toi. ;)

Pour le format de ton code, dans l’IDE Arduino (Processing a la même fonction) tu vas dans l’onglet outils >> formatage automatique… et hop

Bonjour, Pour @icare, une fois que le départ a été détecter je dois m'occuper de comptabilisé les longueurs et si il détecte un nouveau départ, le relevé sera remise a zéro et donc faussé.

En fait, je dois comptabilisé le nombre de longueurs et d'exercice effectué par nageur durant son entrainement. Pour le faire je dois réalisé un système a l'aide d'un accéléromètre ( ADXL 335 ). Il me reste plus que la partie programmation a réalisé mais la je bloque c'est pourquoi j'ai poster.

J'ai réalisé un algo pour facilité la compréhension de mon programme.

Voici une autre aide : Les trais bleus sont des longueurs effectué par le nageur.

Merci a @Jean-François pour le formatage automatique.

Le "void loop" est une boucle infini ? Je ne comprend pas a quoi sert cette fonction.

Bonjour,

  • void setup est une fonction qui ne s'exécute qu'une seule fois
  • void loop est une fonction qui s'exécute à l'infini

Cashh: Le "void loop" est une boucle infini ? Je ne comprend pas a quoi sert cette fonction.

On veut par exemple allumé une LED quand un bouton est appuyé alors on :

void loop()
{
action = digitalRead(bouton);
if(action == LOW) digitalWrite(2, HIGH);
else
{
digitalWrite(2, LOW);
}

Bah par là tu vois que si void loop n'était pas une boucle en elle même, la lecture et l'action ne se feront qu'une seule fois. Alors que comme c'est une boucle, on lit l'état, on agit en fonction de l'état puis on repars à nouveau pour lire l'état et ainsi de suite jusqu'à l'infini. Ainsi comme l'état de ton bouton est vérifier à chaque fois, tu es sûr que quand tu appuieras à n'importe quel moment, ta led s'allumera à cause de la boucle.

Ah d’accord.

Sinon sur une adruino uno y’a til un bouton ?

Bonsoir,

Bah oui, il y a un bouton de réinitialisation comme sur la plus part des cartes Arduino mais ce bouton n'a rien à voir avec ce que je suis en train de t'expliquer. Vu que tu me demandes ça, dois-je en conclure que tu n'as pas saisi un trait de ce que j'ai dit ?

Si si j'ai compris que c'était un boucle infini, mais ça ne pose pas de soucis si j'en met une autre dedans ? Si j'ai compris l'histoire de la boucle merci.

Le bouton Reset de la carte uno relance tout le programme au début (utilisé en cas de plantage, sinon il ne sert pas si c'est bien codé). On peut emboîter plusieurs structures les unes dans les autres (boucles, tests), c'est le principe même de la programmation.

Oui c'est bien ce que je me disait.