ATMega8 ADC Interrupt - lesen mehrerer Eingänge liefert Schrott

[Karsten W. (lsmod)]

Mit einem ATMega8 soll eine Phasenanschnitts-Steuerung unter Beachtung 
des Ausgangssignals realisiert werden.
Dafür wird aus der Wechselspannung ein Trigger-Signal hergestellt, 
welches hier mit einem Oszilloskop dargestellt ist (Sync).

Darüber hinaus wird dann zusätzlich die Ausgangsspannung und der 
Ausgangsstrom überwacht, wozu 2 weitere AD-Eingänge verwendet werden.
Es werden also nacheinander insgesamt 3 AD-Eingänge abwechselnd gelesen, 
hier wird aber nur das erste Signal als Beispiel dargestellt.

Wenn man das Signal mit einer Single-Shot-Conversion jeweils für die 3 
Eingänge einliest funktioniert das wunderbar (Single-Conversion).

Nun soll dieser Vorgang jedoch über den ADC-Interrupt im Hintergrund 
erfolgen, alleine schon um das lästige Polling zu vermeiden.

Im ersten Versuch wurde der Free-Running-Modus verwendet, beim dem 
jedoch ein Umschalten der Eingänge scheinbar nicht vorgesehen ist.
Egal wie man es macht, es kommt immer kompletter Datenschrott raus 
(Free-Running).

Nun gut - dann also mit Single-Conversion, jedoch führt dies ebenfalls 
nicht zu brauchbaren Ergebnissen sobald man den Interrupt verwendet 
(Interrupt-Single-Shot).

Der Quellcode dazu sieht folgendermaßen aus:

Initialisierung

volatile uint16_t Oszi[256];
volatile uint8_t  CountOszi;  
volatile uint8_t  CurADC;
volatile uint16_t ADCWert[3];

  ADMUX = (1 << REFS0);
  ADCSRA = (1 << ADPS2) | (1 << ADPS1);        // Frequenzvorteiler 64
  ADCSRA |= (1<<ADEN) | (1 << ADIE);                // ADC mit Interrupt aktivieren (benötigt 25 ADC Takte)

Interrupt

ISR(ADC_vect) {
  ADCWert[CurADC - 2] = ADCW;                          // ADC auslesen und speichern
  CurADC ++;
  if (CurADC > 4) CurADC = 2;
  
  ADMUX = (ADMUX & ~(0x1F)) | (CurADC & 0x1F);        // AD-Eingang wählen
  _delay_us(10);                    // Änderung des Eingangs abwarten
  ADCSRA |= (1 << ADSC);                     // Eine Wandlung "single conversion"

if (CurADC == 3) {
  Oszi[CountOszi] = ADCWert[0];
  CountOszi ++;
}

// Weitere Auswertung
}

Das Array Oszi[CountOszi] wird dann später ausgegeben und als Diagramm 
visualisiert wie in den Bildern zu sehen ist.

Hat jemand eine Idee was am Code falsch ist oder woran dies liegen 
könnte?

[Karl M. (Gast)]

Hallo,
Was soll das Auslesen des ADC Wert im Interrupt Betrieb? Hast du dir mal 
Gedanken gemacht, wie man so einen Eingang umschalten kann?
Steht natürlich im Datenblatt.
Darüber hinaus ist unklar, wie die ADC Eingänge beschaltet sind.
Sind sie nieder ohmig genug?

[Stefan F. (Gast)]

Spontan fällt mir das auf:

volatile uint16_t ADCWert[3];
volatile uint8_t  CurADC;

ISR(ADC_vect) {
  ADCWert[CurADC - 2] = ADCW; 
  ...
}

Daraus ergibt sich, dass CurADC die Werte 2 bis 4 haben muss. Du fängst 
aber mit 0 an, da du die Variable nicht initialisiert hast. Innerhalb 
der ISR wirst du daher irgendwo falsch in RAM schreiben, da kann alles 
Mögliche passierten.

Der delay hat in der ISR nichts verloren.

Bedenke, dass der ADC im freilaufenden Modus bereits mit der nächsten 
Messung beschäftigt ist, während die ISR abgearbeitet wird. Der Kanal, 
den du in der ISR einstellt, wirkt sich daher erst auf die übernächste 
Messung aus.

Ich hatte damit auch Schwierigkeiten und es damals bei meiner ersten 
Anwendung ganz ähnlich wie du umgesetzt. Der folgende Code war für einen 
Atmega16:

// Werte vom ADC
// Index 0-7 entsprechen Kanal 0-7
static volatile uint16_t adc_value[8];

// Unterbrechung vom ADC
ISR(ADC_vect) {

    // Messergebnis auslesen
    uint16_t value = ADC;
    uint8_t channel = ADMUX & 7;
    adc_value[channel]=value;

    // Zähle von 0-7
    if (++channel > 7) {
        channel=0;
    }

    // Schalte zum nächsten Kanal
    ADMUX=(ADMUX & ~7) | channel;

    // Starte nächste Messung
    ADCSRA |= (1<<ADSC); 
}

void init() {
    // Aktiviere ADC Konvertierung im Einzelschritt Modus 
    // mit Taktfrequenz (F_CPU/128)
    ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0) | (1<<ADIE) | (1<<ADSC); 
    ADMUX = REF_VCC;

    // Erlaube Unterbrechungen
    sei();
}

So funktioniert das jedenfalls tadellos, nur eben nicht freilaufend. Ist 
bei deiner Anwendung wichtig, dass die Messintervalle in 100% 
gleichmäßigen Intervallen stattfinden? Wenn ja, dann solltest du den 
freilaufenden Modus benutzen.

[Stefan F. (Gast)]

Karl M. schrieb:
> Was soll das Auslesen des ADC Wert im Interrupt Betrieb?

Irgendwie muss er ihn ja zu den richtigen Zeitpunkten auslesen. Wie 
hättest du das denn anders gemacht?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Karsten M. schrieb:
> jedoch führt dies ebenfalls nicht zu brauchbaren Ergebnissen sobald man
> den Interrupt verwendet (Interrupt-Single-Shot).
Was sieht man denn überhaupt auf den Bildern? Und was stimmt damit 
nicht?

Karl M. schrieb:
> Darüber hinaus ist unklar, wie die ADC Eingänge beschaltet sind.
> Sind sie nieder ohmig genug?
Wenn nicht, dann verschleppt man sich gern Teile des Messwerts vom zuvor 
gewandelten Kanal auf den eigentlichen Messwert, weil der S&H 
Kondensator nicht komplett umgeladen wird.

[Karsten W. (lsmod)]

Stefan ⛄ F. schrieb:

> Daraus ergibt sich, dass CurADC die Werte 2 bis 4 haben muss. Du fängst
> aber mit 0 an, da du die Variable nicht initialisiert hast. Innerhalb
> der ISR wirst du daher irgendwo falsch in RAM schreiben, da kann alles
> Mögliche passierten.

Stimmt - aber daran liegt es (leider) nicht.


> Der delay hat in der ISR nichts verloren.

Die wurde später testweise hinzugefügt und ist überflüssig.

> Bedenke, dass der ADC im freilaufenden Modus bereits mit der nächsten
> Messung beschäftigt ist, während die ISR abgearbeitet wird. Der Kanal,
> den du in der ISR einstellt, wirkt sich daher erst auf die übernächste
> Messung aus.

Ja genau - daher ist ein Umschalten der Eingänge nicht vorgesehen.

> Ich hatte damit auch Schwierigkeiten und es damals bei meiner ersten
> Anwendung ganz ähnlich wie du umgesetzt. Der folgende Code war für einen
> Atmega16:
>
>

...
>

>
> So funktioniert das jedenfalls tadellos, nur eben nicht freilaufend.

Ein prinzipieller Unterschied ist zu dem Code für den ATMega8 nicht zu 
sehen.
Dennoch ist das Ergebnis beim Einlesen in der Interrupt-Routine 
fundamental anders.

> Ist bei deiner Anwendung wichtig, dass die Messintervalle in 100%
> gleichmäßigen Intervallen stattfinden? Wenn ja, dann solltest du den
> freilaufenden Modus benutzen.

Nein - das Messintervall muß ja nur innerhalb 20 ms einigermaßen 
gleichmäßig sein, wobei die Interruptroutine ja sehr gleichmäßig läuft, 
da die Auswertung erst später erfolgt.

[Karsten W. (lsmod)]

Lothar M. schrieb:
> Karsten M. schrieb:
>> jedoch führt dies ebenfalls nicht zu brauchbaren Ergebnissen sobald man
>> den Interrupt verwendet (Interrupt-Single-Shot).
> Was sieht man denn überhaupt auf den Bildern? Und was stimmt damit
> nicht?

Geben die Bilder Single-Conversion.png und Interrupt-Single-Shot.png für 
Dich den gleichen Signalverlauf wieder?

> Karl M. schrieb:
>> Darüber hinaus ist unklar, wie die ADC Eingänge beschaltet sind.
>> Sind sie nieder ohmig genug?
> Wenn nicht, dann verschleppt man sich gern Teile des Messwerts vom zuvor
> gewandelten Kanal auf den eigentlichen Messwert, weil der S&H
> Kondensator nicht komplett umgeladen wird.

Mag alles sein, aber das erklärt nicht das recht perfekte Ergebnis bei
single-conversion im Vergleich zu dem Ergebnis der gleichen 
Vorgehensweise in einem ADC-Interrupt.

[Karsten W. (lsmod)]

Hier noch ein weiteres aktuelles Ergebnis mit einer korrekten 
Initialisierung

volatile uint8_t CurADC = 2;

und ohne die 10µs verschwendete Wartezeit.

Die grüne Linie ist übrigens ein gleitender Mittelwert über 5 Werte.
Das ist hier ebenfalls nicht von Bedeutung.

[Torn (Gast)]

Karsten M. schrieb:

>> Daraus ergibt sich, dass CurADC die Werte 2 bis 4 haben muss. Du fängst
>> aber mit 0 an, da du die Variable nicht initialisiert hast. Innerhalb
>> der ISR wirst du daher irgendwo falsch in RAM schreiben, da kann alles
>> Mögliche passierten.

> Stimmt - aber daran liegt es (leider) nicht.

Den seine Beiträge musst du irgnorieren.

[Oliver S. (oliverso)]

Karsten M. schrieb:
> Im ersten Versuch wurde der Free-Running-Modus verwendet, beim dem
> jedoch ein Umschalten der Eingänge scheinbar nicht vorgesehen ist.
> Egal wie man es macht, es kommt immer kompletter Datenschrott raus
> (Free-Running).

Datasheet:

If both ADFR and ADEN is written to one, an interrupt event can occur at any time. If the
ADMUX Register is changed in this period, the user cannot tell if the next conversion is based
on the old or the new settings. ADMUX can be safely updated in the following ways:
1. When ADFR or ADEN is cleared
2. During conversion, minimum one ADC clock cycle after the trigger event
3. After a conversion, before the Interrupt Flag used as trigger source is cleared
When updating ADMUX in one of these conditions, the new settings will affect the next ADC
conversion.

Oliver

[Stefan F. (Gast)]

Oliver S. schrieb:
> 2. During conversion, minimum one ADC clock cycle after the trigger
> event

Ich denke, das ist erfüllt, wenn man den Multiplexer innerhalb der ISR 
umschaltet.

[Karsten W. (lsmod)]

Torn schrieb:
> Den seine Beiträge musst du irgnorieren.

Dennoch wurden konkrete Fehler aufgezeigt.
Das ist näher an der Lösung drann als die anderen Tips.

Die Impedanz am Eingang liegt übrigens unter 47 KOhm.

[Stefan F. (Gast)]

Karsten M. schrieb:
> Die Impedanz am Eingang liegt übrigens unter 47 KOhm.

Sie soll unter 10kΩ liegen!

[Udo S. (urschmitt)]

Karsten M. schrieb:
> Hier noch ein weiteres aktuelles Ergebnis mit einer korrekten
> Initialisierung

Wie wäre es wenn du mal anfängst auf die Rückfragen zu antworten:
1. Wie ist die Eingangsbeschaltung
2. Wie sehen die gemessenen Werte aus, und welch Werte erwartest du?
3. Woher weisst du daß deine gemessenen Werte falsch sind, was ist deine 
Referenz?

Wenn die grüne Kurve die "schlechte" sein soll, dann könnte das genau 
der Effekt einer zu hohen (dynamischen) Impedanz der Quelle sein.

[Oliver S. (oliverso)]

REFS1 REFS0 ADLAR – MUX3 MUX2 MUX1 MUX0 ADMUX

Karsten M. schrieb:
> ADMUX = (ADMUX & ~(0x1F)) | (CurADC & 0x1F);

Hm...

Oliver

[Karsten W. (lsmod)]

Ja - aber es bleibt dabei - das nächste sample & hold ist bereits im 
Gange.
Hier kann man nicht sinnvoll für jede einzelne Messung den Eingang 
umschalten.

Höchstens in mit einem Timer in einem anderen getimten Interrupt und 
selbst dann ist es fragwürdig ob das sauber funktioniert.

[Stefan F. (Gast)]

Oliver S. schrieb:
> Hm...

Bitte verrate uns dein Geheimnis!

Der Filter 0x1F ist mir auch aufgefallen, aber ich glaube nicht, dass er 
hier ein Problem auslöst.

[Stefan F. (Gast)]

Karsten M. schrieb:
> Hier kann man nicht sinnvoll für jede einzelne Messung den Eingang
> umschalten.

Doch kann man. Man muss halt nur beachten, dass das Ergebnis erst im 
übernächsten Interrupt eintrifft. Der Multiplexer-Wert muss einfach nur 
um zwei Positionen versetzt rotieren.

[Karsten W. (lsmod)]

Stefan ⛄ F. schrieb:
> Oliver S. schrieb:
>> Hm...
>
> Bitte verrate uns dein Geheimnis!
>
> Der Filter 0x1F ist mir auch aufgefallen, aber ich glaube nicht, dass er
> hier ein Problem auslöst.

Diese Zeile wurde aus irgendeiner Library einfach übernommen.
Das lässt sich geschickter ausdrücken.

Aber es funktioniert ja wenn man in der Main-Loop damit die Eingänge 
setzt und ausliest wie man oben sehen kann.

[Karsten W. (lsmod)]

Stefan ⛄ F. schrieb:
> Doch kann man. Man muss halt nur beachten, dass das Ergebnis erst im
> übernächsten Interrupt eintrifft. Der Multiplexer-Wert muss einfach nur
> um zwei Positionen versetzt rotieren.

Könntest Du Deine Rotation bitte in einem Beispiel ausdrücken?

[Stefan F. (Gast)]

> Könntest Du Deine Rotation bitte in einem Beispiel ausdrücken?

Horizontal läuft die Zeit (=ISR Aufrufe).

falsch:

CurADC       2  3  4  2  3  4  2  3  4
Array-Index  0  1  2  0  1  2  0  1  2

richtig:

CurADC       2  3  4  2  3  4  2  3  4
Array-Index  2  0  1  2  0  1  2  0  1

Wobei CurADC hier nicht anzeigt, welchen Channel du gerade gemessen 
hast, sondern welcher Channel in diesem ISR Aufruf in den MUX 
geschrieben wird.

Also erst CurADC inkrementieren, dann ADC auslesen, dann gemäß obigem 
Mapping ins Array schreiben, dann den neuen Wert ins ADMUX Register 
schreiben.

Oder meinetwegen auch: Erst CurADC inkrementieren, den neuen Wert ins 
ADMUX Register schreiben, dann ADC auslesen, dann gemäß obigem Mapping 
ins Array schreiben.

[Karsten W. (lsmod)]

Verstehe - dies wurde folgendermaßen abgebildet:

  /*
  * Kanal 2 wird unter ADCWert[0] gespeichert
  * CurADC = 3 wird gesetzt
  * K   [S]   case    (ADC-Kanal  [im Array]   case)
  * 2 -> 0 -> 3       Phase Wechselspannung 20V
  * 3 -> 1 -> 4       Strommessung Hochspannung
  * 4 -> 2 -> 2       Spannungsmessung Hochspannung
  */
  switch (CurADC) {
    case ...
  }

Zugegebenermaßen von der Programmierlogik her nicht sehr elegant. :-)

[Karsten W. (lsmod)]

Stefan ⛄ F. schrieb:
> Karsten M. schrieb:
>> Die Impedanz am Eingang liegt übrigens unter 47 KOhm.
>
> Sie soll unter 10kΩ liegen!

Wo steht das?

Bei 100 MOhm Eingangswiderstand?

Außerdem funktioniert es ja prächtig wenn man single-conversion 
außerhalb des Interrupt durchführt.

[Oliver S. (oliverso)]

Stefan ⛄ F. schrieb:
> Bitte verrate uns dein Geheimnis!
>
> Der Filter 0x1F ist mir auch aufgefallen, aber ich glaube nicht, dass er
> hier ein Problem auslöst.

Ok, ich hab da was verwechselt.

Stefan ⛄ F. schrieb:
> Karsten M. schrieb:
>> Hier kann man nicht sinnvoll für jede einzelne Messung den Eingang
>> umschalten.
>
> Doch kann man. Man muss halt nur beachten, dass das Ergebnis erst im
> übernächsten Interrupt eintrifft. Der Multiplexer-Wert muss einfach nur
> um zwei Positionen versetzt rotieren.

Das führt dann aber nur dazu, daß die Kanäle komplett rotiert sind, 
nicht zur (vermuteten) Versmischung der Daten.

Karsten M. schrieb:
> Die grüne Linie ist übrigens ein gleitender Mittelwert über 5 Werte.
> Das ist hier ebenfalls nicht von Bedeutung.

Da es ja offensichtlich an all dem, was du bisher gezeigt hast, eher 
nicht liegt, wird es Zeit, mal daß ganze Programm zu zeigen.

Oliver

[Stefan F. (Gast)]

> Zugegebenermaßen von der Programmierlogik her nicht sehr elegant. :-)

Deswegen: Wie gefällt Dir das?:

volatile uint8_t  curChannel=7;
volatile uint8_t  muxValue=1;
volatile uint16_t adcValues[8];

ISR(ADC_vect) {    
    adcValues[curChannel] = ADCW;
    ADMUX = (ADMUX & 0xF0) + muxValue;

    curChannel = (curChannel+1) & 7;
    muxValue = (muxValue+1) & 7;  
}

Starte den ADC auf Channel 0, dann wird folgendes Passieren:

1. IRQ, curChannel=7, muxValue=1, ADC0 -> adcValues[7]   falsch zugeordnet
2. IRQ, curChannel=0, muxValue=2, ADC0 -> adcValues[0]   ab hier richtig zugeordnet 
3. IRQ, curChannel=1, muxValue=3, ADC1 -> adcValues[1]
4. IRQ, curChannel=2, muxValue=4, ADC1 -> adcValues[2]
5. IRQ, curChannel=3, muxValue=5, ADC1 -> adcValues[3]
6. IRQ, curChannel=4, muxValue=6, ADC1 -> adcValues[4]
7. IRQ, curChannel=5, muxValue=7, ADC1 -> adcValues[5]
8. IRQ, curChannel=6, muxValue=0, ADC1 -> adcValues[6]
9. IRQ, curChannel=7, muxValue=1, ADC1 -> adcValues[7]
10.IRQ, curChannel=0, muxValue=2, ADC1 -> adcValues[0]
11.IRQ, curChannel=1, muxValue=3, ADC1 -> adcValues[1]

Das erste Messergebnis musst du verwerfen weil es im falschen 
Array-Index gespeichert wird. Alle folgenden sind verwendbar.

Der ADC ist schnell genug, um einfach alle 8 Kanäle Zyklisch zu messen. 
Wenn du willst, kannst du das natürlich auch auf weniger Kanäle 
reduzieren.

[Stefan F. (Gast)]

Karsten M. schrieb:
>>> Die Impedanz am Eingang liegt übrigens unter 47 KOhm.
>> Sie soll unter 10kΩ liegen!
> Wo steht das?

Weiß ich nicht auswendig. ich glaube in irgendeiner Appnote. Je höher 
die Impedanz der Quelle ist, umso ungenauer die Messergebnisse und umso 
mehr verschleift man Spannungen von einem Eingang zum nächsten, weil der 
Sample&Hold Kondensator im ADC Überreste der vorherigen Messung enthält.

> Außerdem funktioniert es ja prächtig wenn man single-conversion
> außerhalb des Interrupt durchführt.

Im Freilaufenden Modus ist die Zeitspanne zwischen dem Umschalten des 
Multiplexers und der Messung kürzer.

[Stefan F. (Gast)]

Scheiße, copy-paste Fehler bei den ADCx Nummern. Hier die Korrektur:

Starte den ADC auf Channel 0, dann wird folgendes Passieren:

1. IRQ, curChannel=7, muxValue=1, ADC0 -> adcValues[7]   falsch zugeordnet
2. IRQ, curChannel=0, muxValue=2, ADC0 -> adcValues[0]   ab hier richtig zugeordnet 
3. IRQ, curChannel=1, muxValue=3, ADC1 -> adcValues[1]
4. IRQ, curChannel=2, muxValue=4, ADC2 -> adcValues[2]
5. IRQ, curChannel=3, muxValue=5, ADC3 -> adcValues[3]
6. IRQ, curChannel=4, muxValue=6, ADC4 -> adcValues[4]
7. IRQ, curChannel=5, muxValue=7, ADC5 -> adcValues[5]
8. IRQ, curChannel=6, muxValue=0, ADC6 -> adcValues[6]
9. IRQ, curChannel=7, muxValue=1, ADC7 -> adcValues[7]
10.IRQ, curChannel=0, muxValue=2, ADC0 -> adcValues[0]
11.IRQ, curChannel=1, muxValue=3, ADC1 -> adcValues[1]

[Karsten W. (lsmod)]

Ja - das ist eleganteres C.

Allerdings hat das IC nur 6 AD-Eingänge und es werden nur 3 benutzt.

[Oliver S. (oliverso)]

Stefan ⛄ F. schrieb:
> Karsten M. schrieb:
>>>> Die Impedanz am Eingang liegt übrigens unter 47 KOhm.
>>> Sie soll unter 10kΩ liegen!
>> Wo steht das?
>
> Weiß ich nicht auswendig. ich glaube in irgendeiner Appnote.

Das steht auch im Datenblatt, wo sonst.

Oliver

[Stefan F. (Gast)]

Karsten M. schrieb:
> Allerdings hat das IC nur 6 AD-Eingänge und es werden nur 3 benutzt.

Das ist egal, dann nutzt du eben nicht alle Werte aus dem Array. Das 
sind doch nur ein paar Bytes!

Dafür hast du eine schöne 1:1 Zuordnung von ADC Kanal zu Array-Index und 
kannst alle Kanäle Nutzen.

Wenn du das auf die 3 Kanäle reduzierst, wird der Code schwer 
verständlich und vermutlich auch größer.

[S. Landolt (Gast)]

> Das steht auch im Datenblatt, wo sonst.

[Karsten W. (lsmod)]

Zwischendurch kam die Kritik das nicht der vollständige Code 
veröffentlich worden ist.
Da ist grundsätzlich was drann, daher hier eine Minimalversion mit ihrem 
dazugehörigen Ergebnis.

Der Fehler lag einfach daran das bei der Ausgabe der Werte auf der UART 
der Interrupt nicht deaktiviert worden ist!
Dadurch wurde das Array Oszi während der Ausgabe überschrieben.

Hier der Democode (bis auf die UART) der zeigt das es funktioniert.
Daher gilt wie immer: Kaum macht man es richtig und schon 
funktioniert's.

// VARIABLEN ================================================

volatile uint16_t Oszi[256];        // Oszilloskop
volatile uint8_t  CountOszi;        // Aktuelles Puffer-Byte
volatile uint8_t  CurADC;        // Aktueller AD-Kanal
volatile uint16_t ADCWert[3];        // Gemessene ADC-Werte

static char spuffer[17];          // String 


/******************************************************//**
 * ADC initialisieren
 **********************************************************/
void ADC_Init(void) {
  ADMUX = (1 << REFS0);

  ADCSRA = (1 << ADPS2) | (1 << ADPS1);        // Frequenzvorteiler 64
  ADCSRA |= (1<<ADEN) | (1 << ADIE);                // ADC mit Interrupt aktivieren (benötigt 25 ADC Takte)

  ADCSRA |= (1 << ADSC);              // Eine ADC-Wandlung starten
  while (ADCSRA & (1 << ADSC) ) {}          // Auf Abschluss der Konvertierung warten

  if (ADCW);
  
  CurADC = 2;
}


/******************************************************//**
 * MAIN
 **********************************************************/
int main(void) {

  DDRB  = 0b00111111;
  DDRC  = 0b00000000;
  DDRD  = 0b11111010;
  
  PORTB = 0b00111101;
  PORTC = 0b00000000;
  PORTD = 0b11110111;

  uart_init();
  ADC_Init();

  sei();

  uart_string("Oszi-Debug");
  uart_string(CR);

// HAUPTSCHLEIFE =====================================================
  while(1) {
    _delay_ms(20000);
    cli();
    for(uint8_t i = 0; i < 255; i ++) {
      utoa(Oszi[i], spuffer, 10);
      uart_string(spuffer);
      uart_string(CR);
    }
    uart_string("=== Ende ===");
    uart_string(CR);
    sei();
  }

}


/******************************************************//**
 * ADC Interrupt
 **********************************************************/
ISR(ADC_vect) {
  ADCWert[CurADC - 2] = ADCW;                          // ADC auslesen und speichern
  CurADC ++;
  if (CurADC > 4) CurADC = 2;
  
  ADMUX = (ADMUX & ~(0x1F)) | (CurADC & 0x1F);        // AD-Eingang wählen
  ADCSRA |= (1 << ADSC);                     // Eine Wandlung "single conversion"
  
  /*
  * Kanal 2 wird unter ADCWert[0] gespeichert
  * CurADC = 3 wird gesetzt
  * K   [S]   case    (ADC-Kanal  [im Array]   case)
  * 2 -> 0 -> 3       Phase Wechselspannung 20V
  * 3 -> 1 -> 4       Strommessung Hochspannung
  * 4 -> 2 -> 2       Spannungsmessung Hochspannung
  */
  switch (CurADC) {                  // AD-Werte immer nach Erfassung auswerten
    case 3:                    // Detektion der Phase
      Oszi[CountOszi] = ADCWert[0];
      CountOszi ++;
      break;
    case 4:                    // Strommessung
//       Oszi[CountOszi] = ADCWert[1];
//       CountOszi ++;
      break;
    case 2:                    // Spannungsmessung
//       Oszi[CountOszi] = ADCWert[2];
//       CountOszi ++;
      break;
  }
}

Danke für die Unterstützung!

[Soul E. (Gast)]

Stefan ⛄ F. schrieb:

> Karsten M. schrieb:
>> Die Impedanz am Eingang liegt übrigens unter 47 KOhm.
>
> Sie soll unter 10kΩ liegen!

Wichtiger ist deren dynamisches Verhalten, und das verbessert man durch 
Stützkondensatoren direkt an den ADC-Pins. Jeweils 4,7 nF nach Masse, 
mit weniger als 5 mm Leitungslänge angebunden.

Sonst gibt es beim Umladen des Sample&Hold-Kondensators einen kurzen 
Spannungseinbruch am Pin (den man teilweise sogar von aussen mit dem 
Oszilloskop sehen kann), und der Messwert hängt immer ein bisschen vom 
vorherigen Kanal ab (Übersprechen).

[Georg G. (df2au)]

soul e. schrieb:
> Stützkondensatoren direkt an den ADC-Pins. Jeweils 4,7 nF nach Masse,

Ein toller Beitrag. Hast du dir mal die Impedanz von 4,7nF bei nur 10kHz 
ausgerechnet? Nicht jeder User will Gleichstrom messen. Ein Kondensator 
am ADC-Pin ist die schlechteste Variante. Du bekommst bei 
nicht-sinusförmigen Signalen Verzerrungen. Ein vernünftig ausgelegter 
OpAmp ist da angesagt.

[Wolfgang (Gast)]

Stefan ⛄ F. schrieb:
> Wenn du das auf die 3 Kanäle reduzierst, wird der Code schwer
> verständlich und vermutlich auch größer.

Mit 4 Kanälen  lässt sich der Code genauso kompakt formulieren und er 
wird kein Bisschen größer.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Mit ein paar defines wird das ganze sehr übersichtlich und funktioniert 
gut:

// definitions for the ADC

//! The ADC channel where the small plate control is connected.
#define ADC_CHANNEL_1   0
//! The ADC channel where the large plate control is connected.
#define ADC_CHANNEL_2   1
//! The ADC channel where the oven control is connected.
#define ADC_CHANNEL_3   2
//! The ADC channel where the NTC input is connected.
#define ADC_CHANNEL_4   3


//! ADC clock prescaler 2 setting.
#define ADC_PRESCALER_2        ((0 << ADPS2) | (0 << ADPS1) | (1 << ADPS0))

//! ADC clock prescaler 4 setting.
#define ADC_PRESCALER_4        ((0 << ADPS2) | (1 << ADPS1) | (0 << ADPS0))

//! ADC clock prescaler 8 setting.
#define ADC_PRESCALER_8        ((0 << ADPS2) | (1 << ADPS1) | (1 << ADPS0))

//! ADC clock prescaler 16 setting.
#define ADC_PRESCALER_16        ((1 << ADPS2) | (0 << ADPS1) | (0 << ADPS0))

//! ADC clock prescaler 64 setting.
#define ADC_PRESCALER_64        ((1 << ADPS2) | (1 << ADPS1) | (0 << ADPS0))

//! ADC clock prescaler 64 setting.
#define ADC_PRESCALER_128        ((1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0))

//! ADC clock prescaler used in this application.
#define ADC_PRESCALER           ADC_PRESCALER_16

//! ADC internal 1.1 bandgap voltage reference channel value.
#define ADC_REFERENCE_VOLTAGE_11INTERNAL    ((1 << REFS1) | (0 << REFS0))
//! ADC VCC voltage reference channel value.
#define ADC_REFERENCE_VOLTAGE_VCC           ((0 << REFS1) | (0 << REFS0))
//! ADC AREF voltage reference channel value.
#define ADC_REFERENCE_VOLTAGE_AREF          ((0 << REFS1) | (1 << REFS0))

/*! ADC voltage reference used in this application.
 *
 *  \todo Select ADC voltage reference channel.
 */
#define ADC_REFERENCE_VOLTAGE   ADC_REFERENCE_VOLTAGE_VCC

//! ADMUX settings for channel 1
#define ADMUX_CH1  (ADC_REFERENCE_VOLTAGE | (ADC_CHANNEL_1 << MUX0))

//! ADMUX settings for channel 2
#define ADMUX_CH2  (ADC_REFERENCE_VOLTAGE | (ADC_CHANNEL_2 << MUX0))

//! ADMUX settings for channel 3
#define ADMUX_CH3  (ADC_REFERENCE_VOLTAGE | (ADC_CHANNEL_3 << MUX0))

//! ADMUX settings for channel 4
#define ADMUX_CH4  (ADC_REFERENCE_VOLTAGE | (ADC_CHANNEL_4 << MUX0))

// variables
// ADC results
volatile uint8_t channel1, channel2, channel3, channel4;
/* ADC complete interrupt 
 * this version scans 4 channels (0 to 3) and 
 * places the results in globals channel1 to channel4 
 * Note that this relies on a left adjusted result and we only use 8 bits
 * resolution which is ample for this application */
ISR(ADC_vect)
{
  switch (ADMUX)
    {
      case ADMUX_CH1:
          channel1 = (channel1 + ADCH) >> 1; // do some averaging with the last value obtained
          ADMUX = ADMUX_CH2;
          break;
      case ADMUX_CH2:
          channel2 = (channel2 + ADCH) >> 1;
          ADMUX = ADMUX_CH3; 
          break;        
      case ADMUX_CH3:
          channel3 = (channel3 + ADCH) >> 1;
          ADMUX = ADMUX_CH4; 
          break;        
      case ADMUX_CH4:
          channel4 = (channel4 + ADCH) >> 1;
          ADMUX = ADMUX_CH1; 
          break;        
      default: ADMUX = ADMUX_CH1;
        break;
   }
// restart the ADC
   ADCSRA = (1 << ADEN) | (1 << ADSC) | (0 << ADATE) | (1 << ADIF) | (1 << ADIE) | ADC_PRESCALER;
}

Die Glättung usw muss man ja nicht nutzen und selbstverständlich klappt 
das auch mit 10 Bit Werten.

[Karsten W. (lsmod)]

Das ist schön übersichtlich.

[Stefan F. (Gast)]

Wolfgang schrieb:
> Mit 4 Kanälen  lässt sich der Code genauso kompakt formulieren und er
> wird kein Bisschen größer.

Stimmt, nur ünglücklicherweise nutzt er die Kanäle 2, 3 und 4. Kanal 4 
liegt gerade über der Schwelle.

Die Lösung mit dem Switch-Case finde ich auch Ok. Ist nicht ganz so 
kompakt aber gut lesbar, und das ist am wichtigsten.

[Wolfgang (Gast)]

Stefan ⛄ F. schrieb:
> Stimmt, nur ünglücklicherweise nutzt er die Kanäle 2, 3 und 4. Kanal 4
> liegt gerade über der Schwelle.

Das kostet dich genau ein "+1" in der Zeile

    ADMUX = (ADMUX & 0xF0) + muxValue;

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Stefan ⛄ F. schrieb:
> Ist nicht ganz so
> kompakt aber gut lesbar, und das ist am wichtigsten.

Ist so eben auch easy, für verschiedene Kanäle verschiedene Setups zu 
machen, da kann man Referenzspannung oder bei anderen AVR auch auf 
bipolar usw. umschalten, ohne am Programm irgendwas zu ändern. Define 
ändern und fertisch.