StartUp atmega8 und AVR-Studio

#include <avr/io.h>

#ifndef F_CPU

#warning "F_CPU was not defined"

#define F_CPU 18432000UL

#endif

#include <util/delay.h>

#include <avr/interrupt.h>

#include <inttypes.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#define BAUD 115200

#define UART_BUFFER_SIZE 3

#define IRQS_PER_SECOND   0.2

#include <util/setbaud.h>

/*=============================================================================

        GLOBAL VARIABLES

=============================================================================*/

volatile char uart_buffer[UART_BUFFER_SIZE]={'v', 'v', 'v'};

volatile int8_t  uart_count  = 0;

//Variablen für die Zeit

volatile unsigned int  millisekunden;

volatile unsigned int sekunde;

volatile unsigned int minute;

volatile unsigned int stunde;

/*=============================================================================

        SUBROUTINES

=============================================================================*/

void uart_putc(char c)

//send single character

{

    while (!(UCSRA & (1<<UDRE)));

    UDR = c;

}

void uart_puti8(uint8_t c)

//send 8 bit unsigned integer

{

    while (!(UCSRA & (1<<UDRE)));

    UDR = c;

}

void uart_puti16(int16_t c)

// send 16bit signed integer

{

    while (!(UCSRA & (1<<UDRE)));

    UDR = c;                //lowbyte

    while (!(UCSRA & (1<<UDRE)));

    UDR = (c >> 8);              //highbyte

}

void uart_puts(char *data)

//send stiring via usart

{

    while(*data)

    {

        uart_putc(*data);

        data++;

    }

}

void uart_puti(int16_t value)

//send integer as sting

{

    char s[5];

    sprintf(s,"%u",value);

    uart_puts(s);

}

inline void uart_init(void)

//initailize uart communication

{

    //set baudrate

  UBRRH    = UBRRH_VALUE;

    UBRRL    = UBRRL_VALUE;

  #if USE_2X

    UCSRA |= (1<<U2X);

  #else

    UCSRA &= ~(1<<U2X);

  #endif

    UCSRB |= (1<<RXCIE) | (1<<TXEN) | (1<<RXEN);    //enable transmit, receive, interrupt

    UCSRC |= (1<< URSEL) | (1<<UCSZ1) | (1<<UCSZ0);    //8N1

    sei();                        //global interrupt enable

    //send welcomestring 36 chars

    _delay_ms(10);

    uart_puts("currentbox - initialisation complete");

}

/* ADC initialisieren */

void ADC_Init_saxi(void) {

  uint16_t result;

//  ADMUX = (0<<REFS1) | (1<<REFS0);      // AVcc als Referenz benutzen

  ADMUX = (0<<REFS1) | (0<<REFS0);      // externe Referenzspannung nutzen

  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_saxi( uint8_t channel )

{

  // Kanal waehlen, ohne andere Bits zu beeinflußen

  if (channel == 1) {

    ADMUX = (ADMUX & ~(0x1F)) | 0x00; // alle Kanäle rücksetzen und gewünschten Kanal dazu odern;

  } else if (channel == 2) {

    ADMUX = (ADMUX & ~(0x1F)) | 0x01;

  }

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"

  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten

  return ADCW;                    // ADC auslesen und zurückgeben

}

/* Beispielaufrufe: */

int main()

{

  uint16_t adcvals, adcvalc;

  //float uref = 5.2; // Spannungsversorgung usb Schnittstelle

  //float us = 0; 

  //float uc = 0; 

  uint8_t state = 0;

  ADC_Init_saxi();

  uart_init();   // Kommunikation mit Matlab

  DDRB=0xFF;

  // Timer 1 konfigurieren

  TCCR1A = 0; // CTC Modus

  #if defined (CTC1) && !defined (WGM12)

   TCCR1B = (1 << CTC1)  | (1 << CS10) | (1 << CS12);

  #elif !defined (CTC1) && defined (WGM12)

   TCCR1B = (1 << WGM12) | (1 << CS10) | (1 << CS12);

  #else

  #error Keine Ahnung, wie Timer1 fuer diesen AVR zu initialisieren ist!

  #endif

  OCR1A = (unsigned short) ((unsigned long) F_CPU / (1024*IRQS_PER_SECOND)-1);

  #if defined (TIMSK1)

    TIMSK1 |= (1 << OCIE1A);

  #elif defined (TIMSK)

    TIMSK  |= (1 << OCIE1A);

  #else   

  #error Keine Ahnung, wie IRQs fuer diesen AVR zu initialisieren sind!

  #endif

  // Compare Interrupt erlauben

  //TIMSK |= (1<<OCIE1A);

  // Global Interrupts aktivieren

  sei();

  while( 1 ) {

    switch(state)

  {

  case 0:

    if(uart_count!=0)

    {

      if(uart_buffer[0]=='t')

      {

        state = 1;

      }

      else if(uart_buffer[0]=='u')

      {

        state = 2;

      }

      if(uart_buffer[0] =='s')

        state = 3;

    }

    break;

  case 1:

    adcvals = ADC_Read_saxi(1);  // Kanal 0

    uart_puti16(adcvals);

    uart_buffer[0]=uart_buffer[1];

    uart_buffer[1]=uart_buffer[2];

    uart_count--;

    state = 0;

    break;

  case 2:

    adcvalc = ADC_Read_saxi(2);  // Kanal 1

    uart_puti16(adcvalc);

    uart_buffer[0]=uart_buffer[1];

    uart_buffer[1]=uart_buffer[2];

    uart_count--;

    state = 0;

    break;

  case 3:

    uart_puti16(sekunde);

    uart_buffer[0]=uart_buffer[1];

    uart_buffer[1]=uart_buffer[2];

    uart_count--;

    state = 0;

    break;

  default:

    state = 0;

    uart_count = 0;

    break;

  }//switch

  }//while 

} 

/*=============================================================================

        INTERRUPT SERVICE ROUTINES

=============================================================================*/

ISR(USART_RXC_vect)            // isr for usart receive

{

    if (uart_count < UART_BUFFER_SIZE) uart_buffer[uart_count] = UDR;  //protect overwriting/overflow

    uart_count++;

}

ISR (TIMER1_COMPA_vect)

{

  millisekunden= millisekunden+1000;

  if(millisekunden == 1000)

  {

    sekunde++;

    millisekunden = 0;

    if(sekunde == 60)

    {

      minute++;

      sekunde = 0;

    }

    if(minute == 60)

    {

      stunde++;

      minute = 0;

    }

    if(stunde == 24)

    {

      stunde = 0;

    }

  }

}