Problème compréhension programme.

Bonsoir ! Je m’intéressais à un programme, et malheureusement je ne comprends pas trop ce qu’il fait. Si quelqu’un peut me détailler ce qu’il fait, ça serait super sympa.
Merci d’avance

#include <Wire.h>

// tableau valeurs pour l'accelerometre
int X;
int Y;
int Z;
// tableau de valeur pour le gyroscope
int U;       //x du gyroscope
int V;      //y du gyroscope
int W;      //z du gyroscope
long temps;
char bu[6];
//String essai;
String cmd = String("");
String souschaine;
int longueur;
char text;
int N;
int S;
const int xpin = A0;                  // x-axis de l' accelerometre
const int ypin = A1;                  // y-axis  de l'accelerometre
const int zpin = A2;                  // z-axis de l'acceloremetre
const int xgpin =A3;                  // X-axis gu gyroscope
const int ygpin =A4;                  // Y-axis gu gyroscope
const int zgpin =A5;                  // Z-axis gu gyroscope
char inByte;
int in2Byte=0;
int Xval;
int Yval;
int Zval;
int Xgval;
int Ygval;
int Zgval;
int i;


int sampleDelay = 50;   //number of milliseconds between readings

void setup()
{
  // initialize the serial communications:
  Serial.begin(57600);

  //Make sure the analog-to-digital converter takes its reference voltage from
  // the AREF pin
  analogReference(EXTERNAL);

  pinMode(xpin, INPUT);
  pinMode(ypin, INPUT);
  pinMode(zpin, INPUT);
  pinMode(xgpin, INPUT);
  pinMode(ygpin, INPUT);
  pinMode(zgpin, INPUT);
  N=5; //Nombre de points de mesures
  i=0;
  S=30;
  
}
void loop()
{
  if (Serial.available() > 0)         { 
    // get incoming byte:[/color]
   inByte = Serial.read();
   if(inByte==10){ 
          ProcessCmd();
                 }else
                    {
          // sinon, ajouter le caractère à la mémoire tampon (cmd)
                       cmd += String(inByte);
          
         
                     }
                 
                
  
  // Renvoyer la commande (contenu du buffer) sur le port série

   
           
                                   }
}
void ProcessCmd() {
   
    text=cmd.charAt(0);
    longueur=cmd.length();
    souschaine=cmd.substring(1,longueur);
    if(text==('A')){
                                  //for (i=0;i<N;i++)  {
 
/*Serial.print("X\t");
Serial.print(analogRead(xpin));
Serial.print("\t");
Serial.print("Y\t");
Serial.print( analogRead(ypin));
Serial.print("\t");
Serial.print("Z\t"); 
Serial.print( analogRead(zpin));
Serial.print("\t");
Serial.print ("\n");
*/
// lecture des valeurs acceleration et rotation
X=analogRead(xpin);
Y=analogRead(ypin);
Z=analogRead (zpin);
U=analogRead(xgpin);
V=analogRead(ygpin);
W=analogRead (zgpin);
temps=millis(); ;


//tempo entre 2 point 

//delay(S);//                                        }
i=0;
                                           //for (i=0;i<N;i++){
                         
    
Serial.print("X");
Serial.print(X);
//Serial.print("\t");
Serial.print("Y");
Serial.print(Y);
//Serial.print("\t");
Serial.print("Z"); 
Serial.print(Z);
//Serial.print("\t");

Serial.print("U");
Serial.print(U);
//Serial.print("\t");
Serial.print("V");
Serial.print(V);
//Serial.print("\t");
Serial.print("W"); 
Serial.print(W);
//Serial.print("\t");

   Serial.print("F");   
   Serial.print(temps);
   Serial.print("T");
Serial.print ("\n");

         //                                                              }
  
                   
                      }
      
    else if(text==('B')){
     if (longueur>1){
            N=(souschaine.toInt());
            delay(5);
            
                     }  
                        }
              else if(text==('S')){
     if (longueur>1){
            S=(souschaine.toInt());
            delay(5);
                     }  
                        }          
    else{
         // toutes les autres commandes sont ignorées.
         Serial.println("unknown command!");
         Serial.println(cmd);
         //clearCmd();
    }
cmd="";
}
#include <Wire.h>

// tableau valeurs pour l'accelerometre
int X;
int Y;
int Z;
// tableau de valeur pour le gyroscope
int U;       //x du gyroscope
int V;       //y du gyroscope
int W;       //z du gyroscope
long temps;
char bu[6];
//String essai;
String cmd = String("");
String souschaine;
int longueur;
char text;
int N;
int S;
const int xpin = A0;                  // x-axis de l' accelerometre
const int ypin = A1;                  // y-axis  de l'accelerometre
const int zpin = A2;                  // z-axis de l'acceloremetre
const int xgpin =A3;                  // X-axis gu gyroscope
const int ygpin =A4;                  // Y-axis gu gyroscope
const int zgpin =A5;                  // Z-axis gu gyroscope
char inByte;
int in2Byte=0;
int Xval;
int Yval;
int Zval;
int Xgval;
int Ygval;
int Zgval;
int i;


int sampleDelay = 50;   //number of milliseconds between readings

void setup()
{
  // initialize the serial communications:
  Serial.begin(57600);  // Remarque que j'ai changé pour avoir une liaison correcte

  //Make sure the analog-to-digital converter takes its reference voltage from
  // the AREF pin
  analogReference(EXTERNAL);

  pinMode(xpin, INPUT);
  pinMode(ypin, INPUT);
  pinMode(zpin, INPUT);
  pinMode(xgpin, INPUT);
  pinMode(ygpin, INPUT);
  pinMode(zgpin, INPUT);
  N=5; //Nombre de points de mesures
  i=0;
  S=30;
  
}
void loop()
{
  if (Serial.available() > 0) {     // Lire les données entrants dans le Serial
    inByte = Serial.read();         // Assigner les valeurs entrants à intByte
   
    if (inByte == 10) {             // Si la représentation ASCII est '10' [...]
        ProcessCmd();               // Exécuter ProcessCmd
    }
    else {
      cmd += String(inByte);        // Sinon, ajouter le caractère reçu à la suite du mémoire tampon (cmd)
    }               
  Serial.println("Mémoire tampon : ");
  Serial.print(cmd);                // Renvoyer la commande (contenu du buffer) sur le port série
  }
}
void ProcessCmd() {
  
    text = cmd.charAt(0);          // Assigner 'text' comme étant 'cmd' à partir du première carachtère
    longueur = cmd.length();       // Assigner 'longeur' comme étant la longeur de 'cmd'
    souschaine = cmd.substring(1,longueur); // Assigner 'souschaine' comme étant le souschaine (partie d'une chaine) de 'cmd' en partant du carachtère [1] et pour la longeur de 'longeur'
    
    if(text==('A')){               // Si text est égal à 'A' [...]
    
      X = analogRead(xpin);        // Assigner les variable suivants (X, Y, Z, ...)  à la fonction analogRead de chaque variable (xpin, ypin, ...)              
      Y = analogRead(ypin);
      Z = analogRead (zpin);
      U = analogRead(xgpin);
      V = analogRead(ygpin);
      W = analogRead (zgpin);
      temps=millis();                //tempo entre 2 point               
    
      i = 0;                         // Initialiser 'i' à 0 
                         
 // for (i=0, i<N, i++) {
      Serial.print("X");
      Serial.print(X);
      //Serial.print("\t");
      Serial.print("Y");
      Serial.print(Y);
      //Serial.print("\t");
      Serial.print("Z"); 
      Serial.print(Z);
      //Serial.print("\t");
      
      Serial.print("U");
      Serial.print(U);
      //Serial.print("\t");
      Serial.print("V");
      Serial.print(V);
      //Serial.print("\t");
      Serial.print("W"); 
      Serial.print(W);
      //Serial.print("\t");

      Serial.print("F");   
      Serial.print(temps);
      Serial.print("T");
      Serial.print ("\n");
 // }
  }
      
    else if(text == ('B')) {       // Si 'test' est égal à 'B'
      if (longueur > 1) {          // Si la longeur de la chaine est plus grande que 1
        N=(souschaine.toInt());    // N est égal à la conversion de 'souschaine' en type int
        delay(5);                  // Délai de 5
      }  
    }
    else if (text == ('S')){       // Si 'test' est égal à 'S' 
      if (longueur>1) {            // Si la longeur de la chaine est plus grand que 1
        S = (souschaine.toInt());  // 'S' est alors égal la la conversion de souschaine en type int
        delay(5);                  // Délai de 5
      }  
    }          
    else{                          // Sinon toutes autres chaines de carachtères sont ignorées.accompagnées d'un 'message d'erreur'
         Serial.println("unknown command!");
         Serial.println(cmd);
         //clearCmd();
    }
  cmd="";                          // 'cmd' est réinitialisé          
}

Je ne sais pas si ça peut beaucoup t’aider, pas certain que ce soit ce que tu recherche, niveau fonctionnement, il compile mais je ne sais pas s’il est fonctionnel, pas tester. Hmmm, je suis moi-même un peu noob, mais il me semble que c’est plus ou moins correct…

En gros, d’après ce que j’ai compris il est programmé pour être à l’écoute des entrées Serial. Lors de la réception de 10 (ASCII ou la touche Enter) celui-ci exécute la fontion ProcessCmd(). ProcessCmd quant à lui définit ‘text’ qui contient pour la plupart l’équivalent d’un switch case (qui serait peut-être, voir probablement plus adapté) pour les cas prédéfinis (à la réception de A il renvoie la valeur de chaque analogRead, pour la réception de B ou de S rien n’est prédéfini à moins que si (en plus) la longeur de ceux-ci soient plus grands que 1, une fois les conditions remplies la commande ‘extrait’ le souschaine pour le convertir afin de réinitiliser les variables N ou S. En fin de l’exécution de ProcessCmd() le string cmd est réinitialisé. Dans le cas ou les conditions principales sont satisfaits et que ProcessCmd() s’exécute sans encontre de failles, un Serial.println("Mémoire tampon : "); et Serial.print(cmd); renvoient l’état actuel. Sinon cmd est incrémenter de la conversion d’inByte en String.

J’espère que cela vous sera utile, si vous voulez bien m’en tenir informé ce serait aimable. Bon fin de journée à vous.

-TinyTox

void ProcessCmd() {
  
    text = cmd.charAt(0);          // Assigner 'text' comme étant 'cmd' à partir du première carachtère
    longueur = cmd.length();       // Assigner 'longeur' comme étant la longeur de 'cmd'
    souschaine = cmd.substring(1,longueur); // Assigner 'souschaine' comme étant le souschaine (partie d'une chaine) de 'cmd' en partant du carachtère [1] et pour la longeur de 'longeur'
    
    switch (text) {
      case 'A' :
        X = analogRead(xpin);        // Assigner les variable suivants (X, Y, Z, ...)  à la fonction analogRead de chaque variable (xpin, ypin, ...)              
        Y = analogRead(ypin);
        Z = analogRead (zpin);
        U = analogRead(xgpin);
        V = analogRead(ygpin);
        W = analogRead (zgpin);
        temps=millis();                //tempo entre 2 point       
      
        i = 0;                         // Initialiser 'i' à 0 
                           
   // for (i=0, i<N, i++) {            // Etant que ceci est etait en commentaire au départ, enfin je crois,
                                       // et que je vais le laisser ainsi, je suppose que c'est pour éventuellement
                                       // repérer des miniscules changements au niveau des entrées analogiques 
                                       // sur une période de temps réduite. Sur base du temps=millis() qui
                                       // renvoi le temps écoulé depuis le lancement du programme et le fait que N, 
                                       // qui se situe dans un scope global peut etre modifié suite à un changement
                                       // au niveau des cas du switch qui détermine le nombre de fois que la valeur 
                                       // des entrées seront lus . Le cas S peut-etre afin de détaillé prise de calcul, 
                                       // ou quelques-unes d'entre-elles 
        Serial.print("X");
        Serial.print(X);
        //Serial.print("\t");
        Serial.print("Y");
        Serial.print(Y);
        //Serial.print("\t");
        Serial.print("Z"); 
        Serial.print(Z);
        //Serial.print("\t");
        
        Serial.print("U");
        Serial.print(U);
        //Serial.print("\t");
        Serial.print("V");
        Serial.print(V);
        //Serial.print("\t");
        Serial.print("W"); 
        Serial.print(W);
        //Serial.print("\t");
  
        Serial.print("F");   
        Serial.print(temps);
        Serial.print("T");
        Serial.print ("\n");
   // }
        break;
    case 'B' :
      if (longueur > 1) {
        N = (souschaine.toInt());    // N est égal à la conversion du 'souschaine' en type int
        delay(5);                  // Délai de 5
      }  
      break;
    case 'S' : 
      if (longueur > 1) {
        S = (souschaine.toInt());
        delay(5);
      }
      break;
    default :
      Serial.println("Unknown Command");
      Serial.print(cmd);
      break;
    }
  cmd="";                          // 'cmd' est réinitialisé          
}

Cela devrait tout aussi bien fonctionner, niveau temps d’exécution du programme pour la plupart au final ce sera par rapport à la compilation sinon égal à la version précédente.

Sinon :

if (test == 'A' && longeur > 1) {
     // Me parait plus correcte voir même plus performant
}
/* Et ainsi de suite pour le dernier cas */

Bonsoir,

Tu peut déjà supprimé la librairie Wire.h car a moins d’être aveugle j'ai pas vue d'i2c dans le code :slight_smile:

Même beaucoup de trucs à supprimer déclaré sans pour autant être employé, ait pas voulu faire toute une réfactoration. Toutefaois, je suis en accord a-Standby.

Me semble que char bu[6] serait une allocation de mémoire un peu inutile aussi..

Problème résolu?