Anfängerhilfe bei Analog Digital Converter

[Martin *. (mistermister606)]

Hallo zusammen

ich benötige mal wieder eure Hilfe.
Ich nutze das rumpus board (atm168) und möchte hier gerne den Poti 
auswerten (PC5) und bei einem gewissen wert soll die LED1  (PC4) 
aufleuchten.

Ich hab das AVR-GCC-Tutorial schon zig mal gelesen aber ich will es 
einfach nicht verstehen...

Ich frage das ungern, aber kann mir jemand die paar Zeilen zukommen 
lassen, damit ich den Code dann zerlegen und lernen kann?

DANKE

[Floh (Gast)]

Was hindert dich daran, die Turorialfunktion zu nehmen?

[Coder (Gast)]

Gegenfrage: Was verstehst Du und was nicht. Einfacher als im Tutorial 
geht es kaum. Der Code ist ja fast Zeilenweise kommentiert.

[Martin *. (mistermister606)]

Ok ich glaube es ist am besten, wenn ich den bereits kommentierten Code 
nochmals kommentiere

/* ADC initialisieren */
void ADC_Init(void) {
 
  uint16_t result;
  uint16_t test;  

  ADMUX = (1<<REFS1) | (1<<REFS0);      
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler

"Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und 
dem Eingangstakt des ADC."
ATmega48/88/168: 0 - 10MHz @ 2.7V - 5.5V, 0 - 20MHz @ 4.5V - 5.5V  steht 
im DB nur welchen Mhz wert muss ich da jetzt nehmen?

  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  ADCSRA |= (1<<ADFR);                  // eine ADC-Wandlung

wenn ich den Eingang PC5 überwachen will würde ADFR passen oder?

  while (ADCSRA & (1<<ADFR) ) {}        // auf Abschluss der Konvertierung warten
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
     Wandlung nicht übernommen. */
  result = ADCW;
}

Wenn ich es richtig verstanden habe sollte nun bereits der eingelesene 
Wert in result stehen?

/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);

Was mach ich den dann mit ADMUX das auszulesende bit hatte ich doch 
vorher mit  ADCSRA |= (1<<ADFR); bestimmt ?

  ADCSRA |= (1<<ADFR);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADFR) ) {}  // auf Abschluss der Konvertierung warten
test = ADCW;                    // ADC auslesen und zurückgeben
}
...
 
/* Beispielaufrufe: */
 
int main()
{
  uint16_t adcval;
  ADC_Init();
 
  while( 1 ) {
    adcval = ADC_Read(0);  // Kanal 0
    // mach was mit adcval
 
  }
}

Welche Auflösung habe ich nun?
Wie kann ich nun z.b. bei dem wert 4 in der Variable test die LED 1 
(PC4) einschalten?


Danke euch ;)

[Jörg W. (dl8dtl) (Moderator)]

Martin *** schrieb:

> ATmega48/88/168: 0 - 10MHz @ 2.7V - 5.5V, 0 - 20MHz @ 4.5V - 5.5V  steht
> im DB

Das sind nur die zulässigen Taktfrequenzbereiche.

> nur welchen Mhz wert muss ich da jetzt nehmen?

Den Takt, den du wirklich für deine CPU ausgesucht hast.

Wenn du nichts verändert hast, dann beträgt der Takt 1 MHz (interner
RC-Oszillator mit 8 MHz, aber clock prescaler auf 1:8 voreingestellt).

>

>   ADCSRA |= (1<<ADEN);                  // ADC aktivieren
> 
>   ADCSRA |= (1<<ADFR);                  // eine ADC-Wandlung
>

>
> wenn ich den Eingang PC5 überwachen will würde ADFR passen oder?

ADFR gibt's beim ATmegaX8 gar nicht.  Das war bei den älteren AVRs der
"free running mode", bei den aktuellen heißt dieses Bit ADATE (ADC
auto-trigger enable), weil außer "free running" noch weitere
automatische Trigger möglich sind.  Der Kommentar dort passt aber gar
nicht, da steht "eine ADC-Wandlung", das würde man durch

ADCSRA = (1<<ADSC);

erreichen ("SC" = "start conversion")

Damit, welchen ADC-Eingang du abfragst, hat das aber alles nichts zu
tun: das wird im ADMUX festgelegt.  Das Datenblatt enthält eine
Tabelle, in der die Zuordnung der Werte aufgeführt ist.

>   while (ADCSRA & (1<<ADFR) ) {}        // auf Abschluss der
> Konvertierung warten

Siehe oben, das wäre auch wiederum ADSC.

> Wenn ich es richtig verstanden habe sollte nun bereits der eingelesene
> Wert in result stehen?

Ja.

>   ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
> [/c]
>
>
> Was mach ich den dann mit ADMUX das auszulesende bit hatte ich doch
> vorher mit  ADCSRA |= (1<<ADFR); bestimmt ?

ADMUX und ADCSRA sind zwei völlig verschiedene Dinge.

> Welche Auflösung habe ich nun?

10 Bit.

> Wie kann ich nun z.b. bei dem wert 4 in der Variable test die LED 1
> (PC4) einschalten?

Hast du überhaupt schon mal was in C auf einem Controller gemacht?

[Martin *. (mistermister606)]

C ++ habe ich schon gearbeitet aber jetzt nicht als Programmierer 
sondern rein als Hobby wie auch das Microcontroller Programmieren.

Ich hab nun mal alles etwas (für mich einfacher zu verstehen) gestrickt 
und eine If hinzugefügt auch wenn ich nicht glaube, dass dies stimmt.

int main()
{

 uint16_t result;
 

  ADMUX = (1<<REFS1) | (1<<REFS0);      // interne Referenzspannung nutzen
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
  DDRD = (1<<PD3);
 
 
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) ) {}        // auf Abschluss der Konvertierung warten
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
     Wandlung nicht übernommen. */
  result = ADCW;





  while( 1 )
  {
////////////////////////////////////////////////////////////////////////////////
 

/* ADC Einzelmessung */
 uint16_t test; 




  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (1<<PC5);
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten
  test = ADCW;                    // ADC auslesen und zurückgeben


  if(test == 4) {
    PORTD |= (1<<PD3);  //LED2
  }
  else {
    PORTD &= ~(1<<PD3);  //LED2
}
/////////////////////////////////////////////////////////////////////////////////
  }
}

btw. ich nutze den atm168

[Karl H. (kbuchegg)]

Martin *** schrieb:

> Ich hab nun mal alles etwas (für mich einfacher zu verstehen) gestrickt
> und eine If hinzugefügt auch wenn ich nicht glaube, dass dies stimmt.

WTF

WOZU?

Benutz doch die Tutorialroutinen so wie sie sind. Die kopierst du in 
deinen Source Code einfach rein. Das ist doch nicht so schwer

Und dein main sieht dann so aus (auch das findet sich im 
Tutorialsbeispiel mehr oder weniger)

int main()
{
  uint16_t wert;

  ADC_Init()

  while( 1 ) {
    wert = ADC_Read( 5 );    // weil du vom Kanal 5, also PC5 lesen willst

    if( wert > 4 )
      mach was
    else
      mach was anderes
  }
}

Ich versteh gar nicht, was da jetzt so schwer drann sein soll. Ist doch 
ohnehin alles schon vorgearbeitet. Einzig deine Referenzspannung musst 
du im ADC_Init noch richtig einstellen, wobei die Einstellung für 
'intern Vcc' wahrscheinlich sowieso passt.

Was bitte ist an deinem Code jetzt einfacher als an diesem Code.


Udnd die 4, die wirst du wahrscheinlich nicht sehen. Du kriegst Werte 
von 0 bis 1023. Eine 4 kriegst du bei ein paar Millivolt. So genau 
kannst du ein Poti gar nciht einstellen. Sinnvoller wird für erste Tests 
wohl eher

    if( wert > 512 )
      mach was
    else
      mach was anderes

sein

[Jörg W. (dl8dtl) (Moderator)]

Martin *** schrieb:

>   ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
>   ADCSRA |= (1<<ADEN);                  // ADC aktivieren

Es gibt keinen Grund, das auf zwei Anweisungen zu verteilen.

>   ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung

Du hast noch keinen Kanal im ADMUX gewählt, also misst du
ADC0 (alias PC0).

>   // Kanal waehlen, ohne andere Bits zu beeinflußen
>   ADMUX = (1<<PC5);

Erstens passt 'ohne andere Bits zu beeinflußen' nicht zur Aktion
(ADMUX wird komplett neu beschrieben, mit allen Bits), und
zweitens ist das vermutlich nicht, was du willst.  PC5 hat den
Wert 5, also wird hier ADMUX auf 0b00100000 gesetzt, was dir
einerseits die bereits ausgewählte ADC-Referenz wieder zunichte
macht, und andererseits ADLAR setzt.  Vermutlich willst du
aber PC5 (alias ADC5) als ADC-Eingang benutzen:

ADMUX = (1<<REFS1) | (1<<REFS0) | PC5;

>   if(test == 4) {
>     PORTD |= (1<<PD3);  //LED2
>   }
>   else {
>     PORTD &= ~(1<<PD3);  //LED2
> }

Antwort vom Sender Jerewan: "Im Prinzip ja, aber".

Die Wahrscheinlichkeit, dass dein ADC-Ergebnis exakt 4 beträgt,
ist ziemlich klein.  Du wirst wohl eher einen Vergleich auf
"größer/gleich" oder sowas haben wollen.

[Martin *. (mistermister606)]

Soooo nun funktioniert die Schaltung  :)
Ich danke euch recht herzlich für die Hilfe und eure Geduld :)