// ***** Inludes.
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <inttypes.h>
//#include <stdio.h>
//#include <stdlib.h>
#include <string.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;



// ***** Defines.
#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)

#if !defined (__AVR_ATmega128__)
  #error __AVR_ATmega128__ not defined !
#endif

#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 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 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 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 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 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 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(unsigned char data);

void USART1_Init(unsigned int ubrr);
byte USART1_Receive(void);
void USART1_Transmit(unsigned char data);

void do_initblink(unsigned int muster);

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;

ui8 programmodus = 1;			// Variable für den Programmlauf: 0 = normal, 1 = Test, 2 = Test (LED blinken)

// ***** Globale Initialisierung des Systems.
void startinit (void) {


	ANANUM1 = 1;
	ANANUM2 = 1;
	ANANUM3 = 1;
	ANANUM4 = 1;

	// Port Direction Register; 0 = input (i); 1 = output (o)
  DDRA = 0xff;			// I/O: iiiiiiii
  DDRB = (1<<DDB0 | 0<<DDB1 | 0<<DDB2 | 0<<DDB3 | 1<<DDB4 | 0<<DDB5 | 0<<DDB6 | 0<<DDB7);	// I/O: iiiiiiii 
  DDRC = (0<<DDC0 | 0<<DDC1 | 0<<DDC2 | 0<<DDC3 | 0<<DDC4 | 0<<DDC5 | 1<<DDB6 | 1<<DDC7);	// I/O: iiiiiiii
  DDRD = (0<<DDD0 | 0<<DDD1 | 1<<DDD2 | 0<<DDD3 | 0<<DDD4 | 0<<DDD5 | 0<<DDB6 | 0<<DDD7);	// I/O: iiiiiiii
  DDRE = (1<<DDE0 | 0<<DDE1 | 1<<DDE2 | 1<<DDE3 | 1<<DDE4 | 1<<DDE5 | 1<<DDB6 | 1<<DDE7);	// I/O: iiiiiiii
  DDRF = (1<<DDF0 | 1<<DDF1 | 1<<DDF2 | 1<<DDF3 | 1<<DDF4 | 1<<DDF5 | 1<<DDB6 | 1<<DDF7);	// I/O: iiiiiiii
  DDRG = (0<<DDG0 | 0<<DDG1 | 1<<DDG2 | 0<<DDG3 | 0<<DDG4);																// I/O: ---iiiii

  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.
  

  USART0_Init(MYUBRR0);
  USART1_Init(MYUBRR1);

  do_initblink(0);

  wdt_reset();
}



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

  if (reginit.blink == 0) {
	  // Testmuster blinken wenn Neustart
    for (int i = 1; i < 2; i++) {
      LEDSTAT1 = on;
      wdt_reset();
      _delay_ms(200);
      LEDSTAT2 = on;
      wdt_reset();
      _delay_ms(200);
      LEDSTAT3 = on;
      wdt_reset();
      _delay_ms(200);
	  }
  	for (int i = 1; i < 3; i++) {
		  AlleLEDOff();
      wdt_reset();
      _delay_ms(100);
		  AlleLEDOn();
      wdt_reset();
      _delay_ms(100);
	  }
	}

  AlleLEDOff();
  reginit.blink = 1;
  wdt_reset();
}


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

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

//	UCSR0C = (1<<USBS0)|(1<<UCSZ01)|(1<<UCSZ00);              //For devices with Extended IO
	check_ANAAnzahl();
  startinit();

  // Programmschleife für Testmodus
  while (1) {

    wdt_reset();


		LEDOnOff(1, 50);

	  USART0_Transmit(56);
	  USART1_Transmit(65);
    wdt_reset();
  }

  wdt_reset();
  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 = 0x0;

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

/* Read and write functions */
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];
}

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
}

/* Interrupt handlers */
//#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
  }
}





// *** 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 = 0x0;

	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];
}

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
}

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









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



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);	// Set the baudrate to 19,200 bps using a 7.37MHz crystal
  USART1_Init(MYUBRR1);	// Set the baudrate to 19,200 bps using a 7.37MHz crystal
  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
    wdt_reset();
  }
}





/**************************************
 ***** Interrupt Service Routinen *****
 **************************************/

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