// ***** Inludes.
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
//#include <avr/signal.h>
//#include <avr/iom128.h>
#include <avr/wdt.h>
//#include <util/crc16.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <compat/ina90.h>
//#include <avr/boot.h>
//#include <avr/pgmspace.h>
//#include <avr/eeprom.h>
//#include <avr/sfr_defs.h>
//#include <avr/sleep.h>
//#include <errno.h>
//#include <math.h>



typedef uint8_t  ui8;
typedef int8_t   i8;
typedef uint16_t ui16;
typedef int16_t  i16;
typedef uint32_t ui32;
typedef int32_t  i32;
typedef unsigned char ucha;
typedef unsigned char byte;


// *** ANFANG: Abschnitt zur Systemkonfiguration ***
#if !defined (F_CPU)
  #define F_CPU 7372800			// uC-Takt 7,3728 MHz
#endif
#define TAKT F_CPU
#define FOSC F_CPU

#define USART0_BAUD 9600
#define USART1_BAUD 9600
#define MYUBRR0 (FOSC/16/USART0_BAUD-1)
#define MYUBRR1 (FOSC/16/USART1_BAUD-1)

// *** ENDE: Abschnitt zur Systemkonfiguration ***



// ***** Defines.
#if !defined (__AVR_ATmega128__)
  #error __AVR_ATmega128__ not defined !
#endif

//#define RAMSTART 0x0100
//#define RAMSIZE (RAMEND-RAMSTART)

#define sleep() asm volatile ("sleep" "\n\t" :: )	// Idle-Mode ermöglichen

// +++ Definition: Projekt-Netznamen (korrespondiert mit Schaltplänen)
#define EXT_DIG1			PINB4					// Port BB, Eingang
#define EXT_DIG2			PINB0					// Port BB, Eingang
#define EXT_DIG3			PINE7					// Port EEEEE, Eingang
#define EXT_DIG4			PINE6					// Port EEEEE, Eingang
#define EXT_DIG5			PINE5					// Port EEEEE, Eingang
#define EXT_DIG6			PINE4					// Port EEEEE, Eingang
#define EXT_DIG7			PINE3					// Port EEEEE, Eingang
#define EXT_DIG8			PINE2					// Port EEEEE, Eingang
#define EXT_DIG1_DDB4	DDB4					// Port B4 Direction Register
#define EXT_DIG2_DDB0	DDB0					// Port B0 Direction Register
#define EXT_DIG3_DDE7	DDE7					// Port E7 Direction Register
#define EXT_DIG4_DDE6	DDE6					// Port E6 Direction Register
#define EXT_DIG5_DDE5	DDE5					// Port E5 Direction Register
#define EXT_DIG6_DDE4	DDE4					// Port E4 Direction Register
#define EXT_DIG7_DDE3	DDE3					// Port E3 Direction Register
#define EXT_DIG8_DDE2	DDE2					// Port E2 Direction Register

#define MUX_ANA1			PINF0					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA2			PINF1					// Port FFFFFF, ADC-Betrieb, Eingang	
#define MUX_ANA3			PINF2					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA4			PINF3					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA5			PINF4					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA6			PINF5					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA7			PINF6					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA8			PINF7					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA1_DDF0	DDF0					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA2_DDF1	DDF1					// Port FFFFFF, ADC-Betrieb, Eingang	
#define MUX_ANA3_DDF2	DDF2					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA4_DDF3	DDF3					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA5_DDF4	DDF4					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA6_DDF5	DDF5					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA7_DDF6	DDF6					// Port FFFFFF, ADC-Betrieb, Eingang
#define MUX_ANA8_DDF7	DDF7					// Port FFFFFF, ADC-Betrieb, Eingang

#define MUXSEL				PORTA					// Port A, Ausgang
#define MUXSEL1				PINA4					// Port A, Ausgang
#define MUXSEL2 			PINA5					// Port A, Ausgang
#define MUXSEL3 			PINA0					// Port A, Ausgang
#define MUXSEL4 			PINA1					// Port A, Ausgang
#define MUXSEL5 			PINA6					// Port A, Ausgang
#define MUXSEL6 			PINA7					// Port A, Ausgang
#define MUXSEL7 			PINA2					// Port A, Ausgang
#define MUXSEL8 			PINA3					// Port A, Ausgang
#define MUXSEL_DDRA		DDRA					// Port A Direction Register
#define MUXSEL1_DDA4	DDA4					// Port A4 Direction Register
#define MUXSEL2_DDA5 	DDA5					// Port A5 Direction Register
#define MUXSEL3_DDA0 	DDA0					// Port A0 Direction Register
#define MUXSEL4_DDA1 	DDA1					// Port A1 Direction Register
#define MUXSEL5_DDA6 	DDA6					// Port A6 Direction Register
#define MUXSEL6_DDA7 	DDA7					// Port A7 Direction Register
#define MUXSEL7_DDA2 	DDA2					// Port A2 Direction Register
#define MUXSEL8_DDA3 	DDA3					// Port A3 Direction Register

#define LED_BIT(port, bitnummer)	(((volatile struct leds *)&port)->b##bitnummer)
#define LEDSTAT1			LED_BIT(PORTC, 6)					// Port CCC, Ausgang
#define LEDSTAT2			LED_BIT(PORTC, 7)					// Port CCC, Ausgang
#define LEDSTAT3			LED_BIT(PORTG, 2)					// Port GGGGGGG, Ausgang
#define LEDSTAT1_DDC6	DDC6					// Port C6 Direction Register
#define LEDSTAT2_DDC7	DDC7					// Port C7 Direction Register
#define LEDSTAT3_DDG2	DDG2					// Port G2 Direction Register

#define CH1_RXD				PIND2					// Port DDDD,	USART1, Eingang
#define CH1_TXD				PIND3					// Port DDDD, USART1, Ausgang
#define CH3_RXD				PINE0					// Port EEEEE, USART0, Eingang
#define CH3_TXD				PINE1					// Port EEEEE, USART0, Ausgang
#define CH1_RXD_DDD2	DDD2					// Port D2 Direction Register
#define CH1_TXD_DDD3	DDD3					// Port D3 Direction Register
#define CH3_RXD_DDE0	DDE0					// Port E0 Direction Register
#define CH3_TXD_DDE1	DDE1					// Port E1 Direction Register

#define ANA_BIT(port, bitnummer)	(((volatile struct ananum *)&port)->b##bitnummer)
#define	ANANUM1				ANA_BIT(PORTB, 6)			// Port BB, Eingang
#define	ANANUM2				ANA_BIT(PORTB, 7)			// Port BB, Eingang
#define	ANANUM3				ANA_BIT(PORTG, 3)			// Port GGGGGGG, Eingang
#define	ANANUM4				ANA_BIT(PORTG, 4)			// Port GGGGGGG, Eingang
#define	ANANUM1_DDB6	DDB6				// Port B6 Direction Register
#define	ANANUM2_DDB7	DDB7				// Port B7 Direction Register
#define	ANANUM3_DDG3	DDG3				// Port G3 Direction Register
#define	ANANUM4_DDG4	DDG4				// Port G4 Direction Register

#define on	1
#define off	0



// +++ Definition: USART Buffer
#define USART0_R_BUFF_SIZE	64			// 2,4,8,16,32,64,128 or 256 bytes
#define USART0_T_BUFF_SIZE	64			// 2,4,8,16,32,64,128 or 256 bytes
#define USART0_R_BUFF_MASK	(USART0_R_BUFF_SIZE - 1)
#define USART0_T_BUFF_MASK	(USART0_T_BUFF_SIZE - 1)

#if (USART0_R_BUFF_SIZE & USART0_R_BUFF_MASK)
  #error Empfangspuffer-Größe ist nicht durch 2 teilbar
#endif

#if (USART0_T_BUFF_SIZE & USART0_T_BUFF_MASK)
  #error Sendepuffer-Größe ist nicht durch 2 teilbar
#endif

#define USART1_R_BUFF_SIZE	64			// 2,4,8,16,32,64,128 or 256 bytes
#define USART1_T_BUFF_SIZE	64			// 2,4,8,16,32,64,128 or 256 bytes
#define USART1_R_BUFF_MASK	(USART1_R_BUFF_SIZE - 1)
#define USART1_T_BUFF_MASK	(USART1_T_BUFF_SIZE - 1)

#if (USART1_R_BUFF_SIZE & USART1_R_BUFF_MASK)
  #error Empfangspuffer-Größe ist nicht durch 2 teilbar
#endif

#if (USART1_T_BUFF_SIZE & USART1_T_BUFF_MASK)
  #error Sendepuffer-Größe ist nicht durch 2 teilbar
#endif





/**********************
 ***** Prototypen *****
 **********************/
void startinit (void);
void USART0_Init(unsigned int ubrr);
byte USART0_Receive(void);
void USART0_Transmit(byte data);
void USART1_Init(unsigned int ubrr);
byte USART1_Receive(void);
void USART1_Transmit(byte data);
void do_initblink(unsigned int muster);
void USART_puts(const char* zeichenfolge);
void USART_ISR_test(void);
void ANAAnzahl(void);
void LEDOnOff(unsigned int lednummer, unsigned int PulsMS);
void AlleLEDOn(void);
void AlleLEDOff(void);
void check_ANAAnzahl(void);


/***********************************************
 ***** Globale und statische Deklarationen *****
 ***********************************************/
// "0" = NIO; "1" = IO
// 0000'000x: 'start' gestartet
// 0000'00x0: 'ports' durchlaufen
// 0000'0x00: 'adc' durchlaufen
// 0000'x000: 'usart0' durchlaufen
// 000x'0000: 'usart1' durchlaufen
// 00x0'0000: 'blink' durchlaufen
// 0x00'0000: frei
// x000'0000: frei
static struct {
  byte start : 1;
	byte ports : 1;
	byte adc : 1;
	byte usart0 : 1;
	byte usart1 : 1;
	byte blink : 1 ;
	byte free1 : 1 ;
	byte free2 : 1 ;
} reginit;

static struct {
  unsigned char paketnummer;			// --- 1 Byte
  unsigned dig1 : 1;							// -
	unsigned dig2 : 1;							//  |
	unsigned dig3 : 1;							//  |
	unsigned dig4 : 1;							//  |_ 1 Byte
	unsigned dig5 : 1;							//  |
	unsigned dig6 : 1;							//  |
	unsigned dig7 : 1;							//  |
	unsigned dig8 : 1;							// -
	unsigned ana1 : 10;							// -
	unsigned ana2 : 10;							//  |_ 5 Bytes
	unsigned ana3 : 10;							//  |
	unsigned ana4 : 10;             // -
	unsigned ana5 : 10;							// -
	unsigned ana6 : 10;							//  |_ 5 Bytes
	unsigned ana7 : 10;							//  |
	unsigned ana8 : 10;             // -
	unsigned ana9 : 10;							// -
	unsigned ana10 : 10;						//  |_ 5 Bytes
	unsigned ana11 : 10;						//  |
	unsigned ana12 : 10;            // -
	unsigned ana13 : 10;						// -
	unsigned ana14 : 10;						//  |_ 5 Bytes
	unsigned ana15 : 10;						//  |
	unsigned ana16 : 10;            // -
} sensdata1;

struct ananum {
  byte b0 : 1;
  byte b1 : 1;
  byte b2 : 1;
  byte b3 : 1;
  byte b4 : 1;
  byte b5 : 1;
  byte b6 : 1;
  byte b7 : 1;
} __attribute__((_packed_));

struct leds {
  byte b0 : 1;
  byte b1 : 1;
  byte b2 : 1;
  byte b3 : 1;
  byte b4 : 1;
  byte b5 : 1;
  byte b6 : 1;
  byte b7 : 1;
} __attribute__((_packed_));

static unsigned int		anaanzahl;

static byte						USART0_RxBuf[USART0_R_BUFF_SIZE];
static volatile byte	USART0_RxHead;
static volatile byte	USART0_RxTail;
static byte						USART0_TxBuf[USART0_T_BUFF_SIZE];
static volatile byte	USART0_TxHead;
static volatile byte	USART0_TxTail;

static byte						USART1_RxBuf[USART1_R_BUFF_SIZE];
static volatile byte	USART1_RxHead;
static volatile byte	USART1_RxTail;
static byte						USART1_TxBuf[USART1_T_BUFF_SIZE];
static volatile byte	USART1_TxHead;
static volatile byte	USART1_TxTail;

static char Text1[] = { 'H', 'a', 'l', 'l', 'o', ' '};
static char Text2[] = { 'U', 'l', 'l', 'a' };

void usart0_putc(unsigned char c) {
  // Wait until UDR is ready
	while ( !(UCSR0A & (1 << UDRE0) ) ) {}
	UDR0 = c;					// Zeichen senden
  LEDOnOff(2, 10);
}

void usart1_putc(unsigned char c) {
  // Wait until UDR is ready
	while ( !(UCSR1A & (1 << UDRE1) ) ) {}
	UDR1 = c;					// Zeichen senden
	LEDOnOff(3, 10);
}

void usart0_puts (char *s) {
  // Loop until *s != NULL
	while ( *s ) {
	  usart0_putc(*s);
		s++;
  }
}

void usart1_puts (char *s) {
  // Loop until *s != NULL
	while ( *s ) {
	  usart1_putc(*s);
		s++;
  }
}

void usart0_puts_n (char *s, unsigned n) {
  // Loop until *s != NULL
	while ( n-- ) {
	  usart0_putc(*s);
		s++;
  }
}

void usart1_puts_n (char *s, unsigned n) {
  // Loop until *s != NULL
	while ( n-- ) {
	  usart1_putc(*s);
		s++;
  }
}




// ***** Globale Initialisierung des Systems.
void startinit (void) {
	ANANUM1 = 1;
	ANANUM2 = 1;
	ANANUM3 = 1;
	ANANUM4 = 1;

	// Port Direction Register:
	// * Eingang/Input  (i) = 0;
	// * Ausgang/Output (o) = 1.
  DDRA = (1<<MUXSEL3_DDA0  | 1<<MUXSEL4_DDA1  | 1<<MUXSEL7_DDA2  | 1<<MUXSEL8_DDA3  | 1<<MUXSEL1_DDA4  | 1<<MUXSEL2_DDA5  | 1<<MUXSEL5_DDA6  | 1<<MUXSEL6_DDA7);
  DDRB = (1<<EXT_DIG2_DDB0 | 0<<DDB1          | 0<<DDB2          | 1<<DDB3          | 1<<EXT_DIG1_DDB4 | 0<<DDB5          | 0<<ANANUM1_DDB6  | 0<<ANANUM2_DDB7);
  DDRC = (0<<DDC0          | 0<<DDC1          | 0<<DDC2          | 0<<DDC3          | 0<<DDC4          | 0<<DDC5          | 1<<LEDSTAT1_DDC6 | 1<<LEDSTAT2_DDC7);
  DDRD = (0<<DDD0          | 0<<DDD1          | 0<<CH1_RXD_DDD2  | 1<<CH1_TXD_DDD3  | 0<<DDD4          | 0<<DDD5          | 0<<DDD6          | 0<<DDD7);
  DDRE = (0<<CH3_RXD_DDE0  | 1<<CH3_TXD_DDE1  | 1<<EXT_DIG8_DDE2 | 1<<EXT_DIG7_DDE3 | 1<<EXT_DIG6_DDE4 | 1<<EXT_DIG5_DDE5 | 1<<EXT_DIG4_DDE6 | 1<<EXT_DIG3_DDE7);
  DDRF = (0<<MUX_ANA1_DDF0 | 0<<MUX_ANA2_DDF1 | 0<<MUX_ANA3_DDF2 | 0<<MUX_ANA4_DDF3 | 0<<MUX_ANA5_DDF4 | 0<<MUX_ANA6_DDF5 | 0<<MUX_ANA7_DDF6 | 0<<MUX_ANA8_DDF7);
  DDRG = (0<<DDG0          | 0<<DDG1          | 1<<LEDSTAT3_DDG2 | 0<<ANANUM3_DDG3  | 0<<ANANUM4_DDG4);

  PORTA	= 0x0;			// Initialisierungswerte: 00000000
  PORTB	= 0x0;			// Initialisierungswerte: 00000000
  PORTC	= 0x0;			// Initialisierungswerte: 00000000
  PORTD	= 0x0;			// Initialisierungswerte: 00000000
  PORTE	= 0x0;			// Initialisierungswerte: 00000000
  PORTF	= 0x0;			// Initialisierungswerte: 00000000
  PORTG	= 0x0;			// Initialisierungswerte: ---00000

  // AD-Wandler initialisieren.
  


  // USART initialisieren.
  USART0_Init(MYUBRR0);
  USART1_Init(MYUBRR1);
  cli();
	sei();				// Enable interrupts => enable UART interrupts

  do_initblink(0);
}



void do_initblink(unsigned int muster) {
  // Kurzes Startblinken der LEDs, ob sich was tut

    for (int i = 1; i <= 2; i++) {
      LEDSTAT1 = on;
      _delay_ms(200);
      LEDSTAT2 = on;
      _delay_ms(200);
      LEDSTAT3 = on;
      _delay_ms(200);
	  }
  	for (int i = 1; i < 3; i++) {
		  AlleLEDOff();
      _delay_ms(100);
		  AlleLEDOn();
      _delay_ms(100);
	  }

  AlleLEDOff();
}


void LEDOnOff(unsigned int lednummer, unsigned int PulsMS) {
  switch (lednummer) {
	  case 1:
	    LEDSTAT1 = on;
		  _delay_ms(PulsMS);
	    LEDSTAT1 = off;
	    break;
	  case 2:
	    LEDSTAT2 = on;
	  	_delay_ms(PulsMS);
	    LEDSTAT2 = off;
	    break;
	  case 3:
	    LEDSTAT3 = on;
  		_delay_ms(PulsMS);
  	  LEDSTAT3 = off;
	    break;
	  default:
	    break;
	}
}

void AlleLEDOn(void) {
  LEDSTAT1 = on;
  LEDSTAT2 = on;
  LEDSTAT3 = on;
	return;
}

void AlleLEDOff(void) {
  LEDSTAT1 = off;
  LEDSTAT2 = off;
  LEDSTAT3 = off;
	return;
}


// ***** Hauptprogramm.
int main (void) {

  // WatchDog-Timer/-System konfigurieren und aktivieren.
//  wdt_reset();
//  wdt_enable(WDTO_2S);

//	check_ANAAnzahl();
  startinit();
	unsigned char data = 'a';

  while (1) {
    /* Wait for empty transmit buffer */
		while ( !( UCSR0A & (1<<UDRE0)) );
    /* Put data into buffer, sends the data */
    UDR0 = data;
		LEDOnOff(2, 25);

   /* Wait for empty transmit buffer */
		while ( !( UCSR1A & (1<<UDRE1)) );
    /* Put data into buffer, sends the data */
    UDR1 = data;
		LEDOnOff(3, 25);

//    USART_ISR_test();
  }

  return 0;
}





// *** USART0 = CHANNEL 3 ***
// *** USART0 = CHANNEL 3 ***
// *** USART0 = CHANNEL 3 ***
void USART0_Init(unsigned int ubrr) {
	byte x;

	// Baudrate setzen
	UBRR0H = (byte)(ubrr>>8);
	UBRR0L = (byte)ubrr;
	// USART-Empfänger und -Sender aktivieren
	UCSR0B = ( 1<<RXCIE0 ) | ( 1<<RXEN0 ) | ( 1<<TXEN0 );
	// Frame-Format setzen: 8 Datenbits, 2 Stopbits
	UCSR0C = ( 1<<USBS0 ) | ( 1<<UCSZ01 ) | ( 1<<UCSZ00 );
	// Empfangsputter löschen
	x = 0;

	USART0_RxTail = x;
	USART0_RxHead = x;
	USART0_TxTail = x;
	USART0_TxHead = x;
}

byte USART0_Receive(void) {
  byte tmptail;

  while (USART0_RxHead == USART0_RxTail);  					// Wait for incomming data

  tmptail = (USART0_RxTail + 1) & USART0_R_BUFF_MASK;	// Calculate buffer index
  USART0_RxTail = tmptail;									// Store new index

  return USART0_RxBuf[tmptail];
  LEDOnOff(2, 25);
}

void USART0_Transmit(byte data) {
  byte tmphead;

  // Calculate buffer index
  tmphead = (USART0_TxHead + 1) & USART0_T_BUFF_MASK;	// Wait for free space in buffer

  while (tmphead == USART0_TxTail);

  USART0_TxBuf[tmphead] = data;			// Store data in buffer
  USART0_TxHead = tmphead;				// Store new index
  UCSR0B |= ( 1<<UDRIE0 );				// Enable UDRE interrupt
  LEDOnOff(2, 25);
}





// *** USART1 = CHANNEL1 ***
// *** USART1 = CHANNEL1 ***
// *** USART1 = CHANNEL1 ***
void USART1_Init(unsigned int ubrr) {
	byte x;

	// Baudrate setzen
	UBRR1H = (byte) (ubrr>>8);
	UBRR1L = (byte) ubrr;
	// USART-Empfänger und -Sender aktivieren
	UCSR1B = ( 1<<RXCIE1 ) | ( 1<<RXEN1 ) | ( 1<<TXEN1 );
	// Frame-Format setzen: 8 Datenbits, 2 Stopbits
	UCSR1C = ( 1<<USBS1 ) | ( 1<<UCSZ11 ) | ( 1<<UCSZ10 );              //For devices with Extended IO
	//UCSR0C = (1<<URSEL)|(1<<USBS1)|(1<<UCSZ11)|(1<<UCSZ10);   //For devices without Extended IO
	// Empfangsputter löschen
	x = 0;

	USART1_RxTail = x;
	USART1_RxHead = x;
	USART1_TxTail = x;
	USART1_TxHead = x;
}



byte USART1_Receive(void) {
  byte tmptail;

  while (USART1_RxHead == USART1_RxTail);					// Auf eingehende Daten warten

  tmptail = (USART1_RxTail + 1) & USART1_R_BUFF_MASK;	// Calculate buffer index
  USART1_RxTail = tmptail;									// Store new index

  return USART1_RxBuf[tmptail];
  LEDOnOff(3, 25);
}



void USART1_Transmit(byte data) {
  byte tmphead;

  // Calculate buffer index
  tmphead = (USART1_TxHead + 1) & USART1_T_BUFF_MASK;	// Wait for free space in buffer

  while (tmphead == USART1_TxTail);

  USART1_TxBuf[tmphead] = data;			// Store data in buffer
  USART1_TxHead = tmphead;				// Store new index
  UCSR1B |= ( 1<<UDRIE1 );				// Enable UDRE interrupt
  LEDOnOff(3, 25);
}



void check_ANAAnzahl(void) {
  unsigned int a = ANANUM1;
	unsigned int b = ANANUM2;
	unsigned int c = ANANUM3;
	unsigned int d = ANANUM4;
  anaanzahl = (a + b * 2 + c * 4 + d * 8);
}



byte USART0_DataInReceiveBuffer(void){
	return (USART0_RxHead != USART0_RxTail);			// Return 0 (FALSE) if the receive buffer is empty
}

byte USART1_DataInReceiveBuffer(void){
	return (USART1_RxHead != USART1_RxTail);			// Return 0 (FALSE) if the receive buffer is empty
}





// usart_isr_test - a simple test program
void USART_ISR_test(void) {
  USART0_Init(MYUBRR0);
  USART1_Init(MYUBRR1);
  cli();
	sei();				// Enable interrupts => enable UART interrupts

  while(1) {
    USART0_Transmit( USART0_Receive() );		// Echo the received character
    USART1_Transmit( USART1_Receive() );		// Echo the received character
  }
}





/**************************************
 ***** Interrupt Service Routinen *****
 **************************************/
//#pragma vector = USART0_RXC_vect
//__interrupt  void USART0_RX_interrupt(asm void)
ISR(USART0_RX_vect) {
  byte data;
  byte tmphead;

  // Einlesen der empfangenen Daten
  data = UDR0;

  /* Calculate buffer index */
  tmphead = (USART0_RxHead + 1) & USART0_R_BUFF_MASK;
  USART0_RxHead = tmphead;      				// Store new index

  if (tmphead == USART0_RxTail) {
    // ERROR! Receive buffer overflow
  }

  USART0_RxBuf[tmphead] = data;				// Store received data in buffer
}



//#pragma vector = USART0_UDRE_vect
//__interrupt void USART0_TX_interrupt(void)
ISR(USART0_TX_vect) {
  byte tmptail;

  // Prüfen, ob alle Daten gesendet wurden.
  if (USART0_TxHead != USART0_TxTail) {
	  tmptail = (USART0_TxTail + 1) & USART0_T_BUFF_MASK;
	  USART0_TxTail = tmptail;					// Store new index
	  UDR0 = USART0_TxBuf[tmptail];			// Start transmition
  } else {
	  UCSR0B &= ~(1<<UDRIE0);						// Disable UDRE interrupt
  }
}



ISR(USART1_RX_vect) {
  byte data;
  byte tmphead;

  // Einlesen der empfangenen Daten
  data = UDR1;

  /* Calculate buffer index */
  tmphead = (USART1_RxHead + 1) & USART1_R_BUFF_MASK;
  USART1_RxHead = tmphead;      				// Store new index

  if (tmphead == USART1_RxTail ) {
    // ERROR! Receive buffer overflow
  }

  USART1_RxBuf[tmphead] = data;				// Empfangene Daten im Puffer speichern
}



ISR(USART1_TX_vect) {
  byte tmptail;

  // Prüfen, ob alle Daten gesendet wurden.
  if (USART1_TxHead != USART1_TxTail) {
	  tmptail = (USART1_TxTail + 1) & USART1_T_BUFF_MASK;
	  USART1_TxTail = tmptail;					// Store new index
	  UDR1 = USART1_TxBuf[tmptail];			// Übertragung starten
  }	else {
    UCSR1B &= ~(1<<UDRIE1);						// Disable UDRE interrupt
  }
}



ISR(ADC_vect) // ADC Conversion Complete
{
	// ... ;
}