[Question] Possibilité de gerer un tableau en fonction d'un autre tableau ?

Bonjour,

Je cherche à savoir si il est possible de gérer la taille d'un ou plusieurs tableau en 2 dimensions (ex : tableau1[x][y]) en fonction d'un premier tableau d'1 dimension.

Je m'explique :

Dans mon projet, je fais une acquisition de 12 pin analogique, et je traite les datas. Pour le moment, j'ai un tableau sous forme : const int entree_anal[]{A0, A1, A2... A11}; j'ai donc du pin 0 a 11. Or si un jour je ne veux que le 4, 7 et 9 ou 3, 5, 6, 7, j'aurais ce tableau a changer mais tous les autres tableau qui font des calculs derrière (un tableau pour stocker la valeur après le CAN de chaque pin, un pour stocker la valeur de la moyenne car je fais 10 mesures et une moyenne a la fin, etc)

J'aimerais donc savoir si c'est possible, en faisant je ne sais comment, un seul tableau avec mes entrées, et que tous les autres tableau voient leurs nombre de case changer en fonction du nombre d'entrée que je veux acquérir.

De plus, je n'ai que des tableau à une dimension, mais pour faire les moyennes c'est pas pratique..

J'aimerais savoir comment faire pour gérer des tableaux à 2 dimension.. en gros les colonnes seraient pour les pin (1 par pin) et les lignes pour les mesures effectuer, pour ensuite faire les moyennes sur 10 mesures par exemple (ce qui ferais des tableaux de 12*10), c'est possible ?

Merci à vous ! cordialement.

Bonjour,

sizeof est ton ami. le nombre d'éléments de ton tableau entree_anal est

const int nbEntrees=sizeof entree_anal/sizeof entree_anal[0];

tu peux ensuite utiliser nbEntrees pour dimensionner tes autres tableaux.

euh .. je n'ai absolument pas compris mais je vais me documenter sur cette fonction, merci !

Qu'est ce que tu n'as pas compris?

sizeof donne la taille d'un objet. Le nombre d'éléments dans ton tableau c'est la taille du tableau divisé par la taille d'un élément.

Ensuite tu déclares ton tableau mesure

int mesures[nbEntrees][10];

donc en gros si j'ai :

  const int entree_anal[]{A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};   // Liste des entrées analogiques.

je le remplace par

int mesures[nbEntrees][10];
const int nbEntrees=sizeof entree_anal/sizeof entree_anal[0]{A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11}

?? je ne comprend pas trop la 2eme ligne écrite ^^' beaucoup de donnée d'affiler.. je me suis aussi pas mal documenter mais les exemples sont.. enfin pour moi, pas clair xD j'ai du mal à les comprendre..

Tu ne remplaces rien du tout.

tu as un tableau

const int entree_anal[]={A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};   // Liste des entrées analogiques.

Tu veux créer un tableau de mesure dont une des dimensions est la même

const int nbEntrees=sizeof entree_anal/sizeof entree_anal[0];
int mesures[nbEntrees][10];

Bon euh.. je me creuse la tête sur ce que tu m'a dit mais il faut croire qu'elle est vide ou qu'il manque un bout à ma tête..

à quoi ça sert de créer un deuxieme tableau en plus du premier ? je me suis peut être mal exprimé..

J'aimerais qu'à partir de mon premier tableau (où il y a les A0, A1....) j'ai tous les autres tableau qui se cale sur le nombre de A0, A1.. que j'ai.. en gros si il jour je remplace : const int entree_anal[]={A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11}; par const int entree_anal[]={A4, A7, A8, A10}; je n'ai plus dans les autres tableau, que les cases correspondantes à ces 4 valeurs.. je passerai donc de 12 colones à 4 colones.. ou +- le nombre d'entrée que je définirais. c'est faisable ?

C'est bien ce que ça fait. mesure est un exemple de tes autres tableau.

Donnes nous test autres tableaux, ça évitera de parler dans le vide.

Oui chef !

je vous copie le début de mon programme, ça sera plus simple :

    float Tol[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};                    // Tableau des variables de tolérance
          
    int   nb_mesure = 10  ;                                             // Nombre de mesure à effectuer pour la moyenne
    int nb_entrees = 12;                                                // Nombre d'entrée actuel
    int entree=0;                                                       // On met le nombre d'entrée à 0 pour débuter à la 1er entrée
          
    float Tol_A0 =2.7,   Tol_A1 =2.7,   Tol_A2 =2.7,   Tol_A3 =2.7,     // Valeurs fixe qui servent de comparaison
          Tol_A4 =2.7,   Tol_A5 =2.7,   Tol_A6 =2.7,   Tol_A7 = 2.7,    // pour le calcul de tolérance.
          Tol_A8 =2.7,   Tol_A9 =2.7,   Tol_A10 =2.7,  Tol_A11 =2.7 ;     
  /*****************************************************
      Déclaration des Pins d'entrées analogiques
  ******************************************************/  

  const int entree_anal[]{A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};   // Liste des entrées analogiques.

  /****************************************************
     Déclaration des Variables des data d'entrées
  *****************************************************/  

  int valeur_adc[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};      // Déclaration tu tableau de valeurs de l'ADC
  
  /****************************************************
  Déclaration des Variables pour la moyenne
  *****************************************************/

  float i = 0, TA[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};      // Tableau de valeur de tolérance à tester
                             
  /****************************************************
  Déclaration des Variables flottantes pour mesures
  *****************************************************/ 

  float Valeur[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};         // stock les valeurs à virgules
   
  float Vmoy_[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};          // stock les moyennes (avec virgules)

ça c'est le début, juste avant le loop, où je déclare mes tableau etc.

la ligne

 const int entree_anal[]{A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};

est incorrecte, la bonne syntaxe est

 const int entree_anal[]={A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};

Je me demande pourquoi le compilateur ne donne pas d'erreur;

Pour la déclaration de tes tables tu fais comme ceci:

 const int entree_anal[]={A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};   // Liste des entrées analogiques.
 const int NB_ENTREES=sizeof entree_anal/sizeof entree_anal[0];  // nombre d'entrées

 /****************************************************
    Déclaration des Variables des data d'entrées
 *****************************************************/  

 int valeur_adc[NB_ENTREES];      // Déclaration tu tableau de valeurs de l'ADC
 
 /****************************************************
 Déclaration des Variables pour la moyenne
 *****************************************************/

 float TA[NB_ENTREES];       // Tableau de valeur de tolérance à tester
                            
 /****************************************************
 Déclaration des Variables flottantes pour mesures
 *****************************************************/ 

 float Valeur[NB_ENTREES];         // stock les valeurs à virgules
  
 float Vmoy_[NB_ENTREES];          // stock les moyennes (avec virgules)

Et ne pas oublier d'utiliser NB_ENTREES comme limite dans les boucles qui vont parcourir lesdits tableaux.

ça à l'air magique et tellement simple... Merci beaucoup. Je n'ai pas la possibilité de tester actuellement car je n'ai pas la carte avec moi mais dès que je l'ai j'essaye et je te dit si ça fonctionne bien :)

Merci encore en tout cas !!

désolé pour le double poste, en ce qui concerne mes première fonction au début de mon programme,

  /****************************************************
  *****************************************************
       !! TOLERANCE A INDIQUER MANUELLEMENT !!
  *****************************************************
  *****************************************************/ 
    
    float Tol_Min = 0.1 ;    float Tol_Max = 0.1;                       // Tolérances à modifier manuellement
    
    float Tol[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};                    // Tableau des variables de tolérance
          
    int   nb_mesure = 10  ;                                             // Nombre de mesure à effectuer pour la moyenne
    int nb_entrees = 12;                                                // Nombre d'entrée actuel
    int entree=0;                                                       // On met le nombre d'entrée à 0 pour débuter à la 1er entrée
          
    float Tol_A0 =2.7,   Tol_A1 =2.7,   Tol_A2 =2.7,   Tol_A3 =2.7,     // Valeurs fixe qui servent de comparaison
          Tol_A4 =2.7,   Tol_A5 =2.7,   Tol_A6 =2.7,   Tol_A7 = 2.7,    // pour le calcul de tolérance.
          Tol_A8 =2.7,   Tol_A9 =2.7,   Tol_A10 =2.7,  Tol_A11 =2.7 ;

j'ai vu que tu n'y a pas toucher, j'en déduit que ça ne change pas ?

D'après ce que j'ai compris Tol est un tableau de constantes donc il devrait plutot être défini comme ceci

//                 A0  A1  A2  A3  A4  A5  A6  A7  A8  A9  A10 A11
const float Tol[]={2.7,2.7,2.7,2.7,2.7,2.7,2.7,2.7,2.7,2.7,2.7,2.7};

C’est… une excellente idée :smiley:
j’ai essayer de faire fonctionner mon programme avec ce que tu m’a donner, si je laisse les 12 pin ça fonctionne, si j’enlève quelques pin, cela e fonctionne plus…
je te met mon programme en entier, j’ai peut être oublier de modifier certaines choses ^^ (j’ai du supprimer les commentaires pour qu’il tienne dans le message je le met aussi en pièce jointe avec comentaires

/*
AFPT : faire en sorte qu'en remplissant le tableau des A0.... on récupére et on l'applique aux autres tableaux



 const int entree_anal[]={A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};   // Liste des entrées analogiques.
 const int NB_ENTREES=sizeof entree_anal/sizeof entree_anal[0];  // nombre d'entrées




  /****************************************************
  *****************************************************
       !! TOLERANCE A INDIQUER MANUELLEMENT !!
  *****************************************************
  *****************************************************/ 
    
    float Tol_Min = 0.1 ;    float Tol_Max = 0.1;                       // Tolérances à modifier manuellement
    
    float Tol[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};                    // Tableau des variables de tolérance
          
    int   nb_mesure = 10  ;                                             // Nombre de mesure à effectuer pour la moyenne
  //  int nb_entrees = 12;                                                // Nombre d'entrée actuel
    int entree=0;                                                       // On met le nombre d'entrée à 0 pour débuter à la 1er entrée
          
    float Tol_A0 =2.7,   Tol_A1 =2.7,   Tol_A2 =2.7,   Tol_A3 =2.7,     // Valeurs fixe qui servent de comparaison
          Tol_A4 =2.7,   Tol_A5 =2.7,   Tol_A6 =2.7,   Tol_A7 = 2.7,    // pour le calcul de tolérance.
          Tol_A8 =2.7,   Tol_A9 =2.7,   Tol_A10 =2.7,  Tol_A11 =2.7 ;     
  /*****************************************************
      Déclaration des Pins d'entrées analogiques
  ******************************************************/  
  
  const int entree_anal[]={A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};   // Liste des entrées analogiques.
  const int NB_ENTREES=sizeof entree_anal/sizeof entree_anal[0];  // nombre d'entrées

//const int entree_anal[]{A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};   
 
  /****************************************************
     Déclaration des Variables des data d'entrées
  *****************************************************/  

  int valeur_adc[NB_ENTREES];      // Déclaration tu tableau de valeurs de l'ADC
  //int valeur_adc[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};    
  
  /****************************************************
  Déclaration des Variables pour la moyenne
  *****************************************************/
  float i = 0, TA[NB_ENTREES];       // Tableau de valeur de tolérance à tester
//  float i = 0, TA[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};     
                             
  /****************************************************
  Déclaration des Variables flottantes pour mesures
  *****************************************************/ 

  float Valeur[NB_ENTREES];         // stock les valeurs à virgules
 
  float Vmoy_[NB_ENTREES];          // stock les moyennes (avec virgules)

//  float Valeur[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};         
   
//  float Vmoy_[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};          
                                     
  /***********************************************
  ************************************************
          SETUP DU PROGRAMME
  ************************************************
  ************************************************/  
  int Led_Bouton = 51;               
  int Bouton = 50 ;                  
  int test_bp = 49, etat_bp;               
  volatile byte etat_led = LOW;      
  
  
  void setup()                       
  {
    Serial.begin(115200);           
    analogReadResolution(12);        
    pinMode (53, OUTPUT);            
    pinMode (52, OUTPUT);            
    pinMode (test_bp, INPUT) ; 
    pinMode(Led_Bouton, OUTPUT);     
    pinMode(Bouton, INPUT);          
    attachInterrupt(digitalPinToInterrupt(Bouton), interrupt_bouton, FALLING);   
  }                                                                         
  /***********************************************                               // déscendant (FALLING)
  ************************************************
          DEBUT DU PROGRAMME
  ************************************************
  ************************************************/ 
  
  void loop() 
  {
  digitalWrite (53, HIGH);                 
  if(i<nb_mesure)                              
  {
    for(entree=0;entree<NB_ENTREES;entree++)   {action}
    {  
      
      valeur_adc[entree] = analogRead(entree_anal[entree]); 
      Valeur[entree] = valeur_adc[entree];     

         TA[entree] = valeur_adc[entree]*(3.314/4096);             
      Vmoy_[entree] += valeur_adc[entree] ;    
      delay(2);                              
      
    }
     i++;                                    
  }
  else                                       
  {
    digitalWrite (53, LOW);                  
    for(entree=0;entree<NB_ENTREES;entree++)   {action}
    {
     Valeur[entree]=(Vmoy_[entree]/(nb_mesure));            
     affiche_pin();                        
     i=0;                                     
     Vmoy_[entree] = 0;                      
    }
        Serial.println("DI1=ON");       
    Serial.println("DI2=OFF");          
    delay(1);                                 
     etat_bp = digitalRead(test_bp);
    if(etat_bp == HIGH)
    {Serial.println("Bouton Poussoir APPUYEE");}
    else{
    if(etat_bp == LOW) {Serial.println("Bouton Poussoir N_APPUYEE");}}
  }
  // a décaller après le ELSE afin de tester plus souvant // FAIT
  // RAJOUTER AUSSI si appuie sur BP PIN 49 affichier on ou off.  // FAIT au dessus
    if (Serial.available())                  
    {
      String str=Serial.readString();      
      Serial.println(str);                   
      if (str=="setdo1=on")                   
      {    
        digitalWrite(52, HIGH);            
        Serial.println("Vous avez allumer la LED");
        delay(1500);                         
      }  
      if (str=="setdo1=off")                  
      {
        digitalWrite(52, LOW);            
        Serial.println("Vous avez eteint la LED"); 
        delay(1500);                          
      }
      else
      {
       Serial.print("commande saisie :  ");   
       Serial.print(str);                   
       Serial.println("\t INVALIDE");        
       delay(1500);                        
      }
    }
    else                                      
    {}                                       }                                             
  
  void affiche_pin()
  {
//    Serial.print("A");                         
//    Serial.print(entree);                      
//    Serial.print("_HEXA = " );                 
//    Serial.print(valeur_adc[entree],HEX);      
//    Serial.print("\t\t A");                    
//    Serial.print(entree);                      
//    Serial.print("_3.3V = ");                  
//    Serial.print(Valeur[entree]*(3.314/4096),3);
//    Serial.print("\t A");                       
//    Serial.print(entree);                      
//    Serial.print("_6V = ");                     
//    Serial.print(Valeur[entree]*(6.0/4096),3);  
    Serial.print("AI");                     
    Serial.print(entree);                       
    Serial.print("=");
//    Serial.print("_6V_corr = ");               
    Serial.print(((Valeur[entree]*(6.0/4096))+0.1),3);
    Serial.print("=");
    if(TA[entree] > Tol_A0 + Tol_Max || TA[entree] < Tol_A0 - Tol_Min ) 
    {  Serial.println("NOK "); }           
    else 
    { Serial.println("OK ");}               
  }
  


    void interrupt_bouton()                     
  {
    etat_led =! etat_led;                       
    digitalWrite(Led_Bouton,etat_led)   ;       
  }

Prog_Arduino_V1.3.ino (11.5 KB)

J'ai jeté un coup d'oeil à ton programme, à première vue je ne vois pas pourquoi ça ne focntionnerait pas lorsqu'il y a moins de pins. Qu'est ce qu'il se passe exactement?

kamill: J'ai jeté un coup d'oeil à ton programme, à première vue je ne vois pas pourquoi ça ne fonctionnerait pas lorsqu'il y a moins de pins. Qu'est ce qu'il se passe exactement?

bon, j'ai fais mes tests.. si j’enlève les ports un a un en partant de A11 jusqu'à me retrouver avec uniquement A0, ça fonctionne.

Si par contre j'enlève juste le port A4, ou A7 sans toucher aux autres, plus rien ne s'affiche. Nada, niet... Je trouve cela étrange car dans un sens sa fonctionne mais pas dans l'autre.

EDIT / Bon j'ai refais des test et cette fois ci cela fonctionne, j'en déduit donc que cela devais venir d'un problème de connexion ou de communication avec la carte. J'avais du mal brancher l'USB ou autre... M'enfin l'important c'est que cela marche !!! Merci beaucoup ! :)

RE désolé pour le doublepost, mais j'ai de nouveau un soucis ^^'

Lors de l'affichage, j'aimerai afficher le numéro du port (A0, A1 etc). Pour cela il faut que j'aille chercher dans mon tableau où il y a les ports. Quand je met cette ligne :     Serial.print(entree_anal[entree]);                        // Affiche la valeur de l'entrée il est censé aller chercher la valeur du tableau dans la case N° = entree. or ça me met entre 54 et 65, pour des valeurs de "entree" = 0 à 12.... je ne comprend pas....

j'ai tester ceci :

    Serial.print("Input ");                           // Affiche "A"
    Serial.print(entree_anal[entree]);                         // Affiche la valeur de l'entrée
    Serial.print("\t entree =");
    Serial.println(entree);

Pour avoir les valeurs de "entree" et la valeur que le tableau me sort, et quand entree =0 j'ai la valeur du taleau = 54, entree =1 et tableau = 55, entree =3 et tableau 56 et ainsi de suite.. je m'y prend mal ?

C'est le numéro des entrées sur la carte arduino. Si tu veux afficher l numéro d'entrée sour la forme 0 à 11, il faut que tu affiches entree

   Serial.print("Input ");                           // Affiche "A"
   Serial.print(entree);                         // Affiche la valeur de l'entrée
   Serial.print("\t entree =");
   Serial.println(entree_anal[entree]);

Par contre ça ne fonctionnera plus s'il y a un trou dans la table des entrées

ah.. c'est justement ce que j'aimerais faire, afficher même s'il y a un trou.. par exemple j'ai A0, A1, A2, A6, A7 et j'aimmerais que ça n'affiche pas les entrées non sélectionner et uniquement celles sélectionné.. il y a un moyen de faire ça ? je pensais à aller chercher ce qu'il y a dans le tableau "entree_anal" car en cellule 0 il y aurais A0, celleule 1, A1 etc ... mais comme tu l'a vue, ce que j'ai fais n'a pas fonctionner :/