[Arduino Due] Faire un voltmètre/ampèremètre spécial.

Version imprimable

Bonjour, j'ai commencer à bosser sur un projet pour mon BTS mais me voila un peut en galère.

Je vous explique :

Je doit remplacer un multimètre/ampèremètre pour une entreprise. Le leur à une résolution de 10 bits. Ils m'ont donc fournis une Arduino Due (qui a donc une résolution de 12 bits) afin que je puisse leurs faire le programme etc. Pour le moment je n'ai pas plus d'infos intéressante a donner, rien sur l'utilisation si ce n'est les choses suivantes :

Le multimètre à une entrée 3.3V, un 6V, une +16, une -16, une -16/+16 (soit 32V), et une 24 V. ça c'est pour les entrée en tension. Ils me demandent pour le moment de m'occuper juste de ça et on verra pour la suite après.

J'utilise donc le logiciel IDE Arduino 1.7.10 car il est le seul a avoir les fonctions de l'arduino Due. Mon arduino due dispose de ceci comme processeur : "The Arduino Due is a microcontroller board based on the Atmel SAM3X8E ARM Cortex-M3 CPU" un peut plus d'info : 54 entrées/sorties digitales, 12 entrées analogiques, 4 UARTs et 2 sorties analogiques.

Je me sert des entrées analogiques pour récupérer une tension qui sera adapté en 3.3 V quand avant d'arriver sur la carte, sinon elle fume. Donc en gros :

Je récupère une tension en 3.3V, je doit l'analyser, la convertir en bonne tension (selon l'entrée utilisée) et ensuite ajouter un coefficient de correction (je n'ai pas trop compris pourquoi mais ils m'ont dit que ce sera sous la forme ax²+bx ou ax^3+bx²+c).

Pour le moment j'ai fais fonctionner ceci sur une entrée, j'ai un potentiomètre connecté au 3.3 et a la masse de la carte, et qui a sa sortie sur A0 pour mes test.
Dans mon programme, j'imagine que la tension est de 6V (alors qu'actuellement elle est en 3.3) j'ai donc le programme suivant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 const int AI_A0 = A0; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A1 = A1; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A2 = A2; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A3 = A3; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A4 = A4; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A5 = A5; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A6 = A6; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A7 = A7; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A8 = A8; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A9 = A9; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A10 = A10; // PIN d'entrée analogique sur le quel est attaché le potentiomètre const int AI_A11 = A11; // PIN d'entrée analogique sur le quel est attaché le potentiomètre int sensorValue = 0 ; //Déclaration d'une variable en INT float V_A0 = 0; //Déclaration d'une variable en flottante void setup() { **Serial.begin(9600); // Initialise la communication série à 9600 Bauds. } void loop() { ***analogReadResolution(12);*************************//règle la résolution sur 12 bits **//Lis les valeurs analogiques du port AO : **sensorValue*=*analogRead(AI_A0); //Donne à la variable les valeurs lue sur le port A0 **// Affiche les mesures sur le moniteur série **V_A0*=*sensorValue; **Serial.print("A0_HEXA = " ); //affiche "A0_HEXA=" **Serial.print(sensorValue,HEX); //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits) **Serial.print("\t A0_3.3V = "); //Affiche "VA0_3.3V =" **Serial.print(V_A0*(3.3/4096)); //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)); //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)); //Affiche la valeur de V_A0 en 6V + une correction **// Attendre 2 MS avant la prochaine boucle **// pour laisser le temps de convertir **// avant la prochaine lecture. **delay(2); ** }
des suggestions pour m'aider ?
J'aimerai faire une boucle qui fais ce que j'ai fais sur un port, sur tous les ports, sans faire un copier coller 11 fois afin que le programme ne soit pas trop lourd (même si la carte à une grosse capacité). Je n'ai pas trop d'idée de comment faire.. peut être avec un compteur qui incrémente jusqu'à 12 puis qui repart a zero histoire de tout checker.

Pour le moment pour voir les valeurs je me sert de la console de l'IDE. pas d'afficheur ni rien pour le moment.

Merci à vous !

08/06/2016, 10h50
Vincent PETIT

Salut,

Citation:

Envoyé par Alex34000

Le multimètre à une entrée 3.3V, un 6V, une +16, une -16, une -16/+16 (soit 32V), et une 24 V. ça c'est pour les entrée en tension. Ils me demandent pour le moment de m'occuper juste de ça et on verra pour la suite après.

Très bizarre ton multimètre !? C'est qui le fabricant ? Photo ?

Citation:

Envoyé par Alex34000

Je me sert des entrées analogiques pour récupérer une tension qui sera adapté en 3.3 V quand avant d'arriver sur la carte, sinon elle fume.

Si tu veux faire ça bien, je t'invite a regarder ton ADC de prés car (à quoi sert Vref par exemple ou quelle est l'impédance d'entrée) et pour qu'il soit efficace sur ses 12 bits, il faut que le signal mesuré atteigne la pleine échelle du convertisseur.
Sur le net, tu trouveras un nombre incroyable de tuto ou d'exemple où des personnes mesures quelques Volts avec un ADC 10 bits référencé sur le 5V :aie: En faisant ça l'ADC 10 bits n'est utilisé que sur ces 4 premiers bits, autrement dit c'est pas très judicieux. La vraie manière de faire, c'est d'amplifier le signal d'entrée pour qu'il atteigne la référence de l'ADC et comme ça tu utilises pleinement toute la résolution de l'ADC !

Citation:

Envoyé par Alex34000

Je récupère une tension en 3.3V, je doit l'analyser, la convertir en bonne tension (selon l'entrée utilisée) et ensuite ajouter un coefficient de correction (je n'ai pas trop compris pourquoi mais ils m'ont dit que ce sera sous la forme ax²+bx ou ax^3+bx²+c).

Ouais alors ça c'est bizarre car ça ne ressemble même pas a une compensation en température !? A éclaircir.

Citation:

Envoyé par Alex34000

des suggestions pour m'aider ?

Intéresse toi aux interruptions de ton micro (le Timer et l'ADC)
08/06/2016, 11h01
Alex34000

En fait si tu veux, ils ont un voltmètre/ampèremètre fais maison. Il reçoit différentes tension d'entrée et fais ses calculs pour sortir des valeurs avec une résolution 10 bits.

Le projet qu'ils m'ont donnés est de remplacer leurs carte qui est doté d'un PIC d'une résolution max de 10 bits, par une carte arduino Due qui a une résolution de 12 bits.

La carte ne supportant pas le 6V et +, la tension d'entrée est adapté à l'aide de pont diviseur pour qu'il y ai au lieu du 6V, du 3.3, ou 3, ou 2.5 V (ça reste à définir). On se retrouve donc par exemple en port A2 avec 3.3V au lieu de 6V. à l'aide de produit en croix j'adapte ma tension et ensuite, je l'affiche une première fois (tension adapté en 3.3 ou autre) puis une deuxième fois (Tension original donc ici le 6V pour l'exemple) et une troisième fois (Tension 6v + coefficient d'ajustement ou je ne sais quoi, c'est pas moi qui décide ^^').

Pour résumer j'ai une tension qui arrive de 3.3V, je sais que en vrai elle est censé être de 6V si elle arrive en 3.3 (donc si elle est a 2.5 a l'aide de mon produit en croix je connais sa valeur (qui sera inferieur à 6V)). Puis je l'affiche, avec une résolution de 12 bits, et je l'affiche encore avec leurs coefficient d'amélioration de mesure.

Est-ce plus clair ?

Et j'ai longuement chercher sur internet avant de venir ici ^^ je n'ai pas trouvé ce que je désire, c'est la raison de ma venue ici en tant que "novice" .
08/06/2016, 11h45
Vincent PETIT

Citation:

Envoyé par Alex34000

En fait si tu veux, ils ont un voltmètre/ampèremètre fais maison. Il reçoit différentes tension d'entrée et fais ses calculs pour sortir des valeurs avec une résolution 10 bits. [...] Le projet qu'ils m'ont donnés est de remplacer leurs carte qui est doté d'un PIC d'une résolution max de 10 bits, par une carte arduino Due qui a une résolution de 12 bits.

Ok pour le contexte.

Citation:

Envoyé par Alex34000

La carte ne supportant pas le 6V et +, la tension d'entrée est adapté à l'aide de pont diviseur pour qu'il y ai au lieu du 6V, du 3.3, ou 3, ou 2.5 V (ça reste à définir).

C'est en effet la bonne pratique et c'est là où il y a un premier piège. La formule d'un pont diviseur est valable à vide donc sans aucune charge dessus autrement dit lorsque tu ne tires aucun courant dessus.
A partir du moment où tu vas relier ton pont diviseur a ton ADC tu vas t'apercevoir que la formule n'est plus vraiment exacte et souvent les gens la compense dans le soft pour corriger le problème (problème hardware en réalité). Il se passe en réalité quelque chose de très simple : Ton ADC tire du courant car il n'a pas une impédance énorme en entrée et la formule du pont diviseur n'est plus exacte même en prenant de résistance de précision.

2- Solutions pour éviter de mesurer moins bien qu'avant

1) Regarder dans la datasheet qu'elle est l'impédance d'entrée de l'ADC ou alors qu'elle courant il demande et refaire le calcul du pont diviseur avec ces données.

2) Mettre un AOP câblé en suiveur entre la sortie du pont diviseur et l'ADC car un AOP a une impédance immense en entrée, il ne tire donc quasiment aucun courant dans le pont diviseur et il a assez de pêche pour fournir le courant que réclame l'entrée de l'ADC sans en être perturbé.

Citation:

Envoyé par Alex34000

On se retrouve donc par exemple en port A2 avec 3.3V au lieu de 6V. à l'aide de produit en croix j'adapte ma tension et ensuite, je l'affiche une première fois (tension adapté en 3.3 ou autre) puis une deuxième fois (Tension original donc ici le 6V pour l'exemple) et une troisième fois (Tension 6v + coefficient d'ajustement ou je ne sais quoi, c'est pas moi qui décide ^^').

Pour résumer j'ai une tension qui arrive de 3.3V, je sais que en vrai elle est censé être de 6V si elle arrive en 3.3 (donc si elle est a 2.5 a l'aide de mon produit en croix je connais sa valeur (qui sera inferieur à 6V)). Puis je l'affiche, avec une résolution de 12 bits, et je l'affiche encore avec leurs coefficient d'amélioration de mesure.

Je comprends, enfin je pense !
Tu as des armes en traitement du signal pour améliorer la mesure "et dégommer le PIC actuel", tu peux cadencer ton ADC avec un Timer pour qu'il prenne des mesures a intervalle régulier et tu pourras faire une moyenne de l'ensemble des valeurs mesurés (que tu auras mis dans un tableau). Afficher les Vmaxi et Vmini rencontré comme sur les appareils de mesure pros. Les delta entre Vmaxi et Vmini pour mesurer un bruit/ondulation résiduelle/ripple. Faire un calcul de valeur RMS au cas où le signal mesuré est sinusoïdale, donc une mesure en AC et pas en DC. Voir encore plus.... ce n'est que du calcul discret ensuite.

Citation:

Envoyé par Alex34000

Est-ce plus clair ?

Penche toi sur les interruptions avec ton micro ;) et gaffe à Vref de l'ADC surtout si tu as un AOP quelque part.
08/06/2016, 12h04
Alex34000

Citation:

2) Mettre un AOP câblé en suiveur entre la sortie du pont diviseur et l'ADC car un AOP a une impédance immense en entrée, il ne tire donc quasiment aucun courant dans le pont diviseur et il a assez de pêche pour fournir le courant que réclame l'entrée de l'ADC sans en être perturbé.

Je me suis renseigner sur les montages actuels, et en effet il y a des AOP donc cette solution me convient parfaitement, je n'y avais pas pensé ^^'.

Citation:

Tu as des armes en traitement du signal pour améliorer la mesure "et dégommer le PIC actuel", tu peux cadencer ton ADC avec un Timer pour qu'il prenne des mesures a intervalle régulier et tu pourras faire une moyenne de l'ensemble des valeurs mesurés (que tu auras mis dans un tableau). Afficher les Vmaxi et Vmini rencontré comme sur les appareils de mesure pros. Les delta entre Vmaxi et Vmini pour mesurer un bruit/ondulation résiduelle/ripple. Faire un calcul de valeur RMS au cas où le signal mesuré est sinusoïdale, donc une mesure en AC et pas en DC. Voir encore plus.... ce n'est que du calcul discret ensuite.

Très intéressant. De ce qui m'a été dit (je les ai contacter), il y a deux possibilité, faire une moyenne d'un ensemble de valeur, ou corriger un défaut grâce à cette fameuse formule. Tout dépend de la précision des résultat obtenue de base. Personnellement je trouve la moyenne plus simple à mettre en œuvre niveau programmation, même si je n'ai qu'une petite idée de comment faire...

Citation:

Penche toi sur les interruptions avec ton micro et gaffe à Vref de l'ADC surtout si tu as un AOP quelque part.

Les interruptions, OUI !! je pensais justement faire des relevés et au bout d'un certain nombre, interrompre, faire la moyenne, afficher, et recommencer.

Par contre je ne voie pas ce que tu veux me dire par rapport à Vref. (je suis peut être mal réveillé ^^')
08/06/2016, 17h13
Vincent PETIT

Citation:

Envoyé par Alex34000

Je me suis renseigner sur les montages actuels, et en effet il y a des AOP donc cette solution me convient parfaitement, je n'y avais pas pensé ^^'.

On peut faire quelque chose de très au point avec des AOP (si ils sont bien choisies et dimensionnés évidemment)

Citation:

Envoyé par Alex34000

Très intéressant. De ce qui m'a été dit (je les ai contacter), il y a deux possibilité, faire une moyenne d'un ensemble de valeur, ou corriger un défaut grâce à cette fameuse formule. Tout dépend de la précision des résultat obtenue de base. Personnellement je trouve la moyenne plus simple à mettre en œuvre niveau programmation, même si je n'ai qu'une petite idée de comment faire...

Je ne comprends pas trop cette équation. Peu être qu'on parle d'un filtre numérique, c'est possible, mais il y a d'autres manières de l'expliquer qu'une formule sans dire à quoi serve les a, b et c !!!

Citation:

Envoyé par Alex34000

Les interruptions, OUI !! je pensais justement faire des relevés et au bout d'un certain nombre, interrompre, faire la moyenne, afficher, et recommencer.

Voilà ! Tu as tout compris, il faut décorréler l'affichage, l'acquisition et le traitement/calcul
- acquisition + traitement/calcul => priorité 1 dans l'interruption
- affichage => priorité 2 donc dans le programme principal qui n'a pour rôle que d'afficher (sous entendu, si l'affichage est interrompu quelques millisecondes personne ne le verra par contre si c'était l'acquisition qui était interrompu alors ça voulait dire perte de données :aie:)

Citation:

Envoyé par Alex34000

Par contre je ne voie pas ce que tu veux me dire par rapport à Vref. (je suis peut être mal réveillé ^^')

C'est assez subtil.
Un ADC a souvent trois manières d'être référencé :

- VCC,
- Vref du micro,
- Une Vref externe que tu implantes a côté du micro.

Si tu te dis, allez je vais référencer mon ADC 12 bits a VCC qui vaudrait 3.3V.
:fleche: Cela implique que 1 bit = 3.3/((2^12)-1) = 800µV environ
:fleche: Mais cela est vrai si tu considères que ton +3.3V est hyper hyper stable ! En vrai c'est jamais le cas pire encore dès fois le 3.3V et moins stable que les 800µV eux mêmes alors il faut être conscient que tout bouge et varie au rythme de l'instabilité de l'alimentation.

Dans certain cas c'est très emmerdant car si toute l'électronique ainsi que l'ADC bouge légèrement et que tu mesures la tension d'une pile 1.5V par exemple et bien ton affichage n'est pas stable. L’électronique bouge au rythme de son alimentation mais la pile 1.5V, elle, est stable !

Par contre dans d'autre cas ce n'est pas grave du tout. Si ton ADC lit une sortie analogique d'un capteur, qui serait alimenté par le même 3.3V alors tout bouge et varie en même temps (si la tension est de 3.4V alors elle l'est tout autant sur le capteur que sur le micro donc rien ne gène)

Donc méfie toi de ce que tu vas mesurer.

Vref du micro est assez costaux pour alimenter des AOP par exemple. J'ai déjà fait ça sur certain de mes projets : un micro alimenté en 3.3V, son ADC référencé sur une Vref interne de 2.5V (hyper stable) et les AOP d'amplifications ou suiveur eux aussi alimentés par la Vref interne de 2.5V. J'ai donc stabilisé ma chaîne de mesure et même si mon 3.3V est tout pourri (genre alimentation a découpage avec des ondulations résiduelles de la mort) ça reste parfaitement stable !!!

Je ne sais pas si j'ai été clair avec cette histoire de Vref ?

Dac j'ai bien compris tout cela maintenant :)

Je me suis attaquer à la prog, j'ai donc réussis à faire des relevés sur les 12 ports (A0 à A11), à traiter les données sur une résolution de 12 bits, en prenant 100 valeurs (j'ai tester avec 3, 5, 10, 50, et 100 et ça reste fluide même si pour 100 valeurs le temps de traitement est limite) je pense que je resterai sur du 10-15 valeurs, puis j'en fais la moyenne et je l'affiche.

J'ai comparé les valeurs mesuré par ma carte en aillant branché un potentiomètre sur le port A0, alimenté par le port 3.3V de la carte et mis à la masse de la carte, à un multiètre portable type Fluke 175 true RMS multimeter.
Mes relevés sont plus précis que ce multimètre ! comment je le sais ? j'ai ensuite fais la comparaison avec un multimètre de table type Agilent 34401A et la, mes valeurs sont moins précises à 2-4 mv près. j'ai du régler dans mon programme la tension (à peut près) exact en sortie du 3.3 car la carte ne sort pas précisément 3.3V, mais plutôt du 3.3164 environ (variable à +- 10 mv).

Théoriquement je devrais être précis à 08.mv près et non 2mv...
Des idées d'où peut venir l'écart ?

Je vous montre mes programmes au cas ou (j'ai mit pas mal de choses en commentaire pour pouvoir les modifier si nécessaire ou les remettre si je faisais une erreur) :

Prog pour la moyenne (à adapter aux mesures sur tous les ports ) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
  // 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;
 
     }
 
 
    /*
    Serial.print("A0_HEXA = " );                       //affiche "A0_HEXA="
    Serial.print(sensorValue,HEX);                     //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.3/4096));                     //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));                     //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));           //Affiche la valeur de V_A0 en 6V + une correction
    */
 
    // 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
  }

Programme pour tous les ports (pour celui ci, j'ai mit les autres ports en commentaire car j'ai rajouter une possibilité de valider un test rien qu'en indiquant la tolérance voulu sur la valeur désiré (ex on veux du 2.7V à +- 0.1V près, on entre ces deux données et ça nous dit si c'est OK ou NOK) ) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
/****************************************************
*****************************************************
     !! TOLERANCE A INDIQUER MANUELLEMENT !!
*****************************************************
*****************************************************/ 
 
  float Tol_Min = 0.3;    float Tol_Max = 0.3;           // Tolérances à modifier manuellement
 
  float TA0 = 0;                                         // Variable sans la tolérance à tester
  float Tol_A0 =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 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
//******************************************
 
  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);
  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 
  // Serial.println(((V_A0*(6.0/4096))+0.1),4);                                                   //la précision).
  if(TA0 > Tol_A0 + Tol_Max || TA0 < Tol_A0 - Tol_Min )
  {  Serial.println("\t N_OK "); }
  else 
  { Serial.println("\t OK ");}
 
 
// *****************************************
//      Port A1
//******************************************
  /* 
  sensorValue_A1 = analogRead(AI_A1);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A1 = sensorValue_A1;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A1_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A1,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A1_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A1*(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 A1_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A1*(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 A1_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A1*(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).
// *****************************************
//      Port A2
//******************************************
   
  sensorValue_A2 = analogRead(AI_A2);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A2 = sensorValue_A2;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A2_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A2,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A2_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A2*(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 A2_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A2*(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 A2_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A2*(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).
// *****************************************
//      Port A3
//******************************************
   
  sensorValue_A3 = analogRead(AI_A3);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A3 = sensorValue_A3;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A3_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A3,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A3_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A3*(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 A3_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A3*(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 A3_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A3*(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).
// *****************************************
//      Port A4
//******************************************
   
  sensorValue_A4 = analogRead(AI_A4);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A4 = sensorValue_A4;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A4_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A4,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A4_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A4*(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 A4_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A4*(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 A4_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A4*(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).
// *****************************************
//      Port A5
//******************************************
   
  sensorValue_A5 = analogRead(AI_A5);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A5 = sensorValue_A5;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A5_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A5,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A5_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A5*(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 A5_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A5*(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 A5_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A5*(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).
// *****************************************
//      Port A6
//******************************************
   
  sensorValue_A6 = analogRead(AI_A6);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A6 = sensorValue_A6;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A6_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A6,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A6_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A6*(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 A6_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A6*(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 A6_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A6*(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).
// *****************************************
//      Port A7
//******************************************
   
  sensorValue_A7 = analogRead(AI_A7);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A7 = sensorValue_A7;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A7_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A7,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A7_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A7*(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 A7_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A7*(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 A7_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A7*(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).
// *****************************************
//      Port A8
//******************************************
   
  sensorValue_A8 = analogRead(AI_A8);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A8 = sensorValue_A8;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A8_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A8,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A8_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A8*(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 A8_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A8*(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 A8_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A8*(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).
// *****************************************
//      Port A9
//******************************************
   
  sensorValue_A9 = analogRead(AI_A9);                //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A9 = sensorValue_A9;                             //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A9_HEXA = " );                       //affiche "A0_HEXA="
  Serial.print(sensorValue_A9,HEX);                  //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A9_3.3V = ");                   //Affiche "VA0_3.3V ="
  Serial.print(V_A9*(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 A9_6V = ");                       //Affiche "VA0_6V = "
  Serial.print(V_A9*(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 A9_6V_Corr = ");                //Affiche "A0_6V_corr = "
  Serial.println(((V_A9*(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).
// *****************************************
//      Port A10
//******************************************
   
  sensorValue_A10 = analogRead(AI_A10);              //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A10 = sensorValue_A10;                           //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A10_HEXA = " );                      //affiche "A0_HEXA="
  Serial.print(sensorValue_A10,HEX);                 //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A10_3.3V = ");                  //Affiche "VA0_3.3V ="
  Serial.print(V_A10*(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 A10_6V = ");                      //Affiche "VA0_6V = "
  Serial.print(V_A10*(6.0/4096),4);                  //Affiche la valeur de V_A0 en 6V (le nb après la "," augmente la précision).
  Serial.print("\t A10_6V_Corr = ");               //Affiche "A0_6V_corr = "
  Serial.println(((V_A10*(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).
// *****************************************
//      Port A11
//******************************************
   
  sensorValue_A11 = analogRead(AI_A11);              //Lis les valeurs analogiques du port AO et donne ces valeurs à sensorValue
 
 
  V_A11 = sensorValue_A11;                           //Incrémente sensorValue dans la variale V_A0 
  Serial.print("A11_HEXA = " );                      //affiche "A0_HEXA="
  Serial.print(sensorValue_A11,HEX);                 //Affiche la valeur actuel du potentiomètre (sur une résolution de 12 bits)
  Serial.print("\t\t A11_3.3V = ");                  //Affiche "VA0_3.3V ="
  Serial.print(V_A11*(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 A11_6V = ");                      //Affiche "VA0_6V = "
  Serial.print(V_A11*(6.0/4096),4);                  //Affiche la valeur de V_A0 en 6V (le nb après la "," augmente la précision).
  Serial.print("\t A11_6V_Corr = ");               //Affiche "A0_6V_corr = "
  Serial.println(((V_A11*(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).
  
*/
  delay(1);                                          //Attente de 2MS pour laisser le temps de convertir et de traiter les datas
}

09/06/2016, 16h04
Vincent PETIT

Pour répondre a tes questions.

:koi: tu es plus précis qu'un Fluke 175 ? C'est bizarre car il a une résolution de 100µV (8x mieux que ton micro si tu le références au 3.3V) ! Il faut voir combien de chiffres après la virgule sont réellement fiable (le Agilent te le dira) et fait attention avec tout ce qui est multimètre true RMS car "RMS" est un type de calcul que ton micro ne fait pas, donc la comparaison est plus compliqué.

Être aussi précis qu'un Agilent 34401A c'est presque mission impossible ! Ils utilises des techniques faible bruit hautement pointu.
Dans mon labo j'avais ces matériels (Fluke, Agilent, Keithley, TTI, etc...) entre autres.

Dans le soft je vois une erreur : V_A0*(3.3/4096)
C'est V_A0*(3.3/4095)

:fleche: Quelle est la valeur de Vref sur ton micro ?
:fleche: Si tu es référencé par rapport a une Vref stable, tu auras bien 1 bit = (Vref/4095)
:fleche: Des points a vérifier : Attention car il me semble que faire une somme de variable int / 100 va tronquer le résultat ! Tu joues avec des conversions de type méfiance.