Spannung auslesen

[runner02]

Hallo Leute,

Habe mich noch einmal intensivst damit beschäftigt, edlich den ADC meiner AVRs bedienen zu können...

Nun habe ich einiges herausgefunden, doch ein paar Fragen habe ich noch.

Hier mal der gesamte Beispielcode (Auszug aus http://www.rn-wissen.de/index.php/ADC_%28Avr%29 )

#include <avr/io.h>
#include <inttypes.h>

uint16_t readADC(uint8_t channel ) {
uint8_t i;
uint16_t result = 0;

// Den ADC aktivieren und Teilungsfaktor auf 64 stellen
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);

// Kanal des Multiplexers waehlen
// Interne Referenzspannung verwenden (also 2,56 V)
ADMUX = channel | (1<<REFS1) | (1<<REFS0);

// Den ADC initialisieren und einen sog. Dummyreadout machen
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));

// Jetzt 3x die analoge Spannung and Kanal channel auslesen
// und dann Durchschnittswert ausrechnen.
for(i=0; i<3; i++) {
// Eine Wandlung
ADCSRA |= (1<<ADSC);
// Auf Ergebnis warten...
while(ADCSRA & (1<<ADSC));

result += ADCW;
}

// ADC wieder deaktivieren
ADCSRA &= ~(1<<ADEN);

result /= 3;

return result;
}

int main(void) {
uint16_t result = readADC(0); //Auslesen der analogen Spannungen an Pin 0,
// also ADC0. In result steht das Ergebnis.
return 0;
}

Der 'Kanal des Multiplexers' heißt in diesem Fall PortB1 oder auch ADC1 ??

Die interne Referenz ist 2,56 V. Dazu muss ich noch einen Kondensator (mit 15pF ?) an AREF schalten?

Wohin gibt die Funktion die Variable 'result' eigentlich zurück?

Hier... Im letzten Absatz, für was ist der gut?? Da ruft man einfach eine neue Funktion auf, die das Ergebnis ausliest? Wieso heißt das result = read ADC(0)? Wieso fragt man nicht direkt die Variable ab? Oder fragt man hier den AD-Converter, welchen Wert er als letzten draufhatte?? Und das return 0 heißt, er springt wieder zum Anfang zurück und misst wieder die Spannung (Endlosschleife?)??

Ist dies eine Funktion? Die Schreibweise sieht so aus...
Was heißt hier das Channel?


Auf jeden Fall Danke im Vorraus!!

[BurningWave]

Fangen wir mal von hinten an: channel ist eine Variable des Typs uint8_t, die der Funktion (ja das ist eine Funktion) beim Aufrufen als Parameter übergeben wird. Statt uint8_t könnte man auch char als Typ nehmen (hat beides 8 Bit). Im letzten Absatz in der Hauptfunktion (main()), die ja beim Starten des Programms ausgeführt wird, wird eine Variable des Typs uint16_t (16 Bit) erzeugt, die result heißt. In ihr wird der Wert, den die Funktion readADC (die oben definiert ist) zurück gibt, gespeichert. Das zurückgeben geschieht mit "return result" (result ist der digitalisierte Analogwert). Das return 0 in main() tut nichts weiter, als das Programm zu beenden, also eine 0 aus main() zurück zu geben.
Hier: http://www.mikrocontroller.net/artic...-Tutorial:_ADC steht die Beschaltung von AREF
channel ist an dieser Stelle der Parameter der Funktion readADC. Hier musst du nichts verändern. Beim Funktionsaufruf musste du nur eine Zahl, angeben, also nichts mit PORTB oder so. Duch diesen Befehl werden die entsprechenden MUXx Bits im ADMUX Register gesetzt (näheres siehe Link).

Ich hoffe das bringt dich weiter.
mfg

[runner02]

Das heißt, zuerst ruft der Chip die Funktion Main auf (eigentlich klar), und dort steht uint16_t result = readADC(0); . Das heißt, er springt nach oben und benutzt den Quellcode zum Auslesen?

channel ist eine Variable des Typs uint8_t, die der Funktion (ja das ist eine Funktion) beim Aufrufen als Parameter übergeben wird.

Könnte ich sie statdessen auch x oder xyz nennen?

Beim Funktionsaufruf musste du nur eine Zahl, angeben, also nichts mit PORTB oder so.

also result, die gibt er sich selber, oder? Oder ist hier das void bzw. 0 gemeint?

Danke soweit mal,
das hat mir schon einiges geholfen... =D>

[shedepe]

Er ruft die Funktion auf und benutzt den Code der dort steht um den ADC auszulesen.

Du kannst einer Variable sogut wie jeden Namen geben so lange der sich an den C-Standard hält. (Schau im Wiki nach, da steht drin was für namen alles erlaubt sind, bin mir grad nicht mehr ganz sicher)

Wie meinst du das mit ?:

also result, die gibt er sich selber, oder? Oder ist hier das void bzw. 0 gemeint?

Also der Variable Result wird in der Funktion ein Wert zugewiesen, und dieser zurückgegeben--> return result;

[runner02]

Habe das ganze mal in mein Programm geschrieben,
Dabei hat sich mir schnell noch eine Frage aufgedrängt:

das Resultat ist vom Typ uint16_t Also integer mit 16 Zeichen.


Nun, Ich habe dann geschrieben

uint16_t spannung;
spannung=result*3.125

Dann müsste die Spannung in Millivolt ausgegeben werden. Allerdings wird der Compiler aufschreien, da - sofern ich mich richtig erinnere, keine FLießkommawerte erlaubt sind... Sollte ich char oder float nehmen? Oder uchar16_t ?


@shedepe: Hat sich erledigt, trotzdem Danke für dein Bemühen
(readADC ist die Funktion, wenn man sie aufruft gibt man readADC(0) ein, dann muss man an ADC0 anlegen)

[shedepe]

uint16_t ist ein integer mit 16bit nicht mit 16 Zeichen.

Schau dir Festkomma-arithmetik an. Floats sind auf Atmegas ziemlich speicher und rechenintensiv.

[BurningWave]

uint16_t spannung;
spannung=result*3.125

Dann müsste die Spannung in Millivolt ausgegeben werden.

Nein, so einfach ist das nicht: result beinhaltet einen 10 Bit Wert. Wobei 0b0 das niedrigste Ergebnis ist, das der ADC liefern kann und 0b1111111111 (=1024) das Höchste (es würde deinen 3,125V enstprechen). Du kannst es so umrechnen:
float fErgebnis = (float)(result) / 1024.0f * 3.125f;

[runner02]

(es würde deinen 3,125V enstprechen)

Ich glaube da hast du mich unterschätzt. Meine Versorgungsspannung ist 3,2V, daher entspricht ein erfassbarer Schritt exact 3,125mV (3,2/1024)...
Also könnte ich

float spannung =  result * 3.125;

nehmen (?)


Hey ich habe noch ein riesen Problem: Ich habe versucht, den Code auf meinen Chip zu spielen. Allerdings tauchen unzählige Fehler auf... Er kennt alle Ausdrücke nicht wie ADMUX, ADCSAR, ADEN,... 'not found on the scope'

aber, wie es in dem Beispiel link stand, habe ich #include <inttypes.h> dazugeschrieben, trotzdem kennt er die Befehle nicht...

[BurningWave]

OK, ich habe dann deinen Rechenweg oben nicht ganz verstanden, das stimmt dann natürlich.

Also inttypes.h definiert nur die verschiedenen int-Varianten (uint8_t, uint16_t,...), in der Datei avr/io.h werden alle Register usw. definiert. Hast du in den Projekteinstellungen den richtigen Typ des µCs angegeben? Es kann auch sein, dass die Register deines µCs anders heißen, dazu solltest du in dem Datenblatt deines Controllers nachschauen.

[shedepe]

Hast du dir schon mal ein anständiges AVR-GCC Tutorial durchgelesen und auch durchgearbeitet? Wäre vllt. besser bevor du noch weitere tausende fragen wegen Kleinigkeiten stellst ?!

So mal als anhaltspunkte:
http://www.mikrocontroller.net/artic...R-GCC-Tutorial
http://www.rn-wissen.de/index.php/Avr-gcc
http://www.rn-wissen.de/index.php/C-Tutorial

mfg shedepe