lecture de tension/ analogic pin

Bonjour à tous, je rencontre un petit probleme avec l’arduino et j’espere que vous pourrez y répondre.
J’aimerais juste lire une tension que j’envoie sur le pin A1 ( ou autre pin analogique ) (petite partie d’un projet plus conséquent).
Par exemple, j’envoie 4.43 volt en entrée de l’arduino (vérifié au voltmètre) cependant je lis 4.50V (sur un écran LCD snootlab) avec l’aruino alimenté en USB et 4.45 avec une alimentation externe. (Il n’y a absolument rien entre la tension que j’applique et l’arduino).
Mes deux question sont : -Pourquoi est-ce que je lis une tension diférente (Sachant, après de nombreux test que cela ne viens pas de mon circuit ou autre mais bien de l’arduino)?
-Pourquoi la valeur change en fonction du mode d’alimentation de mon arduino ?
Pour tester, j’affiche meme le nombre de bit de la tension lue et c’est le meme dans les deux cas.
J’ai besoin de valeurs super précises.
Je vous link le programme aussi, mais il y a pas mal de lignes qui ne serviront pas pour ce problème là.
En espérant que quelqu’un ai déja rencotré ce probleme, je vous remercie et vous souhaite une bonne journée.

// include the library code:
#include “Wire.h”
#include <Deuligne.h>

// initialize the library with the numbers of the interface pins
Deuligne lcd;

// variables
int analogInput = 1;
int refresh = 1000;
float vout = 0.0;
float vin = 0.0;
float P = 0.0;
float R1 = 1000.0; // !! resistance of R1 !!
float R2 = 1000.0; // !! resistance of R2 !!

// variable to store the value
int value = 0;

// function to print float scientific version

char * float2s(float f)
{
return float2s(f, 2);
}

char * float2s(float f, unsigned int digits)
{
int index = 0;
static char s[16]; // buffer to build string representation
// handle sign
if (f < 0.0)
{
s[index++] = ‘-’;
f = -f;
}
// handle infinite values
if (isinf(f))
{
strcpy(&s[index], “INF”);
return s;
}
// handle Not a Number
if (isnan(f))
{
strcpy(&s[index], “NaN”);
return s;
}

// max digits
if (digits > 6) digits = 6;
long multiplier = pow(10, digits); // fix int => long

int exponent = int(log10(f));
float g = f / pow(10, exponent);
if ((g < 1.0) && (g != 0.0))
{
g *= 10;
exponent–;
}

long whole = long(g); // single digit
long part = long((g-whole)*multiplier); // # digits
char format[16];
sprintf(format, “%%ld.%%0%dld E%%+d”, digits);
sprintf(&s[index], format, whole, part, exponent);

return s;
}

void setup() {

// declaration of pin modes
pinMode(analogInput, INPUT);
Serial.begin(9600);
// set up the LCD’s number of columns and rows:
lcd.init();

// Print a message to the LCD.
// lcd.print(“PRESSION (mbar):”);
}

void loop() {

// read the value on analog input
value = analogRead(analogInput);
lcd.print(value);

// print result over the serial port
vout = (value * 5.0) / 1024.0;

lcd.setCursor(10,0);
lcd.print(vout);

vin = vout / (R2/(R1+R2));
P = pow(10.0,(vin - 6.0));

// set the cursor to column 4, line 1

lcd.setCursor(4,1);
lcd.print(float2s(P, 1));

// sleep…
delay(refresh);

}

scootapy: Bonjour à tous, je rencontre un petit probleme avec l'arduino et j'espere que vous pourrez y répondre. J'aimerais juste lire une tension que j'envoie sur le pin A1 ( ou autre pin analogique ) (petite partie d'un projet plus conséquent). Par exemple, j'envoie 4.43 volt en entrée de l'arduino (vérifié au voltmètre) cependant je lis 4.50V (sur un écran LCD snootlab) avec l'aruino alimenté en USB et 4.45 avec une alimentation externe.

Bonjour c'est simplement parce Vref en standard est dérivé du "5V" delivré par le regulateur ou le "5V" delivré par l'USB

edit pour eviter ambiguité : Vref (Voltage reference) = pin AREF (Analogic REFerence) chez arduino

dans les deux cas c'est à peu prés un 5V et c'est ce 5V +/- l'à peu prés qui est utilisé en Vref , pour la demonstration entre 4,9V et 5,1 V divisée par 1024 qui devient le pas de reference.

Si vraiment tu a besoin d'une precision importante sur l'echelle , il faut passer par une reference de tension externe. personnellement j'utilise souvent des petites Vref en TO92 de 4.096V ce qui est facile à traiter ensuite en ^2

on en apprend tout les jours, merci Artouste pour cette précision, je crois que le manque de précision de mon LMxx était donc due à ça ^^ à retenir merci =)

Skizo !

OK ! donc si j'ai bien compris, mon érreur est due à la ligne de code " Vout=(value * 5 / 1024) " parcequ'en fait, l'arduino ne sort pas du 5V pure ? Mais au lieu d'ajouter un composant, on ne peut pas juste mettre dans la ligne de code à la place du "5" le nom du pin qui sert de référence ? Du coup, ça changerait en fonction du type d'alim et cela serait parfait $) PS : je débute en arduino donc je ne connait pas encore toutes les possibilité de la machine :) Je te remercie déja pour ta réponse :)

parcequ’en fait, l’arduino ne sort pas du 5V pur

Pas tout à fait : ce n’est pas l’arduino qui fourni le 5V c’est toi. Tu le fais généralement par la prise USB.
L’USB est gérée par une norme qui entre autre défini la précision du 5V, (5V +/- 5% si je me rappelle).
L’arduino se contente de diviser la tension d’alimentation que tu lui fourni par 1024.

Si tu as besoin de précision la seule solution viable est celle fourni par Artouste qui est d’utiliser une référence de tension externe, il n’y a que comme cela que tu t’affranchira des inévitables variations de tension d’alimentation.

A la différence des régulateurs de tension, la référence de tension ne fourni qu’un courant très faible qui ne peut servir qu’à polariser une entrée de circuit intégré, il n’est pas possible d’alimenter un autre composant avec.
Par contre elle délivre une tension extrêmement précise et stable (indépendante de la température et de sa propre alimentation).

N'oublions pas l'existence de la référence interne 1.1V qui est précise (je n'ai pas retrouvé la précision) Mais l'utiliser signifie limiter la plage d'entrée de l'ADC entre 0 et 1.1V Pour mesurer des tensions plus grandes, il faudra donc prévoir un pont diviseur de résistances en amont, résistance de précision (1% ou moins) si on veut garder la précision originelle.

Sauf que si tu as une référence à 0,1% et que tu fais un pont diviseur par 10 tu te retrouves au final avec une précision de 1%.
La solution à 4,092V d’Artouste est préférable pour des tensions <= à 4V