AVR GCC ADC Werte ergeben keinen Sinn

[A. B. (developer_x)]

Sehr geehrtes Forum,
ich habe eine Frage bezüglich des ADCs.

Ich habe eine Vorrichtung mit einem ATMEGA 88 PA, mit RS232 Verbindung 
zum PC und folgendem Code in C:

// 19.12.2013 - 17:19 Uhr, Tests zur Kommunikation per RS232 in C

#include <avr/io.h>          
#include <util/delay.h>

#define BAUD  4800UL
#define F_CPU 1000000UL
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)

//  Initialisierung des UART
void uart_init(void)
{
  // Baudrate einstellen
  UBRR0H = UBRR_VAL >> 8;
  UBRR0L = UBRR_VAL & 0xFF;
 
  // Verwendungsart einstellen
  UCSR0B  = (1<<TXEN0);  // UART TX einschalten
  UCSR0C  = (1<<UCSZ01)|(1<<UCSZ00);  // Asynchron 8N1 
  UCSR0B |= (1<<RXEN0);  // UART RX einschalten
}
//  Initialisierung des ADWC
void adc_init(void) 
{
  // 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. */
  (void) ADCW;
}

/* USART - Senden eines einzelnen Zeichens */
int uart_putc(unsigned char c)
{
    while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
    {
    }  

    UDR0 = c;                      /* sende Zeichen */
    return 0;
}
/* Zeichen empfangen */
uint8_t uart_getc(void)
{
    while (!(UCSR0A & (1<<RXC0)))   // warten bis Zeichen verfuegbar
        ;
    return UDR0;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

/* 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
}

void welcome(void)
{
  uart_putc('T');
  uart_putc('E');
  uart_putc('S');
  uart_putc('T');
  uart_putc(' ');
  uart_putc('D');
  uart_putc('E');
  uart_putc('V');
  uart_putc('I');
  uart_putc('C');
  uart_putc('E');
  uart_putc(' ');
  uart_putc('R');
  uart_putc('E');
  uart_putc('A');
  uart_putc('D');
  uart_putc('Y');
}

int main (void) 
{    
  uart_init();
  adc_init();

  welcome();

  while(1)
  {
    uart_getc();

    uint16_t adw = adc_read(0);
    uint8_t lo_value = adw;
    uint8_t hi_value = (adw >> 8);

    uart_putc('>');
      uart_putc(lo_value);
      uart_putc(hi_value); 
  }              
  return 0;                 
}

Problem ist, die Ausgabe ist immer konstant, egal was ich an ADC Channel 
0 auch anschließe, z.B. GND oder VCC oder gar nichts.

Woran könnte es liegen, am Code, oder an der Hardware?

[H.Joachim S. (crazyhorse)]

K. R. schrieb:
> uart_putc('>');
>       uart_putc(lo_value);
>       uart_putc(hi_value);

unabhängig vom Wandlerproblem - das funktioniert sicher nicht so, wie du 
dir das gedacht hast. Musst du in Ascii wandeln.

[Karl H. (kbuchegg)]

K. R. schrieb:

Mach dir doch erst mal ein paar vernünftige Hilfsfunktionen. So was ....

  uart_putc('T');
  uart_putc('E');
  uart_putc('S');
  uart_putc('T');
  uart_putc(' ');
  uart_putc('D');
  uart_putc('E');
  uart_putc('V');
  uart_putc('I');
  uart_putc('C');
  uart_putc('E');
  uart_putc(' ');
  uart_putc('R');
  uart_putc('E');
  uart_putc('A');
  uart_putc('D');
  uart_putc('Y');

ist doch Unsinn.

void uart_puts( const char* str )
{
  while( *str )
    uart_putc( *str++ );
}

damit kannst du dann sofort erst mal schreiben

void welcome(void)
{
  uart_puts( "TEST DEVICE READY\r\n" );
}

Gut.
Weiters ist diese Funktion sofort nützlich, weil sich daraus sofort eine 
Zahlenausgabe zusammensetzen lässt

void uart_puti( uint16_t value )
{
  char buffer[8];
  utoa( value, buffer, 10 );
  uart_puts( buffer );
}

welche gleich mal hier ...

int main()
{
....

  while(1)
  {
    uart_getc();

    uint16_t adw = adc_read(0);
    uart_puti( adw );
    uart_puts( "\r\n" );
  }

zum Einsatz kommt.

Alternativ hätte man azum Testen auch so vorgehen können

...
int main()
{
  char buffer[20];
...
  while(1)
  {
    uart_getc();

    uint16_t adw = adc_read(0);
    sprintf( buffer, "ADC Wert: %u\r\n", adw );
    uart_prints( buffer );
  }
}

Probier beide mal aus. Mal sehen ob dein Problem nicht einfach nur darin 
besteht, dass du die Ausgabe in deinem Terminal fehlinterpretierst.

[Karl H. (kbuchegg)]

Wenn du die Vcc an den ADC anschliessen willst, dann solltest du hier

void adc_init(void) 
{
  // 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);
...

dann aber auch die korrekte Referenzspannung dafür auswählen.

Wie ist der AREF Pin deines µC eigentlich beschaltet?

[A. B. (developer_x)]

Danke erstmal für eure Tipps.

Ich kriege eigentlich nur den einen konstanten Wert rein: 1023

Wenn ich AREF mit VCC (5V) verbinde (obwohl ich eine Interne Spannung 
verwende, hatte ich zumindest gedacht), dann habe ich ne leichte 
Varianz:
> wenn ich dann an Channel 0 z.B. 5V anschließe bin ich bei ca 430-390.
> Wenn ich Channel 0 an 0V (GND) anschließe, bin ich bei Werten ca. bei 350-360.

Ich hätte da schon etwas mehr an Variabilität erwartet. Sollten die 
Werte nicht bei AREF = 5V  zwischen 5V und 0V an Channel 0 nicht 
zwischen 0 und 2^14 liegen?

[A. B. (developer_x)]

Wenn ich das ganze an Channel 1 anschließe, und teste, kommen ähnliche 
Werte wie bei Channel 0 raus.

[Georg G. (df2au)]

AVCC ist beschaltet?

[A. B. (developer_x)]

ja, mit VCC verbunden

[A. B. (developer_x)]

Keiner eine Idee?