Mega32 AD Wandlung Aufruf in der Main oder in ISR?

[Matthias M. (Gast)]

Hallo liebe Forumsgemeinde,

bei mir im Programm läuft erfolgreich eine ADC Wandlung nach folgendem 
Beispiel:

// Diese Beispiel zeigt die Anwendung des ADC eines ATmega169
// unter Verwendung der internen Referenzspannung von nominell 1,1V.
// Zur Anpassung an andere AVR und/oder andere Referenzspannungen
// siehe Erläuterungen in diesem Tutorial und im Datenblatt
 
/* ADC initialisieren */
void ADC_Init(void) {
 
  uint16_t result;
 
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = (1<<REFS0);    
  // oder interne Referenzspannung als Referenz für den ADC wählen:
  // ADMUX = (1<<REFS1) | (1<<REFS0);
 
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten
  // schon auf 0, also single conversion
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
  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;
}
 
/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}
 
/* ADC Mehrfachmessung mit Mittelwertbbildung */
/* beachte: Wertebereich der Summenvariablen */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t nsamples )
{
  uint32_t sum = 0;
 
  for (uint8_t i = 0; i < nsamples; ++i ) {
    sum += ADC_Read( channel );
  }
 
  return (uint16_t)( sum / nsamples );
}
 
...
 
/* Beispielaufrufe: */
 
int main()
{
  uint16_t adcval;
  ADC_Init();
 
  while( 1 ) {
    adcval = ADC_Read(0);  // Kanal 0
    // mach was mit adcval

  }
}

Mein CPU läuft mit 8 MHz, sprich in der Main wird ADC_Read mit CPU Takt 
aufgerufen was viel zu viel ist. Nun bin ich bei meinen Recherchen auf 
die ISR(ADC_vect) gestoßen.

Kann ich statt in der Main auch einfach folgendes schreiben?

ISR(ADV_vect) {
   adcval = ADC_Read(0);  // Kanal 0
}

Und mir den Wert von adcval in der Main z.b. auf ein LCD ausgeben 
lassen?

Soweit ich das verstanden habe wird die ISR immer dann aufgerufen wenn 
ein neuer AD Wert vorliegt, stimmt das?

Ich hab übrigens noch einen weiteren Timer (ISR( TIMER0_OVF_vect ) alle 
10ms am laufen, stören die beiden sich?

Gruß

[Karl H. (kbuchegg)]

Matthias M. schrieb:

> Mein CPU läuft mit 8 MHz, sprich in der Main wird ADC_Read mit CPU Takt
> aufgerufen was viel zu viel ist.

Was heisst das: 'viel zu viel'


> Nun bin ich bei meinen Recherchen auf
> die ISR(ADC_vect) gestoßen.
>
> Kann ich statt in der Main auch einfach folgendes schreiben?

Können tust du schon. Sinnlos ist es auch.

>
>

> ISR(ADV_vect) {
>    adcval = ADC_Read(0);  // Kanal 0
> }
>

Nö.
Wenn die ISR aufgerufen wird, dann liegt ein ADC Ergebnis vor. Das 
WISSEN wir, sonst wäre die ISR ja nicht aufgerufen worden.

Ergo

ISR(ADV_vect) {
  adcval = ADC;
}

fertig.
Jetzt musst du nur noch an strategisch günstigen Positionen den 
ADC-Wandler anstossen, eine Wandlung vorzunehmen. Ist er damit fertig, 
dann wird die ISR aufgerufen.

Aber im Ernst: Ist das wirlich ein großes Problem, dass die 
Hauptschleife ein paar Takte verbrutzelt, weil sie aktiv auf den ADC 
wartet? Immerhin hat das den Charme, dass du von jedem Ergebnis in der 
Hauptschleife auch den Zeitpunkt weißt, wann es während eines Durchgangs 
durch die Hauptschleife entstanden ist. Und wenn einem die Wartezeit 
dann wirklich stört, dann kann man das ganze auch so umformen, dass die 
Wandlung läuft, während der µC in der Hauptschleife gerade was anderes 
macht. Nach dem Muster

  ...

  while( 1 )
  {
     ADC Ergebnis holen
     nächste Wandlung starten

     Ergebnis bearbeiten
  }

Die Wandlungt läuft, während das letzte Eregbnis bearbeitet wird. Geht 
die Hauptschleife in den nächsten Durchgang, dann ist der ADC (meistens) 
längst mit der Arbeit fertig. Man holt sich das Ergebnis ab und startet 
gleich die nächste Wandlung. Während die läuft, bearbeitet man das 
zuletzt geholte Ergebnis. usw. usw.

[Matthias M. (Gast)]

Danke für die Antwort, mir geht es weniger um die Takte die der 
Controller damit verbringt den AD Wert zu ermitteln sondern vielmehr um 
einen sauberen Code und da ich einfach keine x-Millionen Auswertungen / 
Sekunde brauch.

Sprich die ADC_vect ISR ist nur sinnvoll um die Main zu entlasten und 
dort die Werte des AD's in eine entsprechende Variable zu schreiben?

[Karl H. (kbuchegg)]

Matthias M. schrieb:
> Danke für die Antwort, mir geht es weniger um die Takte die der
> Controller damit verbringt den AD Wert zu ermitteln sondern vielmehr um
> einen sauberen Code

was ist an

  while( 1 ) {
    adcval = ADC_Read(0);  // Kanal 0

    ...
  }

unsauber.
So wie ich das sehe, ist das die einfachste, übersichtlichste und am 
leichtesten zu durchschauende Variante.
Jede andere Version (inklusive ISR) fügt nur mehr Komplexität hinzu.

> und da ich einfach keine x-Millionen Auswertungen /
> Sekunde brauch.

Du musst ja nicht bei JEDEM Schleifendurchlauf den ADC abfragen.
Wenn du sagst, du brauchst keine x Millionen pro Sekunde, erhebt sich 
sofort die Frage: ja, wieviele brauchst du denn?
D.h. du musst dir dann sowieso einen Meschanismus einfallen lassen, wie 
du diese spezielle Anzahl an Abfragen zeitmässig realisierst. Zb. mit 
einem Timer, der pro Sekunde y mal den Vorgang anstösst (nach dem 
Vorbild einer blinkenden LED).

> Sprich die ADC_vect ISR ist nur sinnvoll um die Main zu entlasten und
> dort die Werte des AD's in eine entsprechende Variable zu schreiben?

Ist eine Sichtweise.
Eine andere kann sein, dass der ADC mit maximaler Geschwindigkeit 
wandeln und seine Ergebnisse (eine gewisse Anzahl an Ergebnissen) erst 
mal im Speicher ablegen soll.