Go Down

Topic: [Conseil] Projet sur Arduino Due, multimètre spécial (Read 2250 times) previous topic - next topic

alex34000

Bonjour, je suis en stage pour valider mon BTS, et l'entreprise m'a demander de réaliser un projet (qui compte dans mon rapport de stage et pour valider le BTS).

Je vous donnes les infos essentiels :

Je suis muni d'une Arduino Due (je n'ai utiliser que la Uno en classe et encore, on nous demander de programmer en C++ sans utiliser les fonction inclue dans les bibliothèques d'arduino etc). Je doit m'en servir pour :
Dans un premier temps, sur les entrées analogiques A0 à A11, être capable de recevoir des tensions, de les convertir avec le CAN sur 12 bits de résolution, et les transmettre sur la console (pour le moment) de IDE (le principe est que j'aurais des tensions par port entre 3.5v, 6v, +16, -16, +16=>-16 V (soit 32V) et24V en entrée, et je doit pouvoir servir de voltmètre hyper précis, bien évidement les entrées de la carte ne supportant pas plus de 3.3V, je mettrai un pont diviseur en entrée mais la je joue avec un potentiometre relié à la masse et au +3.3 de la carte, sur le port A0 afin de faire mes tests).

Dans un second temps, on me demande qu'avec une simple commande, exemple : on rentre dans la console de l'IDE "D0_ON" et le port D0 devient ON, et si on tape "D0_OFF" le port D0 s'eteint.

La première partie est réalisé avec un léger succes, car je suis plus précis qu'un multimètre de type FLUKE175, sauf que pour ça je doit avant tout rentrer la tension de sortie du pin qui sort du 3.3V, or il ne sort pas vraiment la même tension, elle varie à quelques mV près et c'est une différence importante ! et je ne suis précis qu'à 2-5 mV près ce qui n'est pas assez. Je vous met mon programme ci dessous, si vous avez des idées pour l'améliorer ^^'

Code: [Select]
  // These constants won't change.  They're used to give names
  // to the pins used:
  const int AI_A0 = A0;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A1 = A1;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A2 = A2;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A3 = A3;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A4 = A4;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A5 = A5;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A6 = A6;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A7 = A7;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A8 = A8;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A9 = A9;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A10 = A10;  // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A11 = A11;  // PIN d'entrée analogique sur le quel est attaché le potentiomettre
 
  int Table_Valeur[101]={}, i=0;
 
  int sensorValue = 0 ;  //Déclaration d'une variable en INT
  float V_A0 = 0;        //Déclaration d'une variable en flotante
  void setup() {
    // initialize serial communications at 9600 bps:
    Serial.begin(9600);
  }
 
  void loop() {
     analogReadResolution(12); //règle la résolution sur 12 bits
   
     if(i<=99)
     {
      sensorValue = analogRead(AI_A0);                   //Donne à la variable les valeurs lue sur le port A0
      V_A0 = sensorValue;
      Table_Valeur[i]=sensorValue;
      // Serial.println(Table_Valeur[i]);
      i++;
     // Serial.println(Table_Valeur[i]);
     }
     else
     {
      V_A0=((Table_Valeur[0]+Table_Valeur[1]+Table_Valeur[2]+Table_Valeur[3]
      +Table_Valeur[4]+Table_Valeur[5]+Table_Valeur[6]+Table_Valeur[7]
      +Table_Valeur[8]+Table_Valeur[9]
      +Table_Valeur[10]+Table_Valeur[11]+Table_Valeur[12]+Table_Valeur[13]
      +Table_Valeur[14]+Table_Valeur[15]+Table_Valeur[16]+Table_Valeur[17]
      +Table_Valeur[18]+Table_Valeur[19]
      +Table_Valeur[20]+Table_Valeur[21]+Table_Valeur[22]+Table_Valeur[23]
      +Table_Valeur[24]+Table_Valeur[25]+Table_Valeur[26]+Table_Valeur[27]
      +Table_Valeur[28]+Table_Valeur[29]
      +Table_Valeur[30]+Table_Valeur[31]+Table_Valeur[32]+Table_Valeur[33]
      +Table_Valeur[34]+Table_Valeur[35]+Table_Valeur[36]+Table_Valeur[37]
      +Table_Valeur[38]+Table_Valeur[39]
      +Table_Valeur[40]+Table_Valeur[41]+Table_Valeur[42]+Table_Valeur[43]
      +Table_Valeur[44]+Table_Valeur[45]+Table_Valeur[46]+Table_Valeur[47]
      +Table_Valeur[48]+Table_Valeur[49]
      +Table_Valeur[50]+Table_Valeur[51]+Table_Valeur[52]+Table_Valeur[53]
      +Table_Valeur[54]+Table_Valeur[55]+Table_Valeur[56]+Table_Valeur[57]
      +Table_Valeur[58]+Table_Valeur[59]
      +Table_Valeur[60]+Table_Valeur[61]+Table_Valeur[62]+Table_Valeur[63]
      +Table_Valeur[64]+Table_Valeur[65]+Table_Valeur[66]+Table_Valeur[67]
      +Table_Valeur[68]+Table_Valeur[69]
      +Table_Valeur[70]+Table_Valeur[71]+Table_Valeur[72]+Table_Valeur[73]
      +Table_Valeur[74]+Table_Valeur[75]+Table_Valeur[76]+Table_Valeur[77]
      +Table_Valeur[78]+Table_Valeur[79]
      +Table_Valeur[80]+Table_Valeur[81]+Table_Valeur[82]+Table_Valeur[83]
      +Table_Valeur[84]+Table_Valeur[85]+Table_Valeur[86]+Table_Valeur[87]
      +Table_Valeur[88]+Table_Valeur[89]
      +Table_Valeur[90]+Table_Valeur[91]+Table_Valeur[92]+Table_Valeur[93]
      +Table_Valeur[94]+Table_Valeur[95]+Table_Valeur[96]+Table_Valeur[97]
      +Table_Valeur[98]+Table_Valeur[99])/100);
      affiche();
      i=0;
       
     }
 
    // wait 2 milliseconds before the next loop
    // for the analog-to-digital converter to settle
    // after the last reading:
    delay(2);
   
     
  }
 
  void affiche()
  {
      Serial.print("A0_HEXA = " );                       //affiche "A0_HEXA="
    Serial.print(sensorValue,HEX),4;                     //Affiche la valeur actuel du potentiomettre (sur une résolution de 12 bits)
    Serial.print("\t A0_3.3V = ");                     //Affiche "VA0_3.3V ="
    Serial.print(V_A0*(3.3164/4096),4);                     //Affiche la valeur de V_A0 en 3.3V
    Serial.print("\t\t A0_6V = ");                     //Affiche "VA0_6V = "
    Serial.print(V_A0*(6.0/4096),4);                     //Affiche la valeur de V_A0 en 6V
    Serial.print("\t A0_6V_Corr = ");                  //Affiche "A0_6V_corr = "
    Serial.println(((V_A0*(6.0/4096))+0.1),4);           //Affiche la valeur de V_A0 en 6V + une correction
  }



Par contre pour la 2ème partie, je n'ai aucune idée. Je ne sais même pas si je peut écrire sur la console de l'IDE, pour pouvoir piloter les ports, et si c'est le cas, je ne sais comment faire. J'ai beaucoup chercher sur internet, mais pour l'Arduino Due je ne trouve pas beaucoup d'infos qui m'aide... Si vous avez des infos à me donner et des idées, des exemples, je suis preneur !!

Merci de votre attention et à bientôt j'espère !

68tjs

Et un de plus :
A lire :
http://forum.arduino.cc/index.php?topic=405747.msg2790786#msg2790786

Une petite demande au modo par le lien "report to moderator" pour déplacer le sujet AU BON ENDROIT et ce sera parfait.

A bientôt

68tjs

Une précision de vocabulaire pour éviter la confusion.
Dans les micro-contrôleurs un PORT s'écrit souvent majuscule parce qu'un PORT est un ensemble d'Entrées/ Sorties contrôlées par le même "registre".
Je ne connais pas la Due qui est un ARM mais les avr sont 8 bits et un PORT peut regrouper jusqu'à 8 E/S.
Les ARM sont 32 bits mais (il me semble) ne regroupent que 16 E/S par registre.

Pour parler d'une E/S unitaire on emploi plutôt les termes "pin" ou en français "broche".

Pour la deuxièmme partie je n'ai pas vraiment compris ce que tu cherches à faire mais oui le Serial moniteur est bidirectionel et tu peux entrer des informations au clavier.
Regardes les exemples fournis avec l'IDE (avr ou ARM les fonctions arduino portent le même nom).

bilbo83

Bonjour,


Tu veux réaliser un voltmètre "hyper précis", c'est à dire ?

Tu parles de mesurer des tensions négatives (-16v), attention, même avec un pont diviseur tu n'auras jamais de positif.
Tu devras passer par un translateur de niveau (AOP).

kamill

Bonjour,

Je ne voudrais pas freiner ton enthousiasme, mais ça m'étonnerait que tu sois plus précis qu'un FLUKE175 sans référence de tension de précision. Sans compter que le fluke a une meilleure résolution et doit avoir des composants et une implantation de ceux ci particulièrement chiadée.

Pour ce qui est de ton programme, le moins qu'on puisse dire est que tu le lésines pas sur les lignes de code. Pour faire la somme du tableau, il suffisait de faire une boucle.
Ce tableau est d'ailleurs totalement inutile, il suffit de faire la somme chaque fois que tu fais une mesure.

Comme le dit 68tjs tu peux envoyer des chaines de caractères avec le moniteur série (en haut touche 'envoyer'), après il suffit de comparer la chaine reçue aux instructions que tu dois traiter.

alex34000

Bonjour, tout d'abord, merci à tous pour vos idées et pour la réactivités. Ce matin j'ai un peut modifier les programme et assembler la partie "moyenne" avec la partie "mesure sur chaque Pin (de A0 à A11)".

Quote
ça m'étonnerait que tu sois plus précis qu'un FLUKE175 sans référence de tension de précision
Pour réaliser ce test je me suis servis d'un multimètre très précis, j'ai mesurer avec exactitude la valeur de la tension débité par le PIN qui sort du 3.3V (elle varie à quelques mV près) et je l'ai ajouté à mon programme, ce qui a fais que j'étais très précis. Maintenant j'ai peut être mal lu, je re essayerai cet après midi si il faut ^^, l'erreur est humaine nous dirons.

Quote
Comme le dit 68tjs tu peux envoyer des chaines de caractères avec le moniteur série
C'est justement ce que j'ai essayer ! or j'ai l'impression qu'il faut une commande qui enregistrerai ce qui est saisis, car cela n'a rien fais quand j'envoyai des caractères...

Quote
Tu veux réaliser un voltmètre "hyper précis", c'est à dire ?
Je veux réaliser le Voltmètre le plus précis possible avec ma résolution de 12 bits. Mon module doit remplacer un PIC qui a une résolution de 10 bits, avec mes 12 bits sur ma Due j'aimerai donc être plus précis que le PIC déjà présent.. enfin c'est ce qui m'est demandé.

Quote
Tu parles de mesurer des tensions négatives (-16v), attention, même avec un pont diviseur tu n'auras jamais de positif.
Tu devras passer par un translateur de niveau (AOP).
C'est prévu dans le montage ;) la tension négative n'est pas un soucis apparent à mes yeux, le montage déjà fais avec le PIC prévoie cela. Je dirais donc que ce n'est pas le plus important à gérer. Mais merci de l'info pour l'AOP ^^"


Quote
Pour la deuxièmme partie je n'ai pas vraiment compris ce que tu cherches à faire mais oui le Serial moniteur est bidirectionel et tu peux entrer des informations au clavier.
Regardes les exemples fournis avec l'IDE (avr ou ARM les fonctions arduino portent le même nom).
En gros j'aimerai saisir une commande au clavier, l'envoyer, et que cette commande active (ou désactive en fonction de ce qui est saisit) un port numérique (ou digital, c'est la même) de ma carte.



Pour en revenir vite fais à mon programme, oui je ne lésigne pas sur les lignes de codes.. pour le moment j'ai la place et vu les capacité de l'ARM j'ai pas de soucis la dessus. M'enfin je reste ouvert à toutes proposition pour alléger le nombre de ligne, je n'ai pas vraiment été très doué pour faire un truc simple... D'ailleurs, pourquoi faire simple quand on peut faire compliqué ? ;)

Voici le programme légèrement améliorer à l'heure où je vous parle. Si vous connaissez la formule pour alléger mon calcul sans poser de soucis aux variables déjà présente, je dit OUI !! ^^

(je vous met juste pour 1 PIN et le sous programme associé, pour faciliter la lecture, les 12 autres ont exactement la même programmation

Code: [Select]
/****************************************************
  *****************************************************
       !! TOLERANCE A INDIQUER MANUELLEMENT !!
  *****************************************************
  *****************************************************/
   
    float Tol_Min = 0.3;    float Tol_Max = 0.3;                    // Tolérances à modifier manuellement
   
    float TA0 = 0, TA1 = 0, TA2 = 0, TA3 = 0,
          TA4 = 0, TA5 = 0, TA6 = 0, TA7 = 0,
          TA8 = 0, TA9 = 0, TA10 = 0, TA11 = 0 ;                   // Variable sans la tolérance à tester
         
    float Tol_A0 =3.0,   Tol_A1 =3.0,   Tol_A2 =3.0,   Tol_A3 =3.0,
          Tol_A4 =3.0,   Tol_A5 =3.0,   Tol_A6 =3.0,   Tol_A7 =3.0,
          Tol_A8 =3.0,   Tol_A9 =3.0,   Tol_A10 =3.0,  Tol_A11 =3.0 ;     // Variable fixe qui sert de base pour la tolérance.
  /*****************************************************
      Déclaration des Pins d'entrées analogiques
  ******************************************************/ 

  const int AI_A0 = A0, AI_A1 = A1, AI_A2 = A2, AI_A3 = A3,       // PIN d'entrées analogiques sur les quels
            AI_A4 = A4, AI_A5 = A5, AI_A6 = A6, AI_A7 = A7,       // sont reliés des composants
            AI_A8 = A8, AI_A9 = A9, AI_A10 = A10, AI_A11 = A11;                             
 
  /****************************************************
     Déclaration des Variables des data d'entrées
  *****************************************************/ 

  int sensorValue_A0 = 0, sensorValue_A1 = 0, sensorValue_A2 = 0,     //Déclaration des variables en INT
      sensorValue_A3 = 0, sensorValue_A4 = 0, sensorValue_A5 = 0,
      sensorValue_A6 = 0, sensorValue_A7 = 0, sensorValue_A8 = 0,
      sensorValue_A9 = 0, sensorValue_A10 = 0, sensorValue_A11 = 0;

  /****************************************************
  Déclaration des Variables pour la moyenne
  *****************************************************/
  int Table_A0[50]={}, Table_A1[50]={}, Table_A2[50]={}, Table_A3[50]={},
      Table_A4[50]={}, Table_A5[50]={}, Table_A6[50]={}, Table_A7[50]={},
      Table_A8[50]={}, Table_A9[50]={}, Table_A10[50]={}, Table_A11[50]={},
      i = 0;
                             
  /****************************************************
  Déclaration des Variables flottantes pour mesures
  *****************************************************/

  float V_A0 = 0, V_A1 = 0, V_A2 = 0, V_A3 = 0,         // Déclaration des variables en flotantes pour les port :
        V_A4 = 0, V_A5 = 0, V_A6 = 0, V_A7 = 0,         // A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11
        V_A8 = 0, V_A9 = 0, V_A10 = 0, V_A11 = 0;       
                                     
  /***********************************************
  ************************************************
          SETUP DU PROGRAMME
  ************************************************
  ************************************************/ 
  void setup()
  {
    Serial.begin(19200);                               // Initialise la comunication série à 9600 Bauds.
  }
 
  /***********************************************
  ************************************************
          DEBUT DU PROGRAMME
  ************************************************
  ************************************************/
 
  void loop() {
     analogReadResolution(12);                         //règle la résolution sur 12 bits
     
  // *****************************************
  //      Port A0
  //******************************************
     

    if(i<=50)
    { 
    sensorValue_A0 = analogRead(AI_A0);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue 
    V_A0 = sensorValue_A0;                             //Incrémente sensorValue dans la variale V_A0
    TA0 = V_A0*(3.3/4096);
    affiche_port_A0();
    Table_A0[i]=sensorValue_A0;
    i++
    }
        else
     {
      V_A0=((Table_A1[0]+Table_A1[1]+Table_A1[2]+Table_A1[3]
      +Table_A1[4]+Table_A1[5]+Table_A1[6]+Table_A1[7]
      +Table_A1[8]+Table_A1[9]
      +Table_A1[14]+Table_A1[15]+Table_A1[16]+Table_A1[17]
      +Table_A1[20]+Table_A1[21]+Table_A1[22]+Table_A1[23]
      +Table_A1[24]+Table_A1[25]+Table_A1[26]+Table_A1[27]
      +Table_A1[28]+Table_A1[29]
      +Table_A1[30]+Table_A1[31]+Table_A1[32]+Table_A1[33]
      +Table_A1[34]+Table_A1[35]+Table_A1[36]+Table_A1[37]
      +Table_A1[38]+Table_A1[39]
      +Table_A1[40]+Table_A1[41]+Table_A1[42]+Table_A1[43]
      +Table_A1[44]+Table_A1[45]+Table_A1[46]+Table_A1[47]
      +Table_A1[48]+Table_A1[49])/50)
      i=0;
     }


sous programme d'affichage :
Code: [Select]
  void affiche_port_A0()
  {
      Serial.print("A0_HEXA = " );                       //affiche "A0_HEXA="
    Serial.print(sensorValue_A0,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
    Serial.print("\t\t A0_3.3V = ");                   //Affiche "VA0_3.3V ="
    Serial.print(V_A0*(3.3/4096),4);                   //Affiche la valeur de V_A0 en 3.3V (le nb après la "," augmente la précision).
    Serial.print("\t A0_6V = ");                       //Affiche "VA0_6V = "
    Serial.print(V_A0*(6.0/4096),4);                   //Affiche la valeur de V_A0 en 6V (le nb après la "," augmente la précision).
    Serial.print("\t\t A0_6V_Corr = ");                //Affiche "A0_6V_corr = "
    Serial.print(((V_A0*(6.0/4096))+0.1),4);         //Affiche la valeur de V_A0 en 6V + une correction. (le nb après la "," augmente la précision).
    if(TA0 > Tol_A0 + Tol_Max || TA0 < Tol_A0 - Tol_Min )
    {  Serial.println("\t N_OK "); }
    else
    { Serial.println("\t OK ");}
  }
 

dfgh

hello
en partant de ton 1er prg
tu remarqueras que tu ne faisais que lire la résolution de conversion ( qui est sur 8 bits par défaut )
et encore, il aurait fallu : variable=analogReadresolution();
Code: [Select]

// These constants won't change.  They're used to give names
  // to the pins used:
  const int AI_A0 = A0;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A1 = A1;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A2 = A2;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A3 = A3;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A4 = A4;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A5 = A5;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A6 = A6;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A7 = A7;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A8 = A8;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A9 = A9;    // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A10 = A10;  // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  const int AI_A11 = A11;  // PIN d'entrée analogique sur le quel est attaché le potentiomettre
  float sum_average=0;
  int sensorValue = 0 ;
void setup()
{
  Serial.begin(9600);
  analogWriteResolution(12); //règle la résolution sur 12 bits
}

void loop()
{
  for (int f =1;f<101;f++)
  {
    sensorValue = analogRead(AI_A0);
    sum_average += sensorValue;
    delay(2); 
  }
  sum_average = sum_average/100;
  affiche();
}
 
 
   void affiche()
  {
    Serial.print("A0_HEXA = " );                       //affiche "A0_HEXA="
    Serial.print(sensorValue,HEX),4;                     //Affiche la valeur actuel du potentiomettre (sur une résolution de 12 bits)
    Serial.print("\t A0_3.3V = ");                     //Affiche "VA0_3.3V ="
    Serial.print(sum_average*(3.3164/4096),4);                     //Affiche la valeur de V_A0 en 3.3V
    Serial.print("\t\t A0_6V = ");                     //Affiche "VA0_6V = "
    Serial.print(sum_average*(6.0/4096),4);                     //Affiche la valeur de V_A0 en 6V
    Serial.print("\t A0_6V_Corr = ");                  //Affiche "A0_6V_corr = "
    Serial.println(((sum_average*(6.0/4096))+0.1),4);           //Affiche la valeur de V_A0 en 6V + une correction
  }

alex34000

hello
en partant de ton 1er prg
tu remarqueras que tu ne faisais que lire la résolution de conversion ( qui est sur 8 bits par défaut )
et encore, il aurait fallu : variable=analogReadresolution();
Oui je viens de remarquer, merci, mais je te rassure j'ai bien mit cette fonction dans les programmes suivants.. je l'ai peut être mal appliqué ?

Je n'ai pas très bien compris ce que tu a rajouter au programme :

Code: [Select]
void loop()
{
 for (int f =1;f<101;f++)
 {
   sensorValue = analogRead(AI_A0);
   sum_average += sensorValue;
   delay(2);
 }
 sum_average = sum_average/100;
 affiche();
}


pourrais tu détailler la partie "sum_average" ?

merci beaucoup !

dfgh

nous sommes bien d'accord que c'est analgWriteresolution

kamill

Pour fixer la résolution des entrées analogiques c'est analogReadResolution(), analogWriteResolution() c'est pour fixer la résolution des convertisseurs digital  analogique

alex34000

Bonjour

Si tu as besoin de mesures de tension très précises, alors utiliser le convertisseur intégré au microcontrôleur de l'Arduino est parfaitement illusoire, car il n'est pas fait pour cela.
Je n'ai pas possibilité d'en avoir un externe, comme on dit "on fais avec ce que on a". Ils veulent une meilleur mesure que le PIC qui est sur 10 bits, la Due est sur 12 bit donc elle est censé être un peut supérieur qui celle du PIC, n'est-ce pas ?

nous sommes bien d'accord que c'est analgWriteresolution
Il me semble comme l'a dit Kamill  que c'est analogRead, en tout cas c'est ce que j'ai lu sur le site de Arduino Due

bilbo83

Tu peux placer analogReadResolution(12); dans le setup(). Inutile de le refaire  à chaque boucle.

dfgh

Pour fixer la résolution des entrées analogiques c'est analogReadResolution(), analogWriteResolution() c'est pour fixer la résolution des convertisseurs digital  analogique
autant pour moi

merci kamill

68tjs

Disposer d'une meilleure résolution ne signifie absolument pas que les mesures soient plus précises, c'est-à-dire entachées de moins d'erreurs.
Tout à fait.
Tu devrais lire la partie de la datasheet du micro de la DUE qui traite du convertisseur analogique numérique et des erreurs de quantifications..

Ce n'est pas parceque tu lit 828 que tu as réellement 828.
Les erreurs qui s'ajoutent à la mesure se répartissent en deux groupes :

- les erreurs systématiques pour l'exemplaire du micro que tu as réellement,( elles sont différentes d'un exemplaire à un autre).
Atmel donne juste les bornes maximales basées sur des statistiques de fabrication.

- les erreurs d'origines aléatoires, dues au bruits par exemple, mais pas que.

Les erreurs systématiques peuvent parfois s'éliminer avec un étalonnage.
S'il n'est pas possible de les éliminer avec un étalonnage, elles se somment arithmétiquement.

Les erreurs aléatoires se somment quadratiquement, certains disent "en rms". Cela s'explique par le fait qu'elles sont aléatoires donc statistiquement il n'y a aucune raison qu'elles se produisent en même temps et qu'elles aient le même signe.
La sommation est à rapprocher des courbes de Gauss et des écarts types.

Exemple avec deux sources d'erreur dont l'une donne une erreur à +/- 5 lsb et l'autre à +/- 3 lsb.
Si ce sont des erreurs systématiques la mesure sera connue à +/- 8 lsb.
Si ce sont des erreurs aléatoires la mesure sera connue à  P= +/- Racine(52+32) = +/- 5,8 lsb

La grande difficulté est de distinguer ce qui est systématique de ce qui est aléatoire. Sur ce plan les fabricants de micro ne sont pas très bavards.

dfgh

ton code simplifié
Code: [Select]
const int entree_ana[]{A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11};
  float sum_average=0;
  int sensorValue = 0 ;
  int entree=0;
  int f=0;
  int nb_mesures = 3; //mettre le nb de mesures pour effectuer la moyenne
  int nb_entrees = 12;
void setup()
{
  Serial.begin(57600);
  analogReadResolution(12);
}

void loop()
{
  for (entree=0;entree<nb_entrees;entree++)
  {
    sum_average = 0;
    for (f =1;f<nb_mesures;f++)
    {
      sensorValue = analogRead(entree_ana[entree]);
      sum_average += sensorValue;
      Serial.print("   mesure " ); Serial.print(f);Serial.print(" sur entree  " ); Serial.println(entree);
      //affiche();
      delay(2);
    }
  sum_average = sum_average/nb_mesures;
  Serial.print("moyenne sur entree ");Serial.print(entree);
  affiche();
  if (entree==(nb_entrees-1)){while(1);}
}
}
 
   void affiche()
  {
    Serial.print("  _HEXA = " );                       //affiche "A0_HEXA="
    Serial.print(sensorValue,HEX),4;                     //Affiche la valeur actuel du potentiomettre (sur une résolution de 12 bits)
    Serial.print("\t A0_3.3V = ");                     //Affiche "VA0_3.3V ="
    Serial.print(sum_average*(3.3164/4096),4);                     //Affiche la valeur de V_A0 en 3.3V
    Serial.print("\t\t A0_6V = ");                     //Affiche "VA0_6V = "
    Serial.print(sum_average*(6.0/4096),4);                     //Affiche la valeur de V_A0 en 6V
    Serial.print("\t A0_6V_Corr = ");                  //Affiche "A0_6V_corr = "
    Serial.println(((sum_average*(6.0/4096))+0.1),4);           //Affiche la valeur de V_A0 en 6V + une correction
  }

Go Up