Hilfe bei AD-Wandler!

// --------------------------------------------------------

// Systemlibs

// --------------------------------------------------------

#include <avr/io.h>

#include <avr/sfr_defs.h>

#include <avr/interrupt.h>

#include <stdint.h>

#include <stdlib.h>

#include <stdbool.h>

// --------------------------------------------------------

// Konstantendeklaration

// --------------------------------------------------------

// Festlegung der realen ADC Ports

// ist nur ein Test am atMega32

#define ADC_AN0    7

#define ADC_AN1    7

#define ADC_AN2    7

#define ADC_AN3    7

// --------------------------------------------------------

// ADC Prescale Value

// --------------------------------------------------------

#define ADC_ADPS2_0(b2,b1,b0)  ((b2)<<ADPS2 ^ (b1)<<ADPS1 ^ (b0)<<ADPS0)

#define ADC_PRESCALE_2    ADC_ADPS2_0(0,0,1)

#define ADC_PRESCALE_4    ADC_ADPS2_0(0,1,0)

#define ADC_PRESCALE_8    ADC_ADPS2_0(0,1,1)

#define ADC_PRESCALE_16    ADC_ADPS2_0(1,0,0)

#define ADC_PRESCALE_32    ADC_ADPS2_0(1,0,1)

#define ADC_PRESCALE_64    ADC_ADPS2_0(1,1,0)

#define ADC_PRESCALE_128  ADC_ADPS2_0(1,1,1)

// --------------------------------------------------------

// ADC Prescale

// --------------------------------------------------------

// max. ADC Taktfrequenz laut Datenblatt, 200.000kHz

#define ADC_SPEED    200000ul

#if (F_CPU / 2) <= ADC_SPEED

# define ADC_PRESCALE    ADC_PRESCALE_2

#elif (F_CPU / 4) <= ADC_SPEED

# define ADC_PRESCALE    ADC_PRESCALE_4

#elif (F_CPU / 8) <= ADC_SPEED

# define ADC_PRESCALE    ADC_PRESCALE_8

#elif (F_CPU / 16) <= ADC_SPEED

# define ADC_PRESCALE    ADC_PRESCALE_16

#elif (F_CPU / 32) <= ADC_SPEED

# define ADC_PRESCALE    ADC_PRESCALE_32

#elif (F_CPU / 64) <= ADC_SPEED

# define ADC_PRESCALE    ADC_PRESCALE_64

#else

# define ADC_PRESCALE    ADC_PRESCALE_128

#endif

// --------------------------------------

// Hilfsvariable der ADC ISR-Routine

// --------------------------------------

// Maximale Messung für einen Mittelwert

static uint8_t adc_avg_max = 1;

// Ergebnis der ADC Mittelwert-Messung

static volatile uint32_t adc_avg_channel = 0;

// Signal an das wartende Messprogramm

static volatile bool_t adc_avg_ready = false;

// --------------------------------------------------------

// ADC Hilfsmacros

// --------------------------------------------------------

#define ADC_DISABLE_INT()    ADCSRA &= (uint8_t)~_BV(ADIE)

#define ADC_ENABLE_INT()    ADCSRA |= _BV(ADIE)

#define ADC_START_NEW_MESSURED()  ADCSRA |= _BV(ADSC)

#define ADC_WAIT_CONVERT_READY()  do { } while ( ADCSRA & _BV(ADSC) )

#define ADC_DISABLE()      ADCSRA &= (uint8_t)~(1<<ADEN)

#define ADC_ENBALE()      ADCSRA |= (1<<ADEN)

#define ADC_SET_REF(ref)    do { \

 uint8_t admux = ADMUX; \

 admux &= (uint8_t)~(_BV(REFS1) | _BV(REFS0)); \

 admux |= (uint8_t)(ref); \

 ADMUX = admux; \

} while(0)

#define ADC_SET_CHANNEL(chn)    do { \

 uint8_t admux = ADMUX; \

 admux &= (uint8_t)~(0x07); \

 admux |= ((chn) & 0x07); \

 ADMUX = admux; \

} while(0)

#define ADC_SET_PRESCALE(ps)    do { \

 uint8_t adcsra = ADCSRA; \

 adcsra &= (uint8_t)~(ADC_ADPS2_0(1,1,1)); \

 adcsra |= (uint8_t)(ps); \

 ADCSRA = adcsra; \

} while(0)

// --------------------------------------------------------

// void adc_init( void );

// --------------------------------------------------------

void adc_init( void )

{

  // Analog Comparator Disable

  ACSR = _BV(ACD);

#ifdef DIDR0

  // Digital Input Disable Register 0

  // ADC7D:ADC0D

  DIDR0 = (_BV(ADC_AN3) ^ _BV(ADC_AN2) ^ _BV(ADC_AN1) ^ _BV(ADC_AN0));

#endif

  // Set ADC-pins to input

  // atMega32

  // pullup off

  PORTA &= (uint8_t)~(_BV(ADC_AN3) ^ _BV(ADC_AN2) ^ _BV(ADC_AN1) ^ _BV(ADC_AN0));

  // set bits to input

  DDRA &= (uint8_t)~(_BV(ADC_AN3) ^ _BV(ADC_AN2) ^ _BV(ADC_AN1) ^ _BV(ADC_AN0));

  // enable ADC

  ADC_ENBALE();

  ADC_SET_PRESCALE(ADC_PRESCALE);

  // AVCC with external capacitor at AREF pin

  // ADC_SET_REF( (0<<REFS1) ^ (1<<REFS0) );

  // Internal 2.56V Voltage Reference with external capacitor at AREF pin

  ADC_SET_REF( (1<<REFS1) ^ (1<<REFS0) );

  ADC_SET_CHANNEL( 0 );

  ADC_START_NEW_MESSURED();

 /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, 

    man liest also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" 

  */

  ADC_WAIT_CONVERT_READY();

  (void)ADCW;

}

// --------------------------------------------------------

// void adc_start_isr_measurement( 

//  uint8_t adc_id0, uint8_t adc_id1,

//  uint8_t adc_avg_cnt              );

// --------------------------------------------------------

static void adc_start_isr_measurement( uint8_t adc_id, uint8_t adc_avg_cnt )

{

  // ADC Kanal setzen

  ADC_SET_CHANNEL( adc_id );

  // Anzahl der Messungen für einen Mittelwert

  adc_avg_max = adc_avg_cnt;

  // Variable initialisieren

  adc_avg_ready = false;

  // enable ADC ISR

  ADC_ENABLE_INT();

  // Erste Messung anstossen

  ADC_START_NEW_MESSURED();

}

// --------------------------------------------------------

// void adc_stop_isr_measurement( void );

// --------------------------------------------------------

static void adc_stop_isr_measurement( void )

{

}

// --------------------------------------------------------

// ISR(ADC_vect);

// --------------------------------------------------------

ISR(ADC_vect)

{

  //lokale Variable der ADC ISR-Routine

  static uint8_t adc_avg_counter = 0;

  // Messwert auslesen und Mittelwert bilden

  adc_avg_channel += ADCW;

  // loop counter

  if (++ adc_avg_counter == adc_avg_max) {

    adc_avg_counter = 0;

    ADC_DISABLE_INT();        // Disable ADC Interrupt

    // Mittelwert-Ergebnisse berechnen

    adc_avg_channel /= adc_avg_max;

    // Signal an die wartende Procedure

    adc_avg_ready = true;

  } else {

    ADC_START_NEW_MESSURED();      // Starte weitere ADC-Konversion

  }

}

// --------------------------------------------------------

// adc_messung( uint16_t *adc_avg,

//               uint8_t  adc_id,

//               uint8_t  adc_avg_cnt );

// --------------------------------------------------------

void adc_messung(

  uint16_t *adc_avg,     // Ergebnisse adc_avg

  uint8_t  adc_id,    // die ADC-Kanal adc_id

  uint8_t  adc_avg_cnt       // Anzahl der Messertte für den Mittelwert 

)

{

  adc_start_isr_measurement( adc_id, adc_avg_cnt );

  while( !adc_avg_ready ) { }

  adc_stop_isr_measurement();

  // Ergebnisse kopieren

  (*adc_avg) = adc_avg_channel;

}