ADC - interne Refspannung

[Hans B. (hans_b92)]

Liebe Alle,

ich versuche mich derzeit am ADC. Den Schaltungsaufbau bei Nutzung der 
internen Referenzspannung des Atmega32 habe ich aus dem Tutorial (ARef 
über Kondensator an Masse, AGND über Kondensator an Masse, AVCC über 
Kondensator an Masse und 47 Ohm Widerstand an VCC).

Nun habe ich über einen Poti auf den Pin A0 unterschiedliche Spannungen 
geschickt und lasse mir den Rückgabewert des ADC über den UART ausgeben: 
leider derzeit konstant der 1023-ger Wert, der eigentlich für die 
Referenzspannung stehen sollte.

Ich hänge den Code an und wäre dankbar für einen Tipp was da im argen 
liegt.

Vielen Dank
Hans

#define F_CPU 8000000UL   

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <string.h>
#include <stdio.h>

#define UART_BAUDRATE  4800
#define UART_SETTING  ((F_CPU/16L/UART_BAUDRATE)-1)


volatile uint16_t sekunden, msekunden;



ISR(TIMER2_COMP_vect)
{
  static int count, count_sek;
  
  count_sek++;

  if(count_sek == 10)
  {
    msekunden++;
    count_sek = 0;

    if(msekunden == 1000)
    {
      sekunden++;
      msekunden = 0;
    }
  }
}

void init_time()
{
  TIMSK|=(1<<OCIE2);
  TCCR2 |= (1<<WGM21) | (1<<CS21);  
  OCR2 = F_CPU/8/10000;      
}



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

  ADMUX = (1<<REFS1) | (1<<REFS0);      // interne Referenzspannung nutzen

  // 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 */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average )
{
  uint32_t result = 0;
 
  for (uint8_t i = 0; i < average; ++i )
    result += ADC_Read( channel );
 
  return (uint16_t)( result / average );
}

void setup_uart()
{
  UBRRH = (char) (UART_SETTING >> 8);
  UBRRL = (char) (UART_SETTING);
  UCSRB = (1<<RXEN) | (1<<TXEN);

  UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
}

void uart_putchar(char c)
{
  // Warten bis Buffer bereit ...
  while (!(UCSRA & (1 << UDRE)))
    ;

  // Senden...
  UDR = c;
}

void uart_putstring(char *str)
{
  unsigned char i;

  for (i=0;i<255;i++) 
  {
    if (str[i] != 0)
      uart_putchar(str[i]);
    else
      break; // Ende des Strings erreicht
  }
}



char uart_getchar()
{
  // Ist schon ein Zeichen im Buffer?
  if (bit_is_set(UCSRA, RXC))
    return UDR;
  else 
    return -1;
}

void uart_readline(char *str)
{
  char c;
  unsigned char index;
  
  index = 0;

  while (1)
  {
    c = uart_getchar();
    if (c != -1)
    {
    


      if (c == 13) 
      {
        str[index] = 0;

        return;
      }
      else 
      {

    
        str[index] = c;
        index++;
      }
    }
  }
}



 
int main()
{

  uint16_t adcval;

  int last_sek;
 
  char Buffer[25];
 

  ADC_Init();

  DDRB=0xff;
  PORTB=0x00;

  sei();                                // Interrupts global an
 
  last_sek = 0;
  sekunden = 0;
  msekunden = 0;


  init_time();
  setup_uart();

  uart_putstring("Setup UART: check\r\n");
  uart_putstring("Setup ADC: ");
 
  _delay_ms(1000);
  
  uart_putstring("check\r\n");


  while( 1 ) 
  {

    if(sekunden>last_sek)
    {
  last_sek = sekunden;
    adcval = ADC_Read_Avg(0,5); 


 
    sprintf( Buffer, "Wert: %d", adcval );

  uart_putstring(Buffer);
  }
 
  }
}

[Hubert G. (hubertg)]

AGND gehört direkt mit Masse verbunden, am besten bei einem Knotenpunkt

[Hans B. (hans_b92)]

Ich danke verbindlichst und freue mich an den Messwerten zwischen 0 und 
1023 :) Grüße

[Krapao (Gast)]

> AVCC über Kondensator an Masse

Aber hoffentlich auch an Vcc?


AVcc o------+------o Vcc
            |
           --- C
           --- 100 nF
            |
AGND o------+------o GND
            |
           --- C
           --- 100 nF
            |
AREF o------+

[Krapao (Gast)]

> aus dem Tutorial (ARef über Kondensator an Masse, AGND über Kondensator
> an Masse, AVCC über Kondensator an Masse und 47 Ohm Widerstand an VCC)

Hast du da einen Link parat?

[Hans B. (hans_b92)]

http://www.mikrocontroller.net/articles/AVR-Tutorial:_ADC#Interne_Referenzspannung

So wie hier an der rechten Seite - der ursprüngliche Fehler wurde dabei 
übersehen. Muss ich daran noch etwas ändern? Ich geh über den Widerstand 
von AVCC auf VCC (gem. des nebenstehenden Textes kann die Spule durch 
einen Widerstand ersetzt werden)

[Hans B. (hans_b92)]

Ach, und wenn ich schon am Fragen bin:

Kann ich ADC0 auch im single ended inupt mit dem 10 x gain nutzen? Die 
Table 84 des Datenblatts verstehe ich anders. Da mein INA333 aber leider 
nur ne 1000fache Verstärkung liefert, würde ich gern noch den gain 
dazuschalten.

[Karl H. (kbuchegg)]

Hans B. schrieb:
> Ach, und wenn ich schon am Fragen bin:
>
> Kann ich ADC0 auch im single ended inupt mit dem 10 x gain nutzen? Die
> Table 84 des Datenblatts verstehe ich anders.

Du vesrstehst die Tabelle richtig. Singel Ended gibt es keinen Gain.

> Da mein INA333 aber leider
> nur ne 1000fache Verstärkung liefert, würde ich gern noch den gain
> dazuschalten.

Du kannst ja auch deine eigene Referenzspannung zur Messung hernehmen, 
die dann eben nur 1/10 der bereitgestellten ausmacht. Das müssten dann 
allerdings 0.25 Volt sein. Und die reicht dir nicht, obowhl du dein 
Signal schon um das 1000-fache verstärkt hast? Was misst du da?