#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>

#define  F_OSC			(8000)		  		//oscillator freq. in kHz (typical 8MHz or 16MHz)


volatile uint8_t	 DmxRxField[8]; 		//array of DMX vals (raw)
volatile uint16_t	 DmxAddress;			//start address

enum {IDLE, BREAK, STARTB, STARTADR};			//DMX states

volatile uint8_t 	 gDmxState;

int main(void)
{
	cli();
	DDRD |= (1<<PD7);					//red LED pin is output
	DDRA = 0b11111111;
	init_DMX_RX();
	
	TCCR0  = (1<<CS00);					//set T0 @sys clk
	TIMSK |= (1<<TOIE0);				//enable overflow irq
	
	DmxAddress= 1;
	sei();
	while(1)
	{
		//get_dips();						//get start address
	}
}

ISR (TIMER0_OVF_vect)
{
	static unsigned char pwm_counter = 0;

	pwm_counter++;

	if(pwm_counter == 255)
	{
		pwm_counter = 0;

	}
	
	if(pwm_counter >= DmxRxField[0])
	{
		
		PORTA &= ~(1<<PA0);
	}
	else
	{
		PORTA |= (1<<PA0);
	}
	
	if(pwm_counter >= DmxRxField[1])
	{
			
		PORTA &= ~(1<<PA1);
	}
	else
	{
		PORTA |= (1<<PA1);
	}	
}

void init_DMX_RX(void)
{
#ifdef USE_DIP
DDRC   = 0;										//set up DIPs
PORTC  = 0xFF;
DDRE  &= ~((1<<PE2)|(1<<PE1));
PORTE |=   (1<<PE2)|(1<<PE1);
#endif

DDRD  |= (1<<2);
PORTD &= ~(1<<2);								
UBRRH  = 0;										//enable reception
UBRRL  = ((F_OSC/4000)-1);						//250kbaud, 8N2
UCSRC  = (1<<URSEL)|(3<<UCSZ0)|(1<<USBS);
UCSRB  = (1<<RXEN)|(1<<RXCIE);
gDmxState= IDLE;
}



// ************* get DMX start address **************
void get_dips(void)
{
#ifdef USE_DIP
uint16_t Temp= (0xFF-PINC);						//invert DIP state
if (!(PINE &(1<<2)))
	{
	Temp += 256;								//9th bit
	}
if (Temp != 0)
	{
	DmxAddress= Temp;
	if (!(UCSRB &(1<<RXCIE)))					//if receiver was disabled -> enable and wait for break
		{
		gDmxState= IDLE;
		UCSRB |= (1<<RXCIE);
		}
	}
else
	{
	UCSRB &= ~(1<<RXCIE);						//disable Receiver if start address = 0
	uint8_t i;
	for (i=0; i<sizeof(DmxRxField); i++)
		{
		DmxRxField[i]= 0;
		}
	}
#endif 
}



// *************** DMX Reception ISR ****************
ISR (USART_RX_vect)
{
static  uint16_t DmxCount;
		uint8_t  USARTstate= UCSRA;				//get state before data!
		uint8_t  DmxByte   = UDR;				//get data
		uint8_t  DmxState  = gDmxState;			//just load once from SRAM to increase speed
 
if (USARTstate &(1<<FE))						//check for break
	{
	UCSRA &= ~(1<<FE);							//reset flag (necessary for simulation in AVR Studio)
	DmxCount =  DmxAddress;						//reset channel counter (count channels before start address)
	gDmxState= BREAK;
	}

else if (DmxState == BREAK)
	{
	if (DmxByte == 0) gDmxState= STARTB;		//normal start code detected
	else			  gDmxState= IDLE;
	}
	
else if (DmxState == STARTB)
	{
	if (--DmxCount == 0)						//start address reached?
		{
		DmxCount= 1;							//set up counter for required channels
		DmxRxField[0]= DmxByte;					//get 1st DMX channel of device
		gDmxState= STARTADR;
		}
	}

else if (DmxState == STARTADR)
	{
	DmxRxField[DmxCount++]= DmxByte;			//get channel
	if (DmxCount >= sizeof(DmxRxField)) 		//all ch received?
		{
		gDmxState= IDLE;						//wait for next break
		}
	}							
}