www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik ADC auslesen


Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moin moin,
habe ein Problem , und zwar möchte ich gerne mein ADC in einem festen 
Intervall von 250ms auslesen , steh aber immoment voll aufm schlauch 
bitte um mithilfe. Habe zuvor schon mein ADC konfiguriert
/////////////////////////init_ADC()/////////////////////////

void init_ADC(void)
{
  ADMUX |= (1 << REFS0);
  ADCSRA |= (1 << ADPS2)|(1 << ADPS1)|(1 << ADPS0); //ADC Prescalar PRESCALAR=FCPU/FADC=80
  ADCSRA |=(1 << ADFR); //Free running modus
}


/////////////////////////init_LED()/////////////////////////


void init_LED(void)
{
  DDRB= 0x00;    // PORT B ALS ANSCHLUSS
  PORTB= 0x00;  //Alle Leds aus  

}



/////////////////////////start_ADC()/////////////////////////

void start_ADC(void)
{

  ADCSRA |=(1 << ADEN)|(1 << ADSC); //ADC an und starten der Konversation

}


/////////////////////////wait_ADC()/////////////////////////

void wait_ADC (void)
{
  while(!(ADCSR & (1<<ADIF)));  //Warten auf Ende

}


/////////////////////////read_ADC()/////////////////////////

void read_ADC(void)
{
  unsigned short adcres;

  adcres=ADC;            //Auslesen

}

Autor: spess53 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi

>habe ein Problem , und zwar möchte ich gerne mein ADC in einem festen
>Intervall von 250ms auslesen , steh aber immoment voll aufm schlauch
>bitte um mithilfe. Habe zuvor schon mein ADC konfiguriert

Controller?
Neuere AVRs haben mehrere Autotriggerquellen. Dazu gehören auch Timer. 
Und damit lässt dann das Abfrageintervall einstellen.

MfG Spess

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Man kann den ADC auch im Free-Run-Mode laufen lassen und im 
Timer-Interrupt nebenher abfragen. Das hat noch den Vorteil, dass man 
nicht prüfen muss, ob der ADC schon fertig ist.

...

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sorry hatte ich vergessen zu erwähnen benutzte einen AVR ATMEGA128

also ich möchte halt das der ADC im intervall von 250ms (delay) 
ausgelesen wird und die eingelesenen wert(8Bits) ausgibt

Autor: ich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>  ADCSRA |=(1 << ADEN)|(1 << ADSC); //ADC an und starten der Konversation

cool. Du kanst mit deinem ADC erzählen???

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sorry konversion haha =)

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Denis schrieb:
> Sorry hatte ich vergessen zu erwähnen benutzte einen AVR ATMEGA128
>
> also ich möchte halt das der ADC im intervall von 250ms (delay)
> ausgelesen wird und die eingelesenen wert(8Bits) ausgibt

Ein paar Möglichkeiten wurden dir ja jetzt schon vorgeschlagen.
Und alle drehen sich immer darum, dass du einen Timer für die zeitliche 
Steuerung verwendest.

Woran hakt es denn jetzt?

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ehrlich gesagt hackt es immoment an der umsetztung

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Denis schrieb:
> ehrlich gesagt hackt es immoment an der umsetztung

Das ist mir zuwenig :-)
Wobei konkret?
Welche Teile kriegst du selber hin, bei welchen brauchst du Hilfe?

Für welche Variante hast du dich entschieden, wie willst du das Problem 
angehen? Kriegst du es zb hin, in einem Timerinterrupt alle 250ms eine 
LED umzuschalten? Wenn ja, dann sollte es ja auch kein Problem sein, in 
demselben Timerinterrupt den ADC zu starten und auszulesen.

Zeig das was du hast. Sag wobei du 'konkret' ein Problem hast und Leute 
werden dir helfen. Aber für dich ein Programm schreiben wird hier 
niemand. Nicht bei einer derartigen Standardaufgabe.

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
mit welchen befehl lese ich denn ein ADC aus?

also ich würde einfach eine funktion my_delay programmieren die 250 ms 
wartet. und dann eine funktion die den ADC ausliest mit ner for schleife 
zum beispiel und dann noch das delay einbinden

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Denis schrieb:
> mit welchen befehl lese ich denn ein ADC aus?

Mit gar keinem.
Schau bitte ins Tutorial. Da findest du auch eine vernünftige, 
anfängergerechte Funktion.
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial


> also ich würde einfach eine funktion my_delay programmieren die 250 ms
> wartet.

Schon falsch.

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
/////////////////////////read_ADC()/////////////////////////

void read_ADC(void)
{
  unsigned short adcres;

  adcres=ADC;            //Auslesen

}



/////////////////////////out_LED()/////////////////////////

void out_LED(void)
{
  DDRB=0xff;    //POTRTB als Ausgang
  PORTB= 0xff;
}




/////////////////////////test()/////////////////////////

void test(void)
{
  read_ADC();
  _delay_ms(250);
  out_LED();

  return;

}

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
so würde er mir ja alles ausgeben?!

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
>> also ich würde einfach eine funktion my_delay programmieren die 250 ms
>> wartet.
>
> Schon falsch.

Das nehme ich zurück.
Fürs erste kann man das so machen.
Aber es ist kein besonders guter Stil und je nachdem was man mit dem 
Wert weiter machen will, manövriert man sich damit ganz schnell in 
Schwierigkeiten.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Denis schrieb:
> so würde er mir ja alles ausgeben?!

Nö.
Du holst zwar hier den Wert

void read_ADC(void)
{
  unsigned short adcres;

  adcres=ADC;            //Auslesen

}

aber du machst nichts damit.

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dann bitte ich um einen kleinen anschub!?

Autor: Torsten Giese (wawibu)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Denis schrieb:
> /////////////////////////test()/////////////////////////
> 
> void test(void)
> {
>   read_ADC();
>   _delay_ms(250);
>   out_LED();
> 
>   return;
> 
> }

Und warum willst Du hier den Wert auslesen (ohne ihn als Rückgabe zu 
erhalten), dann 250ms warten, um dann alle LEDs zur Anzeige zubringen?

Was soll denn mit dem ADC Wert passieren?

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
/////////////////////////out_LED()/////////////////////////

void out_LED(void)
{
  DDRB=0xff;    //POTRTB als Ausgang
  PORTB= 0xff;
  
  PORTB = ADCH;
}




/////////////////////////test()/////////////////////////

void test(void)
{
  read_ADC();
  _delay_ms(250);
  out_LED();

  return;

}

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
also der ADC soll ausgelesen werden 250ms intervall und die eingelesenen 
werte die unteren 8bit auf den leds angezeigt werden

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also noch ma ganz in Ruhe ich lese als ersten mein adc aus das geschieht 
ja schon hier bei mir
 /////////////////////////read_ADC()/////////////////////////

void read_ADC(void)
{
  unsigned short adcres;

  adcres=ADC;            //Auslesen

}

so jetzt möchte in werte einlesen und auf die leds ausgeben und da 
hängts

Autor: Denis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ich habe ein buchstaben eingelesen
/////////////////////////my_getch()/////////////////////////

char my_getch(void)
{
  int pruefung = 0;
  char buchstabe = 0;


    while(((pruefung = my_status()) == 0 ))// warten bis zeichen kommt
    
  buchstabe = UDR0;                      // Abrufe des Datenregisters
    return buchstabe;  

}
und direkt wieder als echo ausgegeben

es ist ein potentiometer (0-5V) an PortF angeschlossen und nun möchte 
ich die niederwertigen 8bits des eingelesenen wertes auf die leds 
ausgeben

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Denis schrieb:
> Also noch ma ganz in Ruhe ich lese als ersten mein adc aus das geschieht
> ja schon hier bei mir
> /////////////////////////read_ADC()/////////////////////////
> 
> void read_ADC(void)
> {
>   unsigned short adcres;
> 
>   adcres=ADC;            //Auslesen
> 
> }
> 
>
> so jetzt möchte in werte einlesen und auf die leds ausgeben und da
> hängts

Dann ändere als erstes einmal diese Funktion so um, dass die den 
ausgelesenen Wert auch an den Aufrufer zurückgibt
unsigned short read_ADC(void)
{
  return ADC;            //Auslesen
}

als nächstes verpasst du der out_Led Funktion ein Argument, damit du 
dieser Funktion auch sagen kannst, was sie ausgeben soll
void out_LED( unsigned short Wert )
{
  DDRB = 0xff;    //POTRTB als Ausgang
  PORTB = Wert;
}

und dann verknüpfst du die beiden Funktionen, indem du den Wert, den du 
von der einen Funktion bekommst in die andere Funktion hineinstopfst
void test(void)
{
  unsigned short Wert;

  start_ADC();
  wait_ADC();
  Wert =  read_ADC();
  out_LED( Wert );
  _delay_ms(250);
}

und als nächstes besorgst du dir ein C-Buch.

Autor: Florian Thevissen (fthevissen)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> mit welchen befehl lese ich denn ein ADC aus?

Ein C Buch, und ne Stunde oder Zwei um das Datenblatt des uCs genau zu 
studieren.

Ist das uebrigens "Alles" was der uC machen soll? Also nur den ADC lesen 
und irgendwas mit dem Ergebnis anstellen?

Dann kommst du um timer und interrupts naemlich herum, kommst aber in 
die Bredouille dass jeder Befehl selber noch ein paar Zyklen, und somit 
Zeit, beansprucht.

Wenn es dann ganz genau (!) 250ms werden sollen musste dir das 
Disassembly Listing anschauen, das der Compiler von deinem C code 
erzeugt hat und rausfinden wie lange das Alles wirklich dauert. C ist 
nunmal leider nur eine Abstraktion.

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Wenn es dann ganz genau (!) 250ms werden sollen musste dir das
> Disassembly Listing anschauen, ...

Das mag für Warteschleifen (Delay-Funktion) gelten, aber nicht für den 
Timer-Interrupt. Dem ist es nämlich egal, ob er per C oder ASM 
initialisiert wurde, der schlägt im exakten Takt zu. Und dem ist es auch 
egal ob eine C-Zuweisung (portx=adcl) oder eine ASM-Codesequenz
(in r0,adcl; out portx,r0) das Ergebnis abholt.

Alle meine bisherigen Programme kommen zwar ohne C aus, die meisten von 
ihnen aber nicht ohne Timer-Interrupt.

...

Autor: Florian Thevissen (fthevissen)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> "Der timer laeuft unabhaengig von dem was die CPU grade anstellt; nur
> die Initialisierung kostet Zeit"
(Mal von dem Aufruf der ISR abgesehen und wie geschickt man sich in der 
ISR anstellt, das kann auch Zeit kosten)

Oehm, sag' ich doch?

Autor: Hannes Lux (hannes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Oehm, sag' ich doch?

Ja sicher doch, aber manchmal versteht es der (nicht übermäßig 
motivierte) Anfänger besser, wenn er es auf verschiedene Arten erklärt 
bekommt.

;-)

...

Autor: Florian Thevissen (fthevissen)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also bei dem Stuss wirds mir schwindlig.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.