ATmega16: ADC0 Wert schwankt obwohl konst. Spannung anliegt

Ist AVCC konstant?
Du solltest auch vermeiden, irgendwelche I/O Pins zu verändern, während 
der ADC eine Messung durchführt.
Was meinst Du mit "schwanken"? Wie schnell und wie stark schwankt es?

David schrieb:
> aber bei einem der 3 treten ziemlich starke Schwankungen auf
Bei welchem?

Und warum schreibst du da so einen Spaghetti-Code? Du machst dreimal 
fast das selbe, da wäre ein Schleife oder ein Zustandsautomat die 
richtige Lösung. Und wenn du jetzt sagst "Zustandsautomat? Zu 
kompliziert!" dann lass dir gesagt sein: du hast schon einen gebaut. 
Aber eben einen umständlichen:

1

    if (ADMUX & (1<<MUX0))         

2

      :

3

      ADMUX &= ~(1<<MUX0);

4

      ADMUX |= (1<<MUX1);

5

    }  

6

    else

7

    {

8

      if (ADMUX & (1<<MUX1))

9

        :

10

        ADMUX &= ~(1<<MUX0);

11

        ADMUX &= ~(1<<MUX1);

12

        ADMUX |= (1<<MUX2);

13

14

      }  

15

      else

16

      {

17

        if(ADMUX & (1<<MUX2))

18

          :

19

          ADMUX &= ~(1<<MUX2);

20

          ADMUX |= (1<<MUX0);

21

          _delay_ms(100);

22

        }

23

      }

24

    }

Das ist ein Automat, weil bei jedem Schleifendurchlauf anhand der 
"Zustandvariablen" ADMUX ausgesucht wird, welcher Kanal jetzt gewandelt 
werden soll.


BTW, das finde ich allerliebst:

1

    if (ADMUX & (1<<MUX0))  // erster wert jeder Wandlung verwerfen, damit sich ADC Multiplexer einschwingen kann

Leider hast du da offenbar das Datenblatt nicht ganz oder nicht an der 
richtigen Stelle gelesen. Das wäre ja ein total vermurkster uC, wenn man 
nach dem Umschalten des MUX jedesmal eine Wandlung wegwerfen müsste...

David schrieb:
> Eingänge ADC0, ADC1, ADC2.
Guck ins Datenblatt. Da ist eine Tabelle drin.
Da siehst du, was du dafür einstellen musst.
Und was du dafür bekommst:
ADMUX &= ~(1<<MUX0);
ADMUX &= ~(1<<MUX1);
ADMUX |= (1<<MUX2);

Kleiner Tip: MUX2 wird erst ab ADC4 interessant.

mfg.

Falsch ist das nicht, nur unelegant. Weil du mehrmals fast identischen 
Code wiederholt hast. Wirklich elegant wäre, den ADC Interrupt zu 
nutzen:

1

#include <avr/interrupt.h>

2

#include <stdint.h>

3

4

// Werte vom ADC, für die vier Kanäle

5

static volatile uint16_t adc_value[4];

6

7

// Unterbrechung vom ADC

8

ISR(ADC_vect) {

9

    // Lese den ADC aus

10

    uint8_t channel = ADMUX & 7;  

11

    adc_value[channel] = ADC;

12

13

    // Schalte auf den nächsten Kanal um.

14

    if (++channel > 3) {

15

        channel=0;

16

    }

17

    ADMUX=(ADMUX & ~7) | channel;

18

19

    // Starte nächste Messung

20

    ADCSRA |= (1<<ADSC); 

21

}

22

23

void main() {

24

    // Initialisiere den ADC

25

    ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0) | (1<<ADIE) | (1<<ADSC); 

26

    ADMUX = REF_VCC;

27

28

    // Erlaube Unterbrechungen

29

    sei();

30

31

    uint8_t channel=0;

32

    while(1) {

33

       _delay_ms(100);

34

       // gib den Wert von adc_value[channel] hier aus

35

       ...

36

       // Zum nächsten Kanal wechseln

37

       if (++channel > 3) {

38

        channel=0;

39

       }

40

    }

41

}

> Er braucht aber nur Channel 0,1 und 2.

Oh, hab ich übersehen. Aber das macht nichts, mein Codebeispiel ist ja 
leicht auf beliebige Anzahl von Kanälen umstellbar.

David schrieb:
> Danke das hat echt geholfen.
DAS würde mir zu denken geben. Denn es wurde ja gar nicht dein Problem 
behoben, sondern dein Code überarbeitet...

David schrieb:
> ADMUX=(ADMUX & ~7) | channel;
Da werden zuerst 3 Bits gelöscht ("und nicht"), anschließend der 
channel gesetzt ("oder"). Siehe Bitmanipulation

> ADMUX=(ADMUX & ~7) | channel;

Oder in deutsch formuliert: Stelle die Kanalnummer ein und lasse dabei 
die anderen Bits in dem ADMUX Register unverändert.

Stefan Frings schrieb:
> ADMUX=(ADMUX & ~7) | channel;

Wieso hab ich nicht selber dran gedacht m(
Danke dir!

Schon lustig, wie man per Zufall die Lösung zu nem Problem findet, an 
dem man vor ner Weile gegrübelt hat.