BANDGAPREF 14

http://sites.prenninger.com/arduino-uno-r3/bandgapref-14

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-11-08

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************





           Referenzspannung Aref

Wenn es darum geht, Spannungen zu messen, wird der Analog-/Digital-Wandler (kurz: A/D-Wandler) oder englisch Analog Digital Converter (ADC) benutzt. Er konvertiert eine elektrische Spannung in eine Digitalzahl. Prinzipiell wird dabei die Messspannung mit einer Referenzspannung verglichen. Die Zahl drückt daher das Verhältnis der Messspannung zu dieser Referenzspannung aus. Sie kann in gewohnter Weise von einem Mikrocontroller weiterverarbeitet werden.


Beschaltung Aref

Interne Referenzspannung

Mittels Konfigurationsregister können beim ATmega8 verschiedene Referenzspannungen eingestellt werden. Dies umfasst die Versorgungsspannung AVcc sowie eine vom AVR bereitgestellte Spannung von 2,56V (bzw. bei den neueren AVRs 1,1V, wie z. B. beim ATtiny13, ATmega48, 88, 168, ...). In beiden Fällen wird an den AREF-Pin des Prozessors ein Kondensator von 100nF als Minimalbeschaltung nach Masse angeschlossen, um die Spannung zu puffern/glätten. Es ist jedoch zu beachten, dass die interne Referenzspannung ca. +/-10% vom Nominalwert abweichen kann, vgl. dazu das Datenblatt Abschnitt ADC Characteristics VINT (z. B. ATmega8: 2,3-2,9V, ATmega324P: 2,33-2,79V bzw. 1,0-1,2V "Values are guidelines only."). Die typische Abweichung der internen Referenzspannung vom Sollwert bei einigen AVR-Controllern wird in dieser Testschaltung exemplarisch untersucht.

Externe Referenzspannung

Wird eine externe Referenz verwendet, so wird diese an AREF angeschlossen. Aber aufgepasst! Wenn eine Referenz in Höhe der Versorgungsspannung benutzt werden soll, so ist es besser, dies über die interne Referenz zu tun. Außer bei anderen Spannungen als 5V bzw. 2,56V gibt es eigentlich keinen Grund, an AREF eine Spannungsquelle anzuschließen. In Standardanwendungen fährt man immer besser, wenn die interne Referenzspannung mit einem Kondensator an AREF benutzt wird. Die 10µH-Spule L1 kann man meist auch durch einen 47Ω-Widerstand ersetzen.


Quelle:
https://www.mikrocontroller.net/articles/AVR-Tutorial:_ADC




*********************************************************



704_d_ARDUINO-x_Arduino UNO - Tutorial Generelles - Marvin Baral (19 Seiten)_1a.pdf

http://jeelabs.org/2012/05/04/measuring-vcc-via-the-bandgap/


Analog-/Digital-Wandler (kurz: A/D-Wandler) oder englisch Analog Digital Converter (ADC)
Die ADC-Versorgungsspannung (AVcc) darf maximal um +/-0,3V von der Versorgung des Digitalteils (Vcc) abweichen, jedoch nicht 5,5V überschreiten.
Die externe Referenzspannung Vref darf nicht kleiner als die im Datenblatt unter ADC Characteristics als VREFmin angegebene Spannung
z. B. ATmega328: 1,023V und nicht größer als AVcc sein

Ub = Vcc messen über die Bandlücke (bandgap)

ARDUINO UNO Betriebspannung testet   mit der internen 1,1V Referenz (Reference = Internal).

Der ATmega328P hat einen 10-bit ADC.
Diese ADCs sind ratiometrische, dh. sie beziehen sich auf die analoge Referenzspannung (in der Regel Vcc)

Auf einem 5V ARDUINO, bedeutet dies dass Sie 0..5V als 0 ..1023 messen oder rund 5mV pro Schritt.

Auf einem 3,3V Arduino, sind die Messwerte von 0 bis 3,3V (0 ..1023) oder ungefähr 3,3 mV pro Schritt.

Es hat keinen Sinn  Ub = Vcc mit einen analogen Eingang zu verbinden
um diesen zu messen,
das funktioniert nicht da der ausgelesene ADC-Wert immer 1023 sein wird egal ob Ub=4,5V oder 5,5V
.
http://www.mikrocontroller.net/articles/AVR-Tutorial:_ADC

Wie können wir herausfinden, welche Spannung in Verwendung ist?
Dies würde
sehr nützlich sein, wenn man  Batterien zum Betrieb des Boardes verwendet.

Nun es gibt aber auch eine "bandgap referenz" in jedem ATmega / ATtiny, die im Wesentlichen eine 1,1V-Spannungsreferenz ist.
(min.1,0V, tatsächlich1,05, default 1,1, max.1,2V)

Wenn wir diesen Wert in Bezug auf unsere Ub = Vcc lesen, dann wird ein wenig Mathematik das Restliche tun:

Angenommen, wir lesen einen ADC-Wert von "x" aus, dieser representiert ca.1,1V,
mit 5V als Vcc, würde dieser Wert (x) rund 1100 / 5000 * 1023 = 225 sein.
während bei 3,3V als Vcc, würden wir einen Messwert von 1100 / 3300 * 1023 = 341 erhalten.
                               x     = 1100 / 1023 * Vcc
                               Vcc = 1100 / x * 1023


Also alles, was wir tun müssen, ist die 1.1V Bandgap-Referenzspannung zu messen und daraus können wir ableiten, was Vcc war.


Leider unterstützt dies 
ARDUINO analogRead ()  nicht
,
daher habe ich
diesen Bandlücke (bandgap)  Demo Sketch gemacht !



// Sketch: ARDUINO-IDE Geheimkanal_14_3a.ino
/// @dir bandgap
// Lesen der Bandgap-Referenzspannung um die aktuellen Vcc-Spannung indirekt zu messen.
// Ub = Vcc = 5,001 mit Multimeter gemessen


static int vccRead (byte us =250) {
  analogRead(6);            // einrichten der beinah richtige ADC Auslese
  bitSet(ADMUX, 3);         // fixieren dann wechseln auf Kanal 14
  delayMicroseconds(us);    // verzögerung wesentlich verbessert Genauigkeit
  bitSet(ADCSRA, ADSC);
  while (bit_is_set(ADCSRA, ADSC));

  word x = ADC;
  return x ? (1071L * 1023) / x : -1;    // 1000L..1100L..1200L der tatsächlichen mit Multimeter gemessenen Vcc-Spannung anpassen.
}

void setup(void) {
  Serial.begin(9600);
  Serial.println("\n                   [bandgap-referenz]");
}

void loop() {

  analogRead(0);                         // nur um zu überprüfen, daß dieser AE0 keinen keinen Einfluß nimmt
  int pin_0_Reading = analogRead(0);
  Serial.print("Wert-AE0 = ");
  Serial.print(pin_0_Reading); 
  delay(1000); 

  Serial.print("    falsch = ");
  Serial.print(vccRead());     // erster Wert ist falsch
  Serial.print("    korrekt = ");
  Serial.print(vccRead());
  Serial.println(" mV");
  delay(2000);                           // 2 Sek. Wartezeit
  
}

https://github.com/netik/jeenode-roommon/blob/master/arduino/jeelib/examples/Ports/bandgap/bandgap.ino

Beispielausgabe, für das von mir verwendete ADRUINO UNO Board
mit Multimeter gemessen Ub = Vcc 5,001V  und
1,071V Spannungsreferenz

[bandgap]
5002

5002
5002

5002
5002
5002

Es gibt eine Verzögerung bei der vccRead () Code, der zur Stabilisierung der Messung hilft.
Hier steht, was
bei vccRead(10)  passiert  - also 10us Verzögerung anstelle der Standard 250us:

Laut Datenblatt 250 s ist übertrieben?
TBG Bandgap-Referenzanlaufzeitstart - up time: VCC = 2,7 TA = 25 °C    typisch = 40μs   max = 70us

 IOW, ist die Bandlücke Genauigkeit nicht groß - wie in dem Datenblatt, das 1,0 .. 1,2V bei 25 °C, wenn Vcc 2,7V
spezifiziert.
Beachten Sie auch,
dass die Bandgap-Referenz  70us
braucht um zu starten, so kann es nicht sofort einsetzbar sein, wenn kommen aus einem Power-Down-Zustand.

[bandgap]
3788
3606
3549
3538
3538
3538
3549
3561
3572
3572
3583

Bei nur 10us entstehen ganz unterschiedliche Werte wie man OBEN sehen kann
Dennoch könnte dies eine hervorragende Möglichkeit sein, Unterspannungen anzuzeigen, bevor einem ATmega oder ATtiny beginnt die Puste auszugehen.

http://jeelabs.org/?s=bandgap
http://jeelabs.org/2012/05/12/improved-vcc-measurement/
http://jeelabs.org/2012/05/04/measuring-vcc-via-the-bandgap/



***************
Arduino Bandgap Reference
 "14" ist die korrekte ADMUX Wert, um die interne Bandgap-Spannung,
aber die
Arduino analogRead()  Funktion ermöglicht keinen Zugriff mehr auf diesen Kanal-14


// Get the Vin see pin(14) on datasheet  ACHTUNG funktioniert nicht
// interner Bandgap-Referenz
// ARDUINO_IDE_Geheimkanal_14_geht_nicht_1a.ino


int reference;  // Stores Refrence val
float BGV, Vin;


void setup()
{
Serial.begin(9600);
}


void loop(){
// ACHTUNG analogRead(14); ist gleich analogRead(0);
// der Geheimkanal 14 kann mit analogRead(14); NICHT gelesen werden
reference = analogRead(14);   // 1.1Volts mit Multimeter 1,071
//reference = analogRead(0);   // Analog-Eingang 0 = pin-A0
Vin = (1.071/reference)*1023; // Convert to Vin
BGV = (Vin/1023)*reference;

Serial.print("  reference = ");
Serial.print(reference);
Serial.print("   Vin = ");
Serial.print(Vin);
Serial.print(" BGV = ");
Serial.println(BGV);

delay(2500); // 2,5sec Wartezeit
}




***************
Einführung
Beim Arduino ATmega168 und ATmega328 kann man die Betriebsspannung Ub in mV über die interne 1,1V Ref.-Spannung messen.

Denken Sie daran, dass die ständige ...
Ergebnis = 1091000L  / Ergebnis;    AVcc in mV wird daraus zuruckberechnet.
Ref-intern von Prozessor zu Prozessor unterschiedlich mit Multimeter bestimmen  (1,0V = 1126400L   1,092V = 1092000L  1,2V = 1200000L)
Wenn mann eine genaue Vcc Wert benötigen, muss man die aktuellen Bandgap-Spannung vom Prozessor bestimmen.

http://code.google.com/p/tinkerit/wiki/SecretVoltmeter


Test-Sketch
 
Geheimkanal C14   1,1V Bandgape
// Die Spannung wird in Millivolt ausgegeben. Also 5V = 5000mV, 3300mV ist 3.3V.
// ARDUINO_IDE_Geheimkanal_14_Bandgape_ref_1b.ino

long readVcc() {
  long result;   // 1,1V lesen Referenz gegen AVcc
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  delay(2); // 2ms warten bis Vref lesebereit
  ADCSRA |= _BV(ADSC); // konvertieren
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  result = 1092000L / result; // int.-Ref 1,092V auf AVcc (in mV) hoch rechnen.
  return result;
}


void setup() {
  Serial.begin(9600);
  Serial.println("Wert-AE0 = WERT   int-Ref hochgerechnet Ub");
}


void loop() {
  analogRead(0);                         // Analog Eingang pin-A0 einlesen
  int pin_0_Reading = analogRead(0);
  Serial.print("Wert-AE0 = ");
  Serial.print(pin_0_Reading); 
  delay(1000);  
  Serial.print("   readVcc = ");
  Serial.println( readVcc(), DEC );
  delay(2500);
}


Die Spannung wird in Millivolt ausgegeben. Also 5000 ist 5V, 3300 ist 3.3V.
Beachten Sie Folgendes:
Dies funktioniert nur auf einem ARDUINO mit einem ATmega328 oder ATmega168.

Wie es funktioniert
Das ARDUINO ATmega328 und ATmega168 haben eine Präzisionsspannungsreferenz von 1,1V eingebaut.
Dies wird manchmal für Präzisionsmessungen verwendet, in der Regel aber gegen Vcc = 5V  gemessen wird.
Der uC besitzt einen internen Schalter (Kanal-14), welcher Pins des Analog-Digital-Wandler auswählt.
Das Software-Schalter hat ein paar frei gebliebenen Verbindungen. Einer dieser Signale ist, die interne Referenz von 1,1V.
Wir messen, wie groß die bekannten 1,1V Referenz  im Vergleich zu Vcc ist, nun können wir hochrechnen, was Vcc ist.

https://code.google.com/p/tinkerit/wiki/SecretVoltmeter




siehe auch das interne Thermometer im ARDUINO UNO  ATmega328P


https://code.google.com/p/tinkerit/wiki/SecretThermometer

Einführung

Der uC des  ARDUINO UNO  ATmega328p  hat einen eingebautem Temperatur-Sensor.
Nicht aber die alten ATmega8 oder ATmega168 (aber mit ATmega168P und ATmega328P).
Auch nicht der ARDUINO Mega.


Test-Sketch  Geheimkanal C8   interner Temperatur-sensor
-  funktioniert nur auf einem Arduino mit einem ATmega328 Chip.

// Die Temperatur wird in hundertstel GradC ausgegeben. Also 22,0 gradC = 2200
//ARDUINO_IDE_Geheimkanal_8_interner_Temp._Sensor_1a.ino

long readTemp() {
  long result;
      // internen Temperatur-Sensor gegen 1,1V Referenz lesen
  ADMUX = _BV(REFS1) | _BV(REFS0) | _BV(MUX3);
  delay(2);                // 2ms warten bis Vref abgesetzt
  ADCSRA |= _BV(ADSC);     // konvertieren
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  result = (result - 126) * 1075; // 126 = pi x Daumen - internen Temp-Sensor hoch rechnen
  return result;
}

void setup() {
  Serial.begin(9600);
  Serial.println("Wert-AE0 = WERT   read int.-Temp");
  Serial.println(" - - - - - - - - - - - - - - - -");
}



void loop() {
  analogRead(0);                         // Analog Eingang pin-A0 einlesen
  int pin_0_Reading = analogRead(0);
  Serial.print("Wert-AE0 = ");
  Serial.print(pin_0_Reading); 
  delay(1000);  
  Serial.print("   readTemp = ");
  Serial.println( readTemp(), DEC );     // Wert des int-Temp-Sensors in milli°C
  delay(2500);
}


Die Temperatur wird in hundertstel °C  ausgegeben. 2500 = 25 °C.
Wie es funktioniert
Der Chip besitzt einen internen Schalter, welcher die pin's der Analog-Digital-Wandler  auswählt.
Das Schalter hat ein paar übrig gebliebenen Verbindungen. Einer dieser Signale ist, eine einfacher ungenauer eingebauter Temperatursensor.
Wenn man die Sensorspannung gegen die interne 1,1V Referenz vergleicht kann man die ungefähre uC-Temperatur berechnen.
Es erfordert ein  Herumspielen mit den Registern, aber es geht auf +/- 10 °C
Hinweise:
Der Sensor ist nicht sehr genau - das Datenblatt sagt ± 10 °C.
Aber wenn man einmal den herausgefundenen Offset mitberücksichtigt, verbessert sich die Genauigkeit erheblich.
Beachten Sie Folgendes:
Dies funktioniert nur auf Arduinos mit CPUs mit "8P" in der Teilenummer.
Für Standard-Arduinos ATmega168 und ATmega328 funktioniert es nicht.
Wenn Sie ein Arduino-Klon mit einem ATmega168P oder ATmega168PA haben, funktioniert dies auch..
Dieser Sensor ist ziemlich nutzlos, auch wenn Sie diesen mit einer bekannten Temperatur  kalibrieren.
Die Sensorausgänge in etwa 1 °C-Schritten.

https://code.google.com/p/tinkerit/wiki/SecretThermometer




*********************************************************
// Ein Sketch, um die tatsächliche Vcc Spannung des ATmega-IC zu erhalten, unter Verwendung interner Bandgap-Referenz.
// uC-Prozessoren Vcc Spannung und die Möglichkeit, A/D-Kalibrierung mit Vcc halten lesen.
// Für ATmega168 / ATmega328 und Mega-Boards.
// Der Sketch wird benötig, wenn beispielsweise eine Niederspannungsalarm notwendig ist.
// Analog-Eingang pin-A0 10k Spannungsteiler
// ARDUINO_IDE_Geheimkanal_14_NEU_1a.ino
int battVolts; void setup(void) {   Serial.begin(9600);   Serial.print("Anzeige in Volt X 100");   Serial.println( "\r\n\r\n" );   delay(100); } void loop(void) {   battVolts=getBandgap();  // die tatsächlichen Vcc, (X 100), basierend auf der gemessenen Bandabstands-Spannungs   Serial.print("Ub = Vcc (Volt) = ");   Serial.println(battVolts);   Serial.print("Analog pin-0 = ");   Serial.println(map(analogRead(0), 0, 1023, 0, battVolts));   Serial.println("- - - - - - - - - - -");   delay(2500); } int getBandgap(void) // gibt tatsächlichen Wert Vcc x 100 aus. { #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)   const long InternalReferenceVoltage = 1115L; // für Mega-Boards   // passen Sie diesen Wert auf Ihre Mega-Boards spezifischen internen BandGape Spannungs x1000   // REFS1 REFS0 --> 0 1, AVcc internen ref. - wählt AVcc Referenz   // MUX4 MUX3 MUX2 MUX1 MUX0 --> 11110 1.1V (VBG) - wählt Kanal 30, um die Bandgap-Spannung bei Mega-Boards zu messen   ADMUX = (0<<REFS1) | (1<<REFS0) | (0<<ADLAR)| (0<<MUX5) | (1<<MUX4) | (1<<MUX3) | (1<<MUX2) | (1<<MUX1) | (0<<MUX0); #else   // Für ATmega168 ATmega328 Boards   const long InternalReferenceVoltage = 1071L; // bei interener Bandgap-Referenz von 1,071V   // Wert auf die spezifische internen Bandgap-Referenz z.B. 1,071V x 1000 = 1071 anpassen.   // REFS1 REFS0 --> 0 1, AVcc internal reference -Selects AVcc external reference   // MUX3 MUX2 MUX1 MUX0 --> 1110 1.1V (VBG) -Wählt den Kanal 14, um die Bandgap-Spannung zu messen   ADMUX = (0<<REFS1) | (1<<REFS0) | (0<<ADLAR) | (1<<MUX3) | (1<<MUX2) | (1<<MUX1) | (0<<MUX0); #endif   delay(50); // 50ms Wartezeit, um eine stabilere A/D-Wandlung zu bekommen.   ADCSRA |= _BV( ADSC );  // Konvertierung starten.   while( ( (ADCSRA & (1<<ADSC)) != 0 ) ); // warten bis Wandlung abgeschlossen ist.    // Wert scalieren / Berechnung für geraden Wert   int results = (((InternalReferenceVoltage * 1023L) / ADC) + 5L) / 10L;   return results; }


*********************************************************
uC A/D-Wandler Referenz-Spannungen

analogReference(type) 

http://arduino.cc/en/pmwiki.php?n=Reference/AnalogReference

analogReference(DEFAULT); // die Referenzspannung ist die Betriebsspannung Ub (pin-Aref muß n.c. sein)
Reference = Avcc '5.0V
analogReference(EXTERNAL); // 0,5 bis 5,0V an pin-Aref (üblicherweise die vorh. 3,3V)
Reference =
analogReference(INTERNAL); // es wird die intern vorhandene Referenzspannung von 1,1V angelegt (pin-Aref muß n.c. sein)
Reference = Internal '1.1V

über 50V Lebensgefährliche Spannungen
Bei 50,0V / 1023 = 48,876mV Auflösung (10-bit) (Spannungsteiler 9k--1k unbedingt notwendig)
Bei 5,0V / 1023 = 4,887mV Auflösung
Bei 3,3V / 1023 = 3,226mV Auflösung
Bei 1,1V / 1023 = 1,075mV Auflösung



#define TEMPINT 8 BASCOM-AVR G = Getadc(8)
int refTempint = analogRead(TEMPINT) Deg = G - 338 (pi x Daumen)
(ADC Geheimkanal 8 erlaubt den internen Temperatursensor zu messen steigt 1mV/°C)
-45°C=242mV 0°C=288mV 25°C=314mV 85°C=380mV

#define BANDGAPREF 14
int refReading = analogRead(BANDGAPREF)
float supplyvoltage = (1.1*1023) /refReading; BASCOM-AVR D = Getadc(14) U = 1023/D*1.1
(ADC Geheimkanal 14 erlaubt die interne 1,1V Referenz zu messen)

#define Aref_voltage 3.30
#define bandgap_voltage 1.1

analogRead(BANDGAPREF);
int refReading=analogRead(BANDGAPREF);




Beschreibung
Konfiguriert die Referenzspannung für den Analogeingang verwendet (also die, wie oben in den Eingangsbereich verwendet Wert). Die Optionen sind:

DEFAULT: Die Standard-Analog-Referenz von 5 Volt (auf 5V Arduino-Boards) oder 3,3 Volt (auf 3,3 V  Arduino-Boards)
INTERNAL: eine integrierte Referenz, gleich 1,1 Volt auf den ATmega168 oder ATmega328 und 2,56 Volt auf dem ATmega8 (nicht auf dem Arduino Mega verfügbar)
INTERNAL1V1  : eine integrierte   1,1  V-Referenz (nur Arduino Mega)
INTERNAL2V56: eine eingebaute 2.56V Referenz (nur Arduino Mega)

EXTERNAL: die an pin-Aref  (0,5.. 5V) angelegte Spannung wird als Referenz verwendet.

Parameter
Typ: Folgende Arten von Referenzen gibt es  (STANDARD, INTERNAL, oder EXTERNAL).
Returns
Keine.
Hinweis
Nach der Änderung des analogen Referenz können die ersten Lesungen aus analogRead () nicht genau.
Warnung
Etwas weniger als 0V oder mehr als 5V nicht für externe Referenzspannung am pin-Aref.
Wenn Sie eine externe Referenz auf pin-Aref sind, müssen Sie die analogen Verweisen auf fremde vor dem Aufruf analogRead () ein.
Andernfalls werden Sie kurz zusammen die aktive Referenzspannung (intern erzeugt) und das pin-Aref, möglicherweise eine Beschädigung der Mikrocontroller auf Ihrem Arduino-Board.

Alternativ können Sie die externe Referenzspannung an den pin-Aref durch eine 5K Widerstand zu verbinden, so dass Sie zwischen externen und internen Referenzspannungen umschalten. Beachten Sie, dass der Widerstand die Spannung, die als die Referenz verwendet wird, weil es eine interne 32K Widerstand auf AREF Pin ändern. Die beiden wirken als Spannungsteiler, so beispielsweise 2,5 V angelegt wird durch den Widerstand 2.5 * 32 / (32 + 5) = ~ 2,2 V am pin-Aref ergeben.
Siehe auch

  - Beschreibung der analogen Eingangspins
  - analogRead ()
Referenz Startseite
Korrekturen, Anregungen und neue Dokumentation sollte in das Forum geschrieben werden.
Der Text der Arduino Referenz ist unter einer Creative Commons Attribution-ShareAlike 3.0 License.
Code-Beispiele in der Referenz werden in die Öffentlichkeit freigegeben.

http://arduino.cc/en/Reference/AnalogReference

*********************************************************

BUCH: Die elektronische Welt mit ARDUINO entdecken Seite 950

Analog-Monitoring


pin-IOref
Am pin-IOref liegt die aktuelle Referenzspannung an, mit der der Mikrocontroller arbeitet.

Es kann u. a. dazu genutzt werden, dass sich Shields dieser Spannung bedienen, um zu ermitteln, ob sie mit 3,3V oder 5,0V arbeiten müssen.
pin-Aref
Der pin-Aref wird für die Referenzspannung der analogen Eingänge verwendet.
Wenn der Mikrocontroller mit einer Spannung von 5V arbeitet, liegt die Genauigkeit bei einer 10-bit Auflösung bei ca. 4,88mV je Schritt.
Möchten sie z.B. einen Sensor verwenden, der lediglich 3,3V als Maximalwert liefert, bedeutet das einen Genauigkeitsverlust, denn die mögliche Bandbreite von 10-bit würde nicht ausgenutzt, um einen
Spannungsbereich von 0V bis 3,3V abzubilden.
Die analogRead-Funktion würde Werte von 0 bis 675 zurückliefern. Der Rest bis 1023 bliebe ungenutzt.
Doch zurück zu unserem pin-Aref.
Wenn wir diesen Pin mit der real anliegenden Spannung von pin-IOref versorgen würden, wäre diese Spannung die neue Referenzspannung für die analogen Eingänge und somit wäre das Problem der vermeintlich zu niedrigen Versorgungsspannung behoben.
Schauen wir uns dazu einen entsprechenden Sketch an.
Es muss vorausgeschickt werden, dass wir über die analogReference-Funktion mit dem EXTERNAL Argument dem Arduino mitteilen, nun eine externe Referenzspannung an pin-Aref anzulegen.

ACHTUNG:
Wenn eine externe Spannung am pin-ARef angelegt wird, darf sie sich nur im Bereich von 0V bis 5V bewegen!
Des Weiteren muss vor dem Aufruf der analogRead-Funktion die analoge Referenz über die Funktion analogReference(EXTERNAL) korrekt initialisiert werden.
Das verhindert, dass sich die intern generierte Spannung für den pin-Aref und die von außen angelegten Spannung am selben Pin nicht in die Quere kommen und so den

Mikrocontroller zerstören.


Sketch:

#define PAUSE 1000       // Pausenwert für die Anzeige

void setup() {
Serial.begin(9600);         // Serielle Schnittstelle initialisieren
while (!Serial);                // Auf den "Serial-Monitor" warten

// Wir beziehen uns jetzt auf den von pin-IOref gelieferten Wert
analogReference(EXTERNAL);
/*
Achtung: Der Aufruf der analogReference-Funktion muss über EXTERNAL
immer vor dem ersten Aufruf der analogRead-Funktion erfolgen!!!
Ansonsten kann der Mikrocontroller zerstört werden.
*/
}

void loop() {
Serial.println(analogRead(A0)); // Ausgabe des gemessenen Wertes
delay(PAUSE);                       // Kurze Pause


weitere Informationen zu den Themen
http://www.erik-bartmann.delarduino-projekt-kapitel-39.html




*********************************************************

analogReference(INTERNAL);

Laut ATmega328P Datenblatt Seite 323
ist Vref int typisch 1,1V und zwischen 1,0V und 1,2V.

Die Spannung ist nicht in jedem ATmega ganz gleich, aber konstant.
Die Versorgungsspannung 5V ändern sich je nach Spannungsquelle und kann schon mal an USB auch nur 4,5V betragen.
Die integrierten A/D-Wandler in Mikroprozessoren sind keine Präzions-Instrumente.
Daß man bei niedrigeren Spannung mehr Einfluss der Störungen hat ist klar.
Die normalen Messfehler von ADCs haben dann auch einen höheren Anteil am Ergebnis.
Und auf dem Arduino Board fehlen Schaltungs-Maßnahmen um das zu kompensieren, wie der LC-Filter an der ADC-Versorgungsspannung.
Es gibt in Software noch Möglichkeiten. Siehe Datenblatt "ADC Noise Canceler".
Man kann den Rest des Prozessors in den Schlaf-Modus versetzten und während dessen messen.
Dadurch strahlen andere Komponenten weniger in den ADC rein.Datenblat uC.

704_d_ATMEL-x_ATmega328P 8-bit Mikrocontroller mit 32K (448 Seiten) Datenblatt_1a.pdf
http://www.atmel.com/Images/doc8161.pdf



*********************************************************

Analog Monitoring 

Aref-pin
An diesen pin  liegt die Referenz Spannung für die 6. analogen Inputs an.
Er wird unter Verwendung der Funktion analogReference() genutzt.
IOref-pin
An diesem pin liegt die Referenzspannung an, mit welcher der Mikrocontroller arbeitet.
Ein korrekt konfiguriertes Shield kann die Spannung des IOref nutzen um die richtige Stromquelle auszuwählen oder die Spannungsregler schalten um die Outputs mit 5V oder 3.3V zu versorgen.
Vin-pin
An diesem pin liegt die Input Spannung des Arduino an, wenn eine externe Stromquelle genutzt wird
(anstatt der 5V einer USB Verbindung oder einer anderen regulierten Stromquelle).
Sie können an diesen pin Spannung anlegen oder, wenn eine externe Stromquelle mit der Strombuchse verbunden ist, Spannung abgreifen.


Der Aref-Pin wird für die Referenzspannung der analogen Eingänge verwendet.
Wenn der Mikrocontroller mit einer Spannung von 5V arbeitet, liegt die Genauigkeit bei einer 10bit Auflösung bei ca. 4,88mV je Schritt.
Möchten wir z.B. einen Sensor verwenden, der lediglich 3,3V als Maximalwert liefert, bedeutet das einen Genauigkeitsverlust, denn die mögliche Bandbreite von 10bit würde nicht ausgenutzt, um einen Spannungsbereich von 0V bis 3,3V abzubilden.
Die analogRead()  Funktion würde Werte von 0 bis 675 zurückliefern. Der Rest bis 1023 bliebe ungenutzt.
Doch zurück zu unserem Aref-pin.
Wenn wir diesen pin mit der real anliegenden Spannung von IOref versorgen würden, wäre diese Spannung die neue Referenzspannung für die analogen Eingänge und somit wäre das Problem der vermeintlich zu niedrigen Versorgungsspannung behoben.
Schauen wir uns dazu einen entsprechenden Sketch an.
Es muss vorausgeschickt werden, dass wir über die analogReference() Funktion mit dem EXTERNAL Argument dem Arduino mitteilen, nun eine externe Referenzspannung an Aref-pin anzulegen.
Achtung
Wenn eine externe Spannung am Aref-pin angelegt wird, darf sie sich nur im Bereich von 0V bis 5V bewegen!
Des Weiteren muss vor dem Aufruf der analogRead() Funktion die analoge Referenz über die Funktion analogReference(EXTERNAL) korrekt initialisiert werden.
Das verhindert, dass sich die intern generierte Spannung für den Aref-pin und die von außen angelegten Spannung am selben pin in die Quere kommen und so den Mikrocontroller zerstören.

Doch nun zum Sketch:


// ARDUINO_SD_Card_Datalogger_EXTERNAL_1a

#define PAUSE 1000 // Pausenwert für die Anzeige


void setup() {
  Serial.begin(9600);   // Serielle Schnittstelle initialisieren
  while (!Serial);	// Auf den Serial-Monitor warten
  // Wir beziehen uns jetzt auf den von IOREF gelieferten Wert 
  analogReference(EXTERNAL);
  /*
Achtung: Der Aufruf der analogReference-Funktion muss über EXTERNAL
   immer vor dem ersten Aufruf der analogRead-Funktion erfolgen!!! 
   Ansonsten kann der Mikrocontroller zerstört werden.
   */
}


void loop() {
  Serial.println(analogRead(A0)); // Ausgabe des gemessenen Wertes
  delay(PAUSE);                   // Kurze Pause
}


Auf der Internetseite unter dem Link
http://www.erik-bartmann.de/arduino-projekt-kapitel-39.html
finden Sie weitere Informationen zu den Themen.



*********************************************************

Hier zu meine Frage..
Ich habe in meinen Codes analogReference nicht verwendet, was für eine Spannung nimmt da der Arduino.?
Und wie muss man da die Auflösung rechnen (U/1024)??

sagen wir analogReference(DEFAULT);
da wir ja als Referenz die Speisespannung des Arduino gesetzt. Bei mir 5V dann
sensorwert = analogRead(sensor) / (5 / 1024)
stimmt das so??

oder sagen wir analogReference(INTERNAL);
da wir die interne Spannung des Arduino UNO gesetzt. UNO 1.1V
wie sieht es dann hier aus
sensorwert = analogRead(sensor) / (1.1 / 1024)
währe das so richtig??

als letztes analogReference(EXTERNAL);
da wir die Spannung des VREF Pins am Arduino UNO gesetzt. zB 3.3V
wie sieht es dann hier aus
sensorwert = analogRead(sensor) / (VREF / 1024)


*********************************************************
AD-Wandler  = Analog/Digital-Wandler  = ADC
In BASCOM wird ADC initialisiert mit

Config Adc = Single (eine Messung)  , Prescaller = 64 (Frequenzteiler 16MHz/64=250kHz) , Referenze = Avcc  (pin-Aref wird intern auf AVcc = Vcc = Ub = 5V gelegt, ACHTUNG pin-Aref darf extern nicht beschaltet sein.)
Config Adc = Free (fortlaufende Messungen)  , Prescaller = 32 (Frequenzteiler 16MHz/32=500kHz) , Referenze = Aref (die an pin-Aref angelegte externe Spannung ist die Referenz, z.B Referenz-IC)
Config Adc = Free  , Prescaller = 64 , Referenze = Internal  (die im uC intern vorhande 1,1V Referenz-Spannung wird an pin-Aref gelegt ACHTUNG pin-Aref darf extern nicht beschaltet sein.




Was bedeutet der Indikator BANDGAPREF 14


Der Geheimkanal Kanal 14 (ADC14 / C14) er erlaubt es die interne 1,1V Referenz zu messen.
BASCOM 
Referece = AVcc
Reference = Internal  ' die interne 1,1V Referenzspannung wird an pin-Aref gelegt
D = Getadc(14)  ' interne 1,1V Referenz an ADC Kanal14  mit Getadc(14) startet man eine Messung wird die internen Referenz-Spannung am internen Kanal C14 gemessen und weist den rohWert der Word-Variablen (auch Integer-Variable)  D zu (10bit 0..1023)
IDC
#define BANDGAPREF 14
analogReference(INTERNAL);

Geheimkanal Kanal 08 (ADC8 / C8) er erlaubt es den internen Temperatur-Sensor der an dem Kanal 8 des ADC liegt zu messen.
1 °C = ca. 1mV Anstieg
-45°C  242mV
 20 °C 309mV
 25°C  314mV
 85°C  380mV
Temperatur-Sensor-IC Genauigkeit nur 10°C daher immer selbst kalibrieren




Problem:
Ich lese den Geheimkanal 14, ich lese den Geheimkanal 8, ich lese den Kanal pin-A0 alle nacheinander aus.
Das Ergebnis, überall die gleichen Werte, immer gleich mit dem am pin-A0 ausgelesenen Wertes.
Das heißt rohWerte von 0 bis 1023
Hallo Herr Prenninger, ich habe etwas rumprobiert, das Problem konnte ich bestätigen.
Zuerst hatte ich einen Rechenfehler in BASCOM in Verdacht. Deshalb habe ich die Einstellungen für Hwstack, Swstack usw. eingefügt.
Keine Änderung. Dann fiel auf, dass auch bei der funktionierenden Variante der erste Wert noch nicht korrekt ist.
Neue Theorie: Das Messen von Kanal 14 schaltet die Referenz erst ein, andere Kanäle schalten sie wieder aus.
Und es wird jedesmal etwas Zeit benötigt, bis die Referenz voll da ist.
Von so einer Einschwingzeit steht auch etwas im Datenblatt.
Also muss man in diesem Fall den Kanal AD14 zweimal messen, einmal zum Einschalten der Referenz und dann nach einer kurzen Pause für die eigentliche Messung. 
Jetzt funktioniert es korrekt.
Ich werde es auch auf meiner Homepage und im Elektor-Forum erwähnen.

Vielen Dank für Ihre Fehlersuche!
Burkhard Kainka
mailto:B.Kainka@t-online.de




'----------------------------------------
'UNO_AD3b.BAS Vcc / 1.1 V
'----------------------------------------
$regfile = "m328pdef.dat"
$crystal = 16000000
$baud = 9600
$hwstack = 32
$swstack = 64
$framesize = 64


Dim D As Word
Dim E As Word
Dim U As Single
Dim V As Single

Config Adc = Single , Prescaler = 64 , Reference = Avcc ' 5,0V

Do
E = Getadc(0) 'int Ref off
V = E * 5.0
V = V / 1023
Print V ; " V"
Waitms 3000


D = Getadc(14) 'Ref on
Waitms 100
D = Getadc(14) 'Ref 1.1 V

U = 1023 / D
U = U * 1.1
Print "Vcc = ";
Print U ; " V"
Waitms 1000
Loop







Datenlogger-Prg. muß ich noch entsprechend ändern fritz
FEHLER noch enthalten.
  1. #include <SD.h>
  2. #include <Wire.h>
  3. #include "RTClib.h"
  4.  
  5. // Data logger for temperature and pressure data using the Adafruit
  6. // logger shield.
  7.  
  8. // Logging Interval (milliseconds)
  9. #define LOG_INTERVAL 60000
  10.  
  11. // Write Interval (milliseconds). How often to write data to the SD card
  12. // Writing every time would be better and prevent any data loss, but this
  13. // will use much less power. Power is indeed a concern for this setup
  14. #define WRITE_INTERVAL 600000
  15. uint32_t syncTime =0;
  16.  
  17. // Echo to serial settings. Turn on (1) for daignostics, but turn off (0)
  18. // before deploying to save power.
  19. #define SERIAL_DIAG 1
  20.  
  21. // Pin definitions - where we have things connected
  22. #define PressurePin 0
  23. #define TempPin 1
  24. #define ChipSel 10
  25. #define BANDGAPREF 14 FALSCH // special indicator that we want to measure

USW USW.



https://github.com/afeld/templogger/blob/master/lighttemplogger.pde

http://www.snip2code.com/Snippet/66961/Pressure-Temperature-Logger-for-Arduino-


*********************************************************



Step 5: Auto-calibrating supply-independent thermometer


I came up with an idea to use temperature sensor and leds to indicate the temperature value. I found LadyAda-s tutorial http://www.ladyada.net/learn/sensors/tmp36.html, and now i want to add leds, so that when the temperature is under 0 degrees the blue led is on, when the temp is over 0 degrees the green led is on and when it is over 20 degrees the red led is on. Actually I have no idea, how to integrate leds to the temperature code. Maybe someone here can help..


This example is similar to the one above except that now we use a special trick where we read the analog value of a fixed reference voltage inside the chip and then use that to make a precise calculation. This also means it will work right no matter what voltage the Arduino is running at!


Schritt 5: Auto-Kalibrierung Versorgung unabhängige Thermometer

Ich kam mit einer Idee, Temperatursensor und LEDs zu verwenden, um den Temperaturwert anzugeben. Ich fand Ladyada-s Tutorial http://www.ladyada.net/learn/sensors/tmp36.html, und jetzt möchte ich LEDs hinzufügen, so dass, wenn die Temperatur unter 0 Grad die blaue LED leuchtet, wenn die Temperatur über 0 Grad die grüne LED auf, und wenn es über 20 Grad ist die rote LED leuchtet. Eigentlich habe ich keine Ahnung, wie man LEDs auf die Temperatur-Code zu integrieren. Vielleicht kann hier jemand helfen ..


Dieses Beispiel ist ähnlich zu der oben mit der Ausnahme, dass jetzt verwenden wir einen Trick, wo wir den analogen Wert aus einer festen Referenzspannung innerhalb des Chips zu lesen und dann verwenden, um eine genaue Berechnung durchzuführen. Das bedeutet auch, es wird rechts, egal welche Spannung der Arduino am Laufen
ist Arbeit!

//TMP36_Pin_Variables_1a
int sensorPin = 0; //the analog pin the TMP36's Vout (sense) pin is connected to
//the resolution is 10 mV / degree centigrade with a
//500 mV offset to allow for negative temperatures

#define BANDGAPREF 14 // FALSCH special indicator that we want to measure the bandgap

/* setup() - this function runs once when you turn your Arduino on. We initialize the serial connection with the computer
 */

void setup()
{
  Serial.begin(9600); //Start the serial connection with the computer
  //to view the result open the serial monitor
  delay(500);
}

void loop() // run over and over again
{
  // get voltage reading from the secret internal 1.05V reference
  int refReading = analogRead(BANDGAPREF);
  Serial.println(refReading);

  // now calculate our power supply voltage from the known 1.05 volt reading
  float supplyvoltage = (1.05 * 1024) / refReading;
  Serial.print(supplyvoltage); 
  Serial.println("V power supply");

  //getting the voltage reading from the temperature sensor
  int reading = analogRead(sensorPin);

  // converting that reading to voltage
  float voltage = reading * supplyvoltage / 1024;

  // print out the voltage
  Serial.print(voltage); 
  Serial.println(" volts");

  // now print out the temperature
  float temperatureC = (voltage - 0.5) * 100 ; //converting from 10 mv per degree wit 500 mV offset
  //to degrees ((volatge - 500mV) times 100)
  Serial.print(temperatureC); 
  Serial.println(" degress C");

  // now convert to Fahrenheight
  float temperatureF = (temperatureC * 9 / 5) + 32;
  Serial.print(temperatureF); 
  Serial.println(" degress F");

  delay(1000); //waiting a second
}

http://forum.arduino.cc/index.php/topic,39636.0.html
http://www.instructables.com/id/Temperature-Sensor-Tutorial/step5/Auto-calibrating-supply-independent-thermometer/
http://forum.arduino.cc/index.php?topic=39636.0;wap2


*********************************************************



templogger / lighttemplogger.pde
#include <SD.h>
#include <Wire.h>
#include "RTClib.h"

// A simple data logger for the Arduino analog pins

// how many milliseconds between grabbing data and logging it. 1000 ms is once a second
#define LOG_INTERVAL 1000 // mills between entries (reduce to take more/faster data)

// how many milliseconds before writing the logged data permanently to disk
// set it to the LOG_INTERVAL to write each time (safest)
// set it to 10*LOG_INTERVAL to write all data every 10 datareads, you could lose up to
// the last 10 reads if power is lost but it uses less power and is much faster!
#define SYNC_INTERVAL 1000 // mills between calls to flush() - to write data to the card
uint32_t syncTime = 0; // time of last sync()

#define ECHO_TO_SERIAL 1 // echo data to serial port
#define WAIT_TO_START 0 // Wait for serial input in setup()

// the digital pins that connect to the LEDs
#define redLEDpin 2
#define greenLEDpin 3

// The analog pins that connect to the sensors
#define photocellPin 0 // analog 0
#define tempPin 1 // analog 1
#define BANDGAPREF 14 // FALSCH special indicator that we want to measure the bandgap

#define aref_voltage 3.3 // we tie 3.3V to ARef and measure it with a multimeter!
#define bandgap_voltage 1.1 // this is not super guaranteed but its not -too- off

RTC_DS1307 RTC; // define the Real Time Clock object

USW USW.

https://github.com/afeld/templogger/blob/master/lighttemplogger.pde



*********************************************************
// The_analog_pins_that_connect_to_the_sensors
#define tempPinRef 0              // analog 0
#define tempPin1 1                 // analog 1
#define tempPin2 2                 // analog 2
#define BANDGAPREF 14          // FALSCH special indicator that we want to measure the bandgap
#define aref_voltage 3.3         // we tie 3.3V to ARef and measure it with a multimeter!
#define bandgap_voltage 1.1   // this is not super guaranteed but its not -too- off

float ReadBandGap(){
  // Log the estimated 'VCC' voltage by measuring the internal 1.1v ref
  analogRead(BANDGAPREF);
  delay(10);
  int refReading = analogRead(BANDGAPREF);
  return supplyvoltage = (bandgap_voltage * 1024) / refReading;
}

http://forums.adafruit.com/viewtopic.php?f=22&t=29946



*********************************************************

Found this post while trying to figure out how to make the Libellium microSD Shield/SDuFAT combo work on my Duemilanove as well. My problem seems to be with the log file on the SD card filling up before all the characters have been used. Will try mowcius's tip using "ETX" and hope that it works.

Since SDuFAT only writes strings, I used the floatToString library from Tim Hirzel (http://www.arduino.cc/playground/Main/FloatToString) to convert my temp sensor (LM35CZ) readings into strings which were then saved on my 2GB MicroSD card w/ the Libellium shield.

Here's the code: (if anyone can offer some suggestions regarding my log file problem http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1261141357/7, please let me know)


Gefunden Beitrag bei dem Versuch, herauszufinden, wie man die microSD Libellium Schirm / SDuFAT Combo auf meinem Duemilanove sowie zu machen. Mein Problem scheint mit der Log-Datei auf der SD-Karte tanken vor alle Zeichen verwendet worden sein. Versuchen mowcius Tipp mit "ETX" und hoffen, dass es funktioniert.

Seit SDuFAT schreibt nur Zeichenfolgen, habe ich die floatToString Bibliothek von Tim Hirzel (http://www.arduino.cc/playground/Main/FloatToString) meinem Temperatursensor (LM35CZ) Lesungen in Strings, die dann auf meine 2GB MicroSD gespeichert wurden, zu konvertieren Karte w / der Libellium Schild.

Hier ist der Code: (wenn jemand einige Vorschläge in Bezug auf meine Log-Datei-Problem http://www.arduino.cc/cgi bin/yabb2/YaBB.pl?num=1261141357/7 anbieten können, lassen Sie es mich wissen
)


Sketch:


// SD_Card_und_FAT_Formatierung_1a
#include "SDuFAT.h" // needed to write data to SD card
#include "floatToString.h" // needed to convert float values to strings used by SDuFat

// define the pin that powers up the SD card
#define MEM_PW 8
#define BANDGAPREF 14 // FALSCH indicator that we want to measure the bandgap
// help string to be sent to the serial port
#define HELP "H help\nL file info\nD delete\nP append string\nW init file and write\nR dump to serial\nA append text\n"

// variable used when reading from serial
byte inSerByte = 0;

// initialize variables for sensors
int SensorPin01 = 0;

int itNum = 1;
void setup(void)
{
  // on my MicroSD Module the power comes from a digital pin
  // I activate it at all times
  pinMode(MEM_PW, OUTPUT);
  digitalWrite(MEM_PW, HIGH);

  // configure the serial port to command the card and read data
  Serial.begin(19200);

}

void loop(void)
{
  // get voltage reading from the internal 1.1V reference analogReference(INTERNAL);
  analogReference(INTERNAL);

  int RefReading = analogRead(BANDGAPREF); // first reading
  RefReading = analogRead(BANDGAPREF); // second reading
  RefReading = analogRead(BANDGAPREF); // third reading
  //Serial.println(RefReading);

  float SupplyCorrection = (1.05 * 1024) / RefReading;
  int Sensor01 = analogRead(SensorPin01);
  float Voltage01 = 100 * (Sensor01 * SupplyCorrection) / 1024;
  //Serial.println(Voltage01);


  // Arduino expects one of a series of one-byte commands
  // you can get some help by sending an 'H' over the serial port
  if (Serial.available() > 0) {
    int result = 0;
    char buffer[25];
    SD.println("temp.txt",""); // adds line break each time serial port query is activated

    inSerByte = Serial.read();
    switch (inSerByte) {
    case 'H':
      Serial.println(HELP);
      result = 3; // special output for help message
      break;
    case 'L':
      result = SD.ls("temp.txt");
      break;
    case 'R':
      result = SD.cat("temp.txt");
      break;
    case 'W':
      result = SD.write("temp.txt");
      break;
    case 'A':
      result = SD.append("temp.txt");
      break;
    case 'P':
      //result = SD.println("temp.txt",floatToString(buffer, testNum, 5));
      result = SD.println("temp.txt",floatToString(buffer, Voltage01,5));
      break;
    case 'D':
      result = SD.del("temp.txt");
      break;
    default:
      result = 2; // value for unknown operation
      break;
    }

    // print a status message for the last issued command
    // for help (result == 3) won't print anything
    if (result == 1) SD.printEvent(ERROR, "temp.txt");
    else if (result == 2) SD.printEvent(WARNING, "unknown command");
    else if (result == 0) SD.printEvent(SUCCESS, "temp.txt");
  }
  //delay(100);
  char buffer[25];
  SD.print("temp.txt",floatToString(buffer,itNum,0)); 
  SD.print("temp.txt"," "); 
  SD.println("temp.txt",floatToString(buffer, Voltage01,5));
  itNum = itNum++;
}

http://forum.arduino.cc/index.php?topic=8061.20;wap2




*********************************************************


Arduino Pins - Analog Pins and Analog Reference Voltage

Arduino Pins - Pins Analog-und Analog-Referenzspannung
Arduino haben 6 analoge markierten Stifte als Analog 0 bis 5. Analog Stifte werden meist verwendet, um analoge Sensoren gelesen und in den Kanälen 6 Analog Digital Converter (ADC) gesendet. Der ADC wird die Spannung (0V bis 5V) auf ganze Zahlen von 0 bis 1023 (10 Bit Auflösung) zu konvertieren. Dies kann mit dem analogRead ()-Funktion ausgeführt werden. Wenn die analogen Sensoren haben einen engen Spannungsbereich, können Sie die analogReference () verwenden, um den Eingangsbereich und die Auflösung zu ändern.





The analogReference() can be change from the default analog reference of 5V ( or 3.3V for some boards ) to either an INTERNAL analog reference or EXTERNAL analog reference.

Internal analog reference will use the internal 1.1V when converting from voltage of integer of 0 - 1023. If the AREF (Analog Reference)  pins is connected, it will USE the external reference voltage even if you issue the command analogReference(INTERNAL);

External analog reference will use the external AREF pin and take the reference voltage of whatever voltage that pins is connected to. You can use this method with a voltage divider to get 2.5V for the analog reference voltage. An example is to connect two resistors of same value (example 100 ohm each) to the 5V pin and tap in the middle to get the 2.5V into the AREF pin.  As normal resistor have a 5% tolerance value, it is not very accurate unless you use metal-film resistors with 1% tolerance value for better accuracy.

All the 6 analog pin can be used as General Purpose Input/Output (GPIO) pins like digital pin using label of A0 to A5. Use the command, pinMode(A0, OUTPUT) to set the analog pin to OUTPUT mode. After the mode is set to OUTPUT, you can use the digitalWrite() functions for these pins.

*** analogRead will not work correctly when set to OUTPUT due to the internal pull-up resistor. You need to use the pinMode to set it back to INPUT before using the analogRead() function.


Die analogReference() kann Wechsel von der Standard-Analog-Referenz von 5V (oder 3,3 V für einige Bretter), um entweder eine interne analoge Referenz oder externen analogen Referenz.

Interne Analogsollwert wird die interne 1,1 V zu verwenden, wenn der Umwandlung von Spannung ganze Zahl von 0 - 1023 Wenn die AREF (Analog Referenz) Stifte angeschlossen ist, wird es die externe Referenzspannung verwenden, selbst wenn Sie den Befehl analogReference (INTERN) auszugeben;

Externen analogen Sollwert wird die externe AREF Pin verwenden und die Referenzspannung gleich welcher Spannung, die Stifte angeschlossen ist. Sie können diese Methode mit einem Spannungsteiler verwenden, um 2,5 V für den analogen Referenzspannung zu erhalten. Ein Beispiel ist, zwei Widerstände gleichen Wert (zB 100 Ohm pro Stück) an den 5V-Pin zu verbinden, und tippen Sie in der Mitte, um die 2,5 V in den AREF Pin zu bekommen. Widerstand als normal haben eine Toleranz von 5%-Wert, ist es nicht sehr genau, wenn Sie Metallfilm -Widerstände mit 1% Toleranzwert für eine bessere Genauigkeit zu verwenden.

Alle 6 analoge Stift kann als General Purpose Input / Output (GPIO) Pins wie Digitalstift mit Etikett A0 bis A5 verwendet werden. Verwenden Sie den Befehl, pinMode (A0, OUTPUT), um das analoge Stift-Ausgabemodus eingestellt. Nach der Modus auf Ausgang gesetzt, können Sie die digital ()-Funktionen für diese Stifte zu verwenden.

*** AnalogRead wird nicht korrekt funktionieren, wenn an OUTPUT aufgrund der internen Pull-up-Widerstand eingestellt. Sie müssen die pinMode, bevor Sie das analogRead ()-Funktion verwenden, um es wieder eingestellt, INPUT.


http://arduino-for-beginners.blogspot.co.at/2011/01/arduino-pins-analog-pins.html



*********************************************************

Arduino > Referenzspannung

Arduino: Referenzspannung und Analog-Digital-Umwandler

Vorbemerkung

Der Standard Arduino verfügt über 6 analoge Eingänge (A0 bis A5). Der ADC/ADU - Analog (to) Digital Converter - wandelt die anliegende Spannung in digitale Signale um. Diese Spannung wird mit einer Referenzspannung verglichen, die nicht mehr als 5 Volt betragen darf (Gefahr der Beschädigung), aber niedriger liegen kann.

Meist wird die den Arduino versorgende Spannung (5 bzw. 3,3 Volt, modellabhängig) als Referenz herangezogen. Diese einfache Lösung ist in vielen Fällen ausreichend, hat aber auch Nachteile. Wird der Arduino z.B. per Batterie versorgt und die Versorgungsspannung sinkt, verändert sich auch unsere Referenz. Auch Servos und/oder Relais können zu kurzfristigen Schwankungen führen.

Eine andere Möglichkeit ist die Verwendung der internen Referenzspannung, die meist 1,1 Volt (Uno etc.), beim Mega jedoch 2,56 Volt beträgt. Alternativ können wir dem ADC eine eigene externe Referenzspannung zur Verfügung führen (Pin AREF), die natürlich niemals 5 Volt übersteigen sollte.

Der beim Arduino verwendete ADC hat 10 Bit, d.h. eine Auflösung von 1024 Stufen (0 bis 1023). Der Wert 0 entspricht einer Spannung von 0 Volt, der Wert 1023 der Referenzspannung.

Einige Informationen findet ihr auch in der Arduino Reference.

Wenn wir 5 Volt = 5000 mV - genauer 4,995 Volt (vernachlässige ich jetzt mal) - durch 1024 teilen, erhalten wir einen Wert von 4,88 mV je Schritt. Bei einer Referenzspannung von 3,3 Volt hingegen 3,22, bei 2,56 Volt sogar nur 2,5 mV. Es kann also sinnvoll sein, mit einer niedrigeren Referenzspannung zu arbeiten, wenn eine genauere Auflösung notwendig sein sollte.. Allerdings müssen natürlich ggf. die Sensoren mitspielen, weshalb die interne Referenzspannung von 1,1 Volt auch selten genutzt wird.

ModusModellSpannungAuflösung
standardalle5 bzw. 3,3 Volt4,88 bzw. 3,22 mV
internUno usw.1,1 Volt1,07 mV
intern Mega1,1 bzw. 2,56 Volt1,07 bzw. 2,50 mv
extern alle 0 bis 5 VoltAREF / 1024
.

Externe Refererenz mit Zener-Diode

Natürlich muß bei einer Verwendung der externen Referenzspannung (AREF) diese stabil sein. Hierfür verwenden wir entweder eine Zener-Diode oder einen Spannungsregler z.B. aus der 78xx-Serie.

Zur Zener-Diode: Sieht dann ungefähr so aus ....

Image

Den notwendigen Widerstandswert könnt ihr auf reuk.co.uk berechnen lassen. Eh' eine empfehlenswerte Seite!

Externe Refererenz mit Zener-Diode (abschaltbar)

Der gewünschte Spannungsabfall an der Zener-Diode verkürzt natürlich die Laufzeit beim Betrieb an Batterien. In vielen Fällen können wir diese Problematik in den Griff bekommen, indem wir die AREF bei Bedarf einfach ausschalten. Ein gutes Beispiel dafür ist eine Wetterstation, die z.B. die gewünschten Daten nur alle 15 Minuten oder sogar stündlich erfassen soll. Hierzu benutzen wir einfach einen freien digitalen Pin und schalten diesen kurz vor dem Auslesen der Sensordaten ein (HIGH) und danach wieder aus (LOW):

Image

Die Darstellungen wurden natürlich wieder einmal mit fritzing erstellt.

wird fortgesetzt



Die meisten Arduino verfügen über einen 10 Bit ADC/ADU (Analog-Digital-Umsetzer). Am analogen Eingang anliegende Spannungen zwischen 0 bis 5 Volt werden in diese Spannung repräsentierende Integerwerte von 0 bis 1023 umgewandelt. Bei einer Betriebsspannung von 5 Volt haben wir also eine Auflössung von 4,88 mV (5000 / 1024), bei einer Betriebsspannung von 3,3 Volt eine Auflösung von 3,22 mV. -->

Jede Abweichung der Betriebsspannung vom Sollwert liefert uns ein "falsches" Messergebnis. Beispiel:

Bei 5 Volt repräsentiert der Wert 623 eine an ein einem Analogeingang anliegende Spannung von ~ 3040 mV, bei einer Referenzspannung von 4900 mV nur ~ 3024. Immerhin eine Abweichung von mehr als 0,5 Prozent.

Bei Anwendungen, in denen es um eine hohe Genauigkeit geht (Temperatur, Entfernung usw.) kann diese "Toleranz" schon eine bedeutende Rolle spielen (2,5 cm Abweichung auf einer Entfernung von 5 Metern).

Bei Stromversorgung per USB ist dies kein ganz seltenes Problem, zudem die verwendeten USB-Kabel selbst ihren Teil betragen können (Impedanz). Beim Arduino Yün, der über keinen integrierten Spannungsregler verfügt, ist dieses Problem noch größer. Auf einem meiner Yŭn lagen am 5 Volt-Pin nur 4,6 Volt an. Dies bedeutet, das wir uns schon mit einer Abweichung von knappen 8 Prozent herumschlagen müssen. Gedanken über die Genauigkeit eines Sensors müssen wir uns spätestens jetzt kaum mehr machen.

Was tun? Zum einen können wir eine externe Referenzspannung nutzen, andererseits aber auch auf Arduino-Bordmittel zurückgreifen: Moderne Arduino verfügen über 2 Pins, die uns bei der Lösung des Problems helfen können:

  • AREF liefert die Spannungsreferenz für die analogen Eingänge
  • IOREF ist die Referenz für die I/O-Ports (eigentlich 5 Volt, 3,3 Volt beim Arduino Due)

Also: Am Pin IOREF geben die aktuellen Arduino die "echte" Spannung aus. Am Pin AREF wird die Referenzspannung für die analogen Pins eingelesen. Verbinden wir jetzt diese beiden Pins

Steckbtett Arduino IOREF und AREF

und und rufen die Funktion

analogReference(EXTERNAL);

auf, arbeiten wir ab sofort mit der realen Referenzspannung. Achtung: Ohne diesen Befehl vor dem ersten analogRead() kann die Verbindung zwischen IOREF und AREF zur Zerstörung des Boards führen!

Siehe auch analogReference.


Hier der Sketch

/* "Echte" Referenzspannung ermitteln

Am PIN IOREF geben die aktuellen Arduino die "echte" Spannung aus. Am Pin AREF wird die
Referenzspannung fuer die analogen Pins eingelesen und der ermittelte Werte auf der
seriellen Konsole ausgegeben.
Arduino AREF an IOREF
Getestet auf Arduino Leonardo unter IDE 1.5.7
fribbe fuer http://macherzin.net
REV. 0.2, 2014-08-12
Unter Public Domain
*/

void setup()
{
                 // Hier IMMER VOR dem dem ersten Aufruf von analogRead aufrufen, da sonst der
                 // Mikrocontroller ZERSTOERT werden kann:
analogReference(EXTERNAL); // beziehen uns jetzt auf den von IOREF gelieferten Wert
}

void loop()
{
                 // euer Code
}


Hinweis:
Sollte ihr euren Arduino mit 5 Volt betreiben, die Sensoren aber mit 3,3 Volt versorgt haben, könnt ihr natürlich auf die 3,3 Volt als analoge Referenzspannung zurückgreifen. In diesen Fällen liegt der Sollwert (3,3 Volt) in der Regel sehr nah am Effektiv-Wert, so daß keine weiteren Maßnahmen notwendig sind. Einfach mal durchmessen.

Einen interessanten Beitrag zu diesem Thema (englischsprachig).

Arduino Tutorials – Chapter 22 – the AREF pin


Hier der Sketch

include <LiquidCrystal.h>
LiquidCrystal lcd(8,9,4,5,6,7);
 
int analoginput = 0;    // our analog pin
int analogamount = 0; // stores incoming value
float percentage = 0;   // used to store our percentage value
float voltage =0;          // used to store voltage value
 
void setup()
{
  lcd.begin(16, 2);
  analogReference(EXTERNAL); // use AREF for reference voltage
}
 
void loop()
{
  lcd.clear();
  analogamount=analogRead(analoginput);
  percentage=(analogamount/1024.00)*100;
  voltage=analogamount*3.222;      // in millivolts
  lcd.setCursor(0,0);
  lcd.print("% of AREF: ");
  lcd.print(percentage,2);
  lcd.setCursor(0,1);  
  lcd.print("A0 (mV): ");
  lcd.println(voltage,2);
  delay(250);
}



http://tronixstuff.com/2013/12/12/arduino-tutorials-chapter-22-aref-pin/


*********************************************************

Arduino > Referenzspannung

Arduino: Referenzspannung und Analog-Digital-Umwandler


Vorbemerkung
Der Standard Arduino verfügt über 6 analoge Eingänge (A0 bis A5).
Der ADC/ADU - Analog (to) Digital Converter - wandelt die anliegende Spannung in digitale Signale um.
Diese Spannung wird mit einer Referenzspannung verglichen, die nicht mehr als 5 Volt betragen darf (Gefahr der Beschädigung), aber niedriger liegen kann.

Meist wird die den Arduino versorgende Spannung (5 bzw. 3,3 Volt, modellabhängig) als Referenz herangezogen.
Diese einfache Lösung ist in vielen Fällen ausreichend, hat aber auch Nachteile.
Wird der Arduino z.B. per Batterie versorgt und die Versorgungsspannung sinkt, verändert sich auch unsere Referenz.
Auch Servos und/oder Relais können zu kurzfristigen Schwankungen führen.

Eine andere Möglichkeit ist die Verwendung der internen Referenzspannung, die meist 1,1 Volt (Uno etc.),
 Alternativ können wir dem ADC eine eigene externe Referenzspannung zur Verfügung führen (Pin-Aref), die natürlich niemals 5 Volt übersteigen sollte.

Der beim Arduino verwendete ADC hat 10-bit, d.h. eine Auflösung von 1024 Stufen (0 bis 1023).
Der Wert 0 entspricht einer Spannung von 0 Volt, der Wert 1023 der Referenzspannung.

Einige Informationen findet ihr auch in der Arduino Reference.

Wenn wir 5 Volt = 5000 mV durch 1023 teilen, erhalten wir einen Wert von 4,8876 mV je Schritt.
Bei einer Referenzspannung von 3,3 Volt hingegen 3,2258mV bei 1,1V  sind es 1,0753mV.
Es kann also sinnvoll sein, mit einer niedrigeren Referenzspannung zu arbeiten, wenn eine genauere Auflösung notwendig sein sollte.
Allerdings müssen natürlich ggf. die Sensoren mitspielen, weshalb die interne Referenzspannung von 1,1 Volt auch selten genutzt wird.
ModusModellSpannungAuflösung
standardalle5 bzw. 3,3 Volt4,88 bzw. 3,22 mV
internUno usw.1,1 Volt1,07 mV
intern Mega1,1 bzw. 2,56 Volt1,07 bzw. 2,50 mv
extern alle 0 bis 5 VoltAref / 1024
.

Externe Refererenz mit Zener-Diode

Natürlich muß bei einer Verwendung der externen Referenzspannung (Aref) diese stabil sein.

Hierfür verwenden wir entweder eine Zener-Diode oder einen Spannungsregler z.B. aus der 78xx-Serie.

Zur Zener-Diode: Sieht dann ungefähr so aus ....

Image

Den notwendigen Widerstandswert könnt ihr auf reuk.co.uk berechnen lassen. Eh' eine empfehlenswerte Seite!

Externe Refererenz mit Zener-Diode (abschaltbar)

Der gewünschte Spannungsabfall an der Zener-Diode verkürzt natürlich die Laufzeit beim Betrieb an Batterien.
In vielen Fällen können wir diese Problematik in den Griff bekommen, indem wir die Aref bei Bedarf einfach ausschalten.
Ein gutes Beispiel dafür ist eine Wetterstation, die z.B. die gewünschten Daten nur alle 15 Minuten oder sogar stündlich erfassen soll.
Hierzu benutzen wir einfach einen freien digitalen Pin und schalten diesen kurz vor dem Auslesen der Sensordaten ein (HIGH) und danach wieder aus (LOW):

Image

Die Darstellungen wurden natürlich mit fritzing erstellt.

wird fortgesetzt

http://macherzin.net/article53



Arduino Spannungsreferenz für analoge Eingänge


Die meisten Arduino verfügen über einen 10-bit ADC/ADU (Analog-Digital-Umsetzer).
Am analogen Eingang anliegende Spannungen zwischen 0 bis 5 Volt werden in diese Spannung repräsentierende Integerwerte von 0 bis 1023 umgewandelt.
Bei einer Betriebsspannung von 5 Volt haben wir also eine Auflössung von 4,88 mV (5000 / 1024), bei einer Betriebsspannung von 3,3 Volt eine Auflösung von 3,22 mV. -->
Jede Abweichung der Betriebsspannung vom Sollwert liefert uns ein "falsches" Messergebnis. Beispiel:
Bei 5 Volt repräsentiert der Wert 623 eine an ein einem Analogeingang anliegende Spannung von ~ 3040 mV, bei einer Referenzspannung von 4900 mV nur ~ 3024.
Immerhin eine Abweichung von mehr als 0,5 Prozent.
Bei Anwendungen, in denen es um eine hohe Genauigkeit geht (Temperatur, Entfernung usw.) kann diese "Toleranz" schon eine bedeutende Rolle spielen (2,5 cm Abweichung auf einer Entfernung von 5 Metern).
Bei Stromversorgung per USB ist dies kein ganz seltenes Problem, zudem die verwendeten USB-Kabel selbst ihren Teil betragen können (Impedanz).
Beim Arduino Yün, der über keinen integrierten Spannungsregler verfügt, ist dieses Problem noch größer.
Auf einem meiner Yŭn lagen am 5 Volt-Pin nur 4,6 Volt an.
Dies bedeutet, das wir uns schon mit einer Abweichung von knappen 8 Prozent herumschlagen müssen.
Gedanken über die Genauigkeit eines Sensors müssen wir uns spätestens jetzt kaum mehr machen.

Was tun? Zum einen können wir eine externe Referenzspannung nutzen, andererseits aber auch auf Arduino-Bordmittel zurückgreifen:
Moderne Arduino verfügen über 2 Pins, die uns bei der Lösung des Problems helfen können:
pin-Aref liefert die Spannungsreferenz für die analogen Eingänge
pin-IOref ist die Referenz für die I/O-Ports (eigentlich 5 Volt, 3,3 Volt beim Arduino Due)


Am pin-IOref geben die aktuellen Arduino die "echte" Spannung aus.
Am pin-Aref wird die Referenzspannung für die analogen Pins eingelesen.


Verbinden wir jetzt diese beiden Pins

Steckbtett Arduino IOREF und AREF

und und rufen die Funktion

analogReference(EXTERNAL);

auf, arbeiten wir ab sofort mit der realen Referenzspannung. Achtung: Ohne diesen Befehl vor dem ersten analogRead() kann die Verbindung zwischen IOREF und AREF zur Zerstörung des Boards führen!

Siehe auch analogReference.

Hier der Code:

/* "Echte" Referenzspannung ermitteln
Am PIN IOREF geben die aktuellen Arduino die "echte" Spannung aus. Am Pin AREF wird die
Referenzspannung fuer die analogen Pins eingelesen und der ermittelte Werte auf der
seriellen Konsole ausgegeben.

Arduino AREF an IOREF

Getestet auf Arduino Leonardo unter IDE 1.5.7

fribbe fuer http://macherzin.net
REV. 0.2, 2014-08-12

Unter Public Domain
*/

void setup()
{
// Hier IMMER VOR dem dem ersten Aufruf von analogRead aufrufen, da sonst der
// Mikrocontroller ZERSTOERT werden kann:
analogReference(EXTERNAL); // beziehen uns jetzt auf den von IOREF gelieferten Wert
}

void loop()
{
// euer Code
}

Hinweis:
Sollte ihr euren Arduino mit 5 Volt betreiben, die Sensoren aber mit 3,3 Volt versorgt haben, könnt ihr natürlich auf die 3,3 Volt als analoge Referenzspannung zurückgreifen.
In diesen Fällen liegt der Sollwert (3,3 Volt) in der Regel sehr nah am Effektiv-Wert, so daß keine weiteren Maßnahmen notwendig sind.
Einfach mal durchmessen.
Einen interessanten Beitrag zu diesem Thema findet ihr hier (englischsprachig).
Habt Spaß!
P.S.: Dank an Erik, der mich zum Schreiben dieses Artikels angeregt hat (auch wenn ihm dieses vielleicht nicht bewußt sein mag ...).
http://macherzin.net/article104-Arduino-Spannungsreferenz-fur-analoge-Eingange




DIN A4 ausdrucken

*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE
Comments