atmega 2560 ADC

[mario (Gast)]

Hallo, ich versuche mit dem ADC Werte einzulesen und per uart ans 
Terminal zu schicken. Allerdings reagiert der ADC-Eingang auf gar 
nichts. Ich weiß nicht, wo der Fehler ist. Habe den Code hier aus dem 
Tutorial und etwas aus anderen Posts eingefügt. Ans Terminal werden zwar 
Werte gesendet, aber nichts was nach Messwert aussieht.

// AVR306: Using the AVR UART in C
// Routines for polled USART
// Last modified: 02-06-21
// Modified by: AR

/* Includes */
#include <avr/io.h>
#include "adc.h"
#include <util/delay.h>


/* Prototypes */
void USART0_Init( unsigned int baudrate );
unsigned char USART0_Receive( void );
void USART0_Transmit( unsigned char data );
void uart_Putc(unsigned char c);
void uart_Puts (char *string);


//#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
   F_CPU im Makefile definiert werden, eine nochmalige Definition
   hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
   #ifndef/#endif 
 
   Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio 
   verwendet wird und dort eine andere, nicht zur Hardware passende 
   Taktrate eingestellt ist: Dann wird die folgende Definition 
   nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?) 
   von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
   noch nicht definiert: */
//#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 8000000"
#define F_CPU 8000000UL  // Systemtakt in Hz - Definition als unsigned long beachten 
                         // Ohne ergeben sich unten Fehler in der Berechnung
//#endif
 
#define BAUD 2400UL      // Baudrate
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
 
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif 



/* Main - a simple test program*/
int main( void )
{
char s[20]=" ";
uint16_t temp;

  uint16_t adcval = 0;
  ADC_Init();


  USART0_Init( UBRR_VAL ); /* Set the baudrate to 19,200 bps using a 3.6864MHz crystal */

DDRC |= (1<<PC7)|(1<<PC6)|(1<<PC5)|(1<<PC4);
//unsigned char a;
PORTC = 0x80;
  for(;;)       /* Forever */
  {
uart_Puts (s);
    adcval = ADC_Read(10);  // Kanal 0
      // mach was mit adcval

    //adcval = ADC_Read_Avg(10, 3);  // Kanal 2, Mittelwert aus 4 Messungen
      // mach was mit adcval
_delay_ms(2000);

    temp = adcval/1000;
    adcval   -= temp*1000;
    USART0_Transmit(temp+0x30);
    
    temp = adcval/100;
    adcval   -= temp*100;
    USART0_Transmit(temp+0x30);
    
    temp = adcval/10;
    adcval   -= temp*10;
    USART0_Transmit(temp+0x30);
    
    USART0_Transmit(adcval+0x30);

_delay_ms(2000);

//uart_Puts ();
    //a = USART0_Receive() ;
  /*  if (adcval<100) {
    PINC = 0x40;
    USART0_Transmit(0x48);
    }  else { 
      USART0_Transmit(0x4C);
      PINC = 0x20;}*/
    //USART0_Transmit( USART0_Receive() ); /* Echo the received character */
  }
}





/* Initialize UART */
void USART0_Init( unsigned int baudrate )
{
  /* Set the baud rate */
  UBRR0H = (unsigned char) (baudrate>>8);                  
  UBRR0L = (unsigned char) baudrate;
  
  /* Enable UART receiver and transmitter */
  UCSR0B = ( ( 1 << RXEN0 ) | ( 1 << TXEN0 ) ); 
  
  /* Set frame format: 8 data 2stop */
  UCSR0C = (0<<USBS0)|(1<<UCSZ01)|(1<<UCSZ00);              //For devices with Extended IO
  //UCSR0C = (1<<URSEL)|(1<<USBS0)|(1<<UCSZ01)|(1<<UCSZ00);   //For devices without Extended IO
}


/* Read and write functions */
unsigned char USART0_Receive( void )
{  PORTD = 0x40;
  /* Wait for incomming data */
  while ( !(UCSR0A & (1<<RXC0)) )   
    ;                      
  /* Return the data */
  return UDR0;
}

void USART0_Transmit( unsigned char data )
{
  /* Wait for empty transmit buffer */
  while ( !(UCSR0A & (1<<UDRE0)) )
    ;                       
  /* Start transmittion */
  UDR0 = data;               
}

void uart_Putc(unsigned char c)
{
    while (!(UCSR0A & (1<<UDRE0)));     
  UDR0 = c; 
//   _delay_ms(10);   
}//end uart_Putc()

void uart_Puts (char *string)
{
    while( *string != '\0' )
    {  
        uart_Putc(*string);
        string++;
    }
}//end uart_Puts()

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

#include <avr/io.h>

/* ADC initialisieren */
void ADC_Init(void) {

DDRK  = 0x00; //Define as Input

 
  uint16_t result;
 
  // interne Referenzspannung als Refernz 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<<ADPS2) |(1<<ADPS1) | (0<<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 
 ADCSRB=0x08|ADCSRA;
 DIDR2=0xFF;  
  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 ADCL+ADCH*256;//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 );
}

[Hubert G. (hubertg)]

Was hast du am Eingang des ADC?
Was wird denn an den PC geschickt?

[Stefan E. (sternst)]

 ADCSRB=0x08|ADCSRA;

Was genau sollte das denn werden?

  return ADCL+ADCH*256;

Hier ist nicht sichergestellt, dass die Register in der richtigen 
Reihenfolge ausgelesen werden.

    adcval = ADC_Read(10);  // Kanal 0

Was genau willst du überhaupt auswählen? Die "10" ist jedenfalls weder 
Kanal 0, noch Kanal 10.

[mario (Gast)]

Hubert G. schrieb:
> Was hast du am Eingang des ADC?
> Was wird denn an den PC geschickt?

Da ist ein Funktionsgenerator dran, wo ich einen DC einstellen kann. An 
den PC kamen jetzt 4-stellige Dezimalzahlen an, aber die sind quasi quer 
über den Wertebereich verteilt.

Stefan Ernst schrieb:
> ADCSRB=0x08|ADCSRA;Was genau sollte das denn werden?

Weiß ich auch nicht so genau, wofür das sein soll, hatte ich hier 
irgendwo gesehen in einem Code, der funktionieren sollte.

>   return ADCL+ADCH*256;Hier ist nicht sichergestellt, dass die Register in der 
richtigen
> Reihenfolge ausgelesen werden.

Wie müsste das denn sinnvollerweise gemacht werden? Hatte vorher ADCW, 
aber das kann ich so nicht einfach übertragen.

>     adcval = ADC_Read(10);  // Kanal 0Was genau willst du überhaupt auswählen? 
Die "10" ist jedenfalls weder
> Kanal 0, noch Kanal 10.

Hm ich hatte das so verstanden, dass man so ADC10 wählt.