Go Down

Topic: [Question] Possibilité de gerer un tableau en fonction d'un autre tableau ?  (Read 1 time) previous topic - next topic

alex34000

Bonjour,

Je cherche à savoir si il est possible de gérer la taille d'un ou plusieurs tableau en 2 dimensions (ex : tableau1
  • [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.

kamill

Bonjour,

sizeof est ton ami.
le nombre d'éléments de ton tableau entree_anal est
Code: [Select]
const int nbEntrees=sizeof entree_anal/sizeof entree_anal[0];

tu peux ensuite utiliser nbEntrees pour dimensionner tes autres tableaux.

alex34000

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

kamill

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
Code: [Select]
int mesures[nbEntrees][10];

alex34000

donc en gros si j'ai :
Code: [Select]

  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
Code: [Select]

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

kamill

Tu ne remplaces rien du tout.

tu as un tableau
Code: [Select]
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
Code: [Select]
const int nbEntrees=sizeof entree_anal/sizeof entree_anal[0];
int mesures[nbEntrees][10];

alex34000

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 ?

kamill

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.

alex34000

Oui chef !

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

Code: [Select]

    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.

kamill

la ligne
Code: [Select]
 const int entree_anal[]{A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};
est incorrecte, la bonne syntaxe est
Code: [Select]
 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:
Code: [Select]
 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)

fdufnews

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

alex34000

ç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 !!

alex34000

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

  /****************************************************
  *****************************************************
       !! 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 ?

kamill

D'après ce que j'ai compris Tol est un tableau de constantes donc il devrait plutot être défini comme ceci
Code: [Select]
//                 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};

alex34000

C'est.... une excellente idée :D
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

Code: [Select]

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

Go Up