ADC - interne Refspannung

#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);

  }

  }

}