/******  Includes  ******/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#define F_CPU 4000000L


/* Timer */
volatile char milli = 0;
volatile char sec = 0;
volatile char step = 0;
volatile unsigned char cube[3][3][3];

ISR (TIMER1_COMPA_vect)
{
	if(milli == 100) {
		sec++;	// sec = sec + 1;
		milli=0;
		
	}
	else {
		milli++;
		
	}

	if(sec==5) {
		sec=0;
		step=myRand(23);
		//step=22;
	}
}



/******************* ANIMATIONS ************/

/* pre definitions */
void turn_on(  int xpos, int ypos ) 
{
	switch( xpos ) {
	
		case 0:
			switch( ypos ) {
				
				case 0:
					PORTC |= (1<<PC0);
					break;
				case 1:
					PORTC |= (1<<PC1);
					break;
				case 2:
					PORTC |= (1<<PC2);
					break;
			}
			break;

		case 1:
			switch( ypos ) {
				
				case 0:
					PORTC |= (1<<PC3);
					break;
				case 1:
					PORTC |= (1<<PC4);
					break;
				case 2:
					PORTC |= (1<<PC5);
					break;
			}
			break;

		case 2:
			switch( ypos ) {
				
				case 0:
					PORTB |= (1<<PB3);
					break;
				case 1:
					PORTB |= (1<<PB4);
					break;
				case 2:
					PORTB |= (1<<PB5);
					break;
			}
			break;
	}

}

void turn_off(  int xpos, int ypos ) 
{
	switch( xpos ) {
	
		case 0:
			switch( ypos ) {
				
				case 0:
					PORTC &= ~(1<<PC0);
					break;
				case 1:
					PORTC &= ~(1<<PC1);
					break;
				case 2:
					PORTC &= ~(1<<PC2);
					break;
			}
			break;

		case 1:
			switch( ypos ) {
				
				case 0:
					PORTC &= ~(1<<PC3);
					break;
				case 1:
					PORTC &= ~(1<<PC4);
					break;
				case 2:
					PORTC &= ~(1<<PC5);
					break;
			}
			break;

		case 2:
			switch( ypos ) {
				
				case 0:
					PORTB &= ~(1<<PB3);
					break;
				case 1:
					PORTB &= ~(1<<PB4);
					break;
				case 2:
					PORTB &= ~(1<<PB5);
					break;
			}
			break;
	}
}

void clear(void) 
{
	PORTB = 0x00;
	PORTD = 0x00;
	PORTC = 0x00;
}

void power(int zpos) 
{
	switch( zpos ) {

		case 0:
			PORTD = (1<<PD2);
			break;
		case 1:
			PORTD = (1<<PD1);
			break;
		case 2:
			PORTD = (1<<PD0);
			break;
	}
}

int myRand(int UpperBound)
{
  int x;

  while( (x = rand()) >= RAND_MAX - (RAND_MAX % UpperBound) );

  return x % UpperBound;
}

void delay_ms(uint16_t x)
{
  uint8_t y, z;
  for ( ; x > 0 ; x--){
    for ( y = 0 ; y < 90 ; y++){
      for ( z = 0 ; z < 6 ; z++){
        asm volatile ("nop");
      }
    }
  }
}


/* animations */

/* random rain */
void rain() 
{
	clear();
	turn_on( myRand(3) , myRand(3) );
	delay_ms(1000);
	power(2);
	delay_ms(500);
	power(1);
	delay_ms(450);
	power(0);
	delay_ms(400);
	
}

/* up-down */
void updown()
{

	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	power(0);
	delay_ms(500);
	power(1);
	delay_ms(500);
	power(2);
	delay_ms(500);
	if(step==7) {
		power(1);
		delay_ms(500);
	}
}

/* lauf */
void lauf()
{

	for(int z=0; z<3; z++) {
		clear();
		power(2-z);
		turn_on( 0, 0);
		delay_ms(500);
		turn_on( 0, 1);
		delay_ms(500);
		turn_on( 0, 2);	
		delay_ms(500);
		turn_on( 1, 2);
		delay_ms(500);
		turn_on( 2, 2);
		delay_ms(500);
		turn_on( 2, 1);
		delay_ms(500);
		turn_on( 2, 0);
		delay_ms(500);
		turn_on( 1, 0);
		delay_ms(500);
	}

	clear();
	turn_on( 1, 1);
	for(int i=0; i<3; i++) {
		power(i);
		delay_ms(250);
	}
}

/* dreh */
void dreh()
{
	
	clear();
	turn_on( 1, 0);
	turn_on( 1, 1);
	turn_on( 1, 2);
	while(sec<1) {
		power(0);
		delay_ms(20);
		power(1);
		delay_ms(20);
		power(2);
		delay_ms(20);
	}

	if(step==3)
		clear();
	turn_on( 2, 0);
	turn_on( 1, 1);
	turn_on( 0, 2);
	while(sec<2) {
		power(0);
		delay_ms(20);
		power(1);
		delay_ms(20);
		power(2);
		delay_ms(20);
	}

	if(step==3)
		clear();
	turn_on( 0, 1);
	turn_on( 1, 1);
	turn_on( 2, 1);
	while(sec<3) {
		power(0);
		delay_ms(20);
		power(1);
		delay_ms(20);
		power(2);
		delay_ms(20);
	}

	if(step==3)
		clear();
	turn_on( 0, 0);
	turn_on( 1, 1);
	turn_on( 2, 2);
	while(sec<4) {
		power(0);
		delay_ms(20);
		power(1);
		delay_ms(20);
		power(2);
		delay_ms(20);
	}
	

	if(step==3) {
		clear();
		turn_on( 1, 0);
		turn_on( 1, 1);
		turn_on( 1, 2);
	}
	while(sec<5 && sec>3) {
		power(0);
		delay_ms(20);
		power(1);
		delay_ms(20);
		power(2);
		delay_ms(20);
	}
	
}

/* leftright */
void leftright()
{
	clear();
	for(int i=0; i<3; i++)
		turn_on( 0 , i );
	
	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	clear();
	for(int i=0; i<3; i++)
		turn_on( 1 , i );
	
	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}	

	clear();
	for(int i=0; i<3; i++)
		turn_on( 2 , i );
	
	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	if (step==6) {
		clear();
		for(int i=0; i<3; i++)
			turn_on( 1 , i );
		
		for(int i=0; i<9; i++) {
			power(0);
			delay_ms(21);
			power(1);
			delay_ms(21);
			power(2);
			delay_ms(21);
		}
	}
}

/* frontrear */
void frontrear()
{

	clear();
	for(int i=0; i<3; i++)
		turn_on( i , 0 );
	
	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	clear();
	for(int i=0; i<3; i++)
		turn_on( i , 1 );
	
	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}	

	clear();
	for(int i=0; i<3; i++)
		turn_on( i , 2 );
	
	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	if (step==8) {
		clear();
		for(int i=0; i<3; i++)
			turn_on( i , 1 );
		
		for(int i=0; i<9; i++) {
			power(0);
			delay_ms(21);
			power(1);
			delay_ms(21);
			power(2);
			delay_ms(21);
		}
	}	
}

/* drehfast */
void drehfast(int speed)
{
	
	clear();
	turn_on( 1, 0);
	turn_on( 1, 1);
	turn_on( 1, 2);
	for(int i=0; i<speed; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	if(step==10)
		clear();
	turn_on( 2, 0);
	turn_on( 1, 1);
	turn_on( 0, 2);
	for(int i=0; i<speed; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	if(step==10)
		clear();
	turn_on( 0, 1);
	turn_on( 1, 1);
	turn_on( 2, 1);
	for(int i=0; i<speed; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	if(step==10)
		clear();
	turn_on( 0, 0);
	turn_on( 1, 1);
	turn_on( 2, 2);
	for(int i=0; i<speed; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	if(step==11) {

		turn_off( 1, 0);
		turn_off( 1, 1);
		turn_off( 1, 2);
		for(int i=0; i<speed; i++) {
			power(0);
			delay_ms(21);
			power(1);
			delay_ms(21);
			power(2);
			delay_ms(21);
		}
	
		turn_off( 2, 0);
		turn_off( 1, 1);
		turn_off( 0, 2);
		for(int i=0; i<speed; i++) {
			power(0);
			delay_ms(21);
			power(1);
			delay_ms(21);
			power(2);
			delay_ms(21);
		}
	
		turn_off( 0, 1);
		turn_off( 1, 1);
		turn_off( 2, 1);
		for(int i=0; i<speed; i++) {
			power(0);
			delay_ms(21);
			power(1);
			delay_ms(21);
			power(2);
			delay_ms(21);
		}
	
		turn_off( 0, 0);
		turn_off( 1, 1);
		turn_off( 2, 2);
		for(int i=0; i<speed; i++) {
			power(0);
			delay_ms(21);
			power(1);
			delay_ms(21);
			power(2);
			delay_ms(21);
		}

	}
	
}

/* random blink */
void randbl()
{

	clear();
	turn_on( myRand(3) , myRand(3) );
	if(step==15)
		turn_on( myRand(3) , myRand(3) );
	power( myRand(3) );
	delay_ms(175);
}

/* rand rm */
void randrm()
{

	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	while(PORTB != 0 && PORTD != 0) {
		turn_off( myRand(3) , myRand(3) );
	
		for(int i=0; i<5; i++) {
			power(0);
			delay_ms(21);
			power(1);
			delay_ms(21);
			power(2);
			delay_ms(21);
		}
	}
	delay_ms(250);
}

/* build cube */
void buildcube()
{

	// first	
	clear();
	turn_on( 0 , 0 );
	power(0);
	delay_ms(1000);
	
	clear();
	turn_on( 0 , 0 );
	turn_on( 0 , 1 );
	turn_on( 1 , 0 );
	turn_on( 1 , 1 );
	for(int i=0; i<24; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
	}
	
	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	for(int i=0; i<18; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	// second
	clear();
	turn_on( 2 , 2 );
	power(0);
	delay_ms(500);
	
	clear();
	turn_on( 2 , 2 );
	turn_on( 2 , 1 );
	turn_on( 1 , 2 );
	turn_on( 1 , 1 );
	for(int i=0; i<24; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
	}
	
	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	for(int i=0; i<18; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	// thrid
	clear();
	turn_on( 2 , 0 );
	power(0);
	delay_ms(500);
	
	clear();
	turn_on( 2 , 0 );
	turn_on( 2 , 1 );
	turn_on( 1 , 0 );
	turn_on( 1 , 1 );
	for(int i=0; i<24; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
	}
	
	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	for(int i=0; i<18; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	// quart
	clear();
	turn_on( 0 , 2 );
	power(0);
	delay_ms(500);
	
	clear();
	turn_on( 0 , 2 );
	turn_on( 0 , 1 );
	turn_on( 1 , 2 );
	turn_on( 1 , 1 );
	for(int i=0; i<24; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
	}
	
	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	for(int i=0; i<18; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}
}

/* drehagain */
void drehagain()
{

	clear();
	for(int i=0;i<3;i++)
		turn_on( i , 1 );
	
	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}


	for(int i=0; i<9; i++) {
		clear();
		for(int j=0;j<3;j++)
			turn_on( j , 0 );
		power(0);
		delay_ms(21);
		clear();
		for(int j=0;j<3;j++)
			turn_on( j , 1 );
		power(1);
		delay_ms(21);
		clear();
		for(int j=0;j<3;j++)
			turn_on( j , 2 );
		power(2);
		delay_ms(21);
	}

	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}
	power(1);
	delay_ms(500);


	for(int i=0; i<9; i++) {
		clear();
		for(int j=0;j<3;j++)
			turn_on( j , 2 );
		power(0);
		delay_ms(21);
		clear();
		for(int j=0;j<3;j++)
			turn_on( j , 1 );
		power(1);
		delay_ms(21);
		clear();
		for(int j=0;j<3;j++)
			turn_on( j , 0 );
		power(2);
		delay_ms(21);
	}
	
}

/* lauf 2 */
void lauf2()
{

	for(int z=0;z<3;z++) {
		clear();
		power(z);
		for(int i=0;i<3;i++){
			for(int j=0;j<3;j++) {
				turn_on( i , j );
				delay_ms(500);
			}
		}
	}	
}

/* buildcube 2 */
void buildcube2()
{

	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}
	power(2);
	delay_ms(500);

	power(0);
	delay_ms(500);

	clear();
	for(int y=0;y<3;y++)
		turn_on( y , 0 );

	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	clear();
	for(int y=0;y<3;y++)
		turn_on( y , 2 );

	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	clear();
	for(int y=0;y<3;y++)
		turn_on( 0 , y );

	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	clear();
	for(int y=0;y<3;y++)
		turn_on( 2 , y );

	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	for(int i=0; i<9; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}
}

/* rain 2 */
void rain2()
{

	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	for(int i=0; i<12; i++) {
		power(0);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}

	int h=myRand(3);
	int l=myRand(3);

	for(int i=0; i<9; i++) {
		clear();
		for(int x=0;x<3;x++) {
			for(int y=0;y<3;y++)
				turn_on( x , y );
		}
		turn_off( l , h );
		power(0);
		delay_ms(21);
		clear();
		turn_on( l , h );
		power(1);
		delay_ms(21);
		clear();
		for(int x=0;x<3;x++) {
			for(int y=0;y<3;y++)
				turn_on( x , y );
		}
		turn_off( l , h );
		power(2);
		delay_ms(21);
	}
	
	
}

/* rand fill/rm */
void randfill()
{

    	for(int z=0;z<3;z++)
		for(int x=0;x<3;x++)
			for(int y=0;y<3;y++)
				cube[z][x][y]=0;

	clear();

	// rand fill
	for(int fill=0;fill<27;fill++) {

		int x=myRand(3);
		int y=myRand(3);
		int z=myRand(3);
		while(cube[z][x][y] == 1) {
			x=myRand(3);
			y=myRand(3);
			z=myRand(3);
		}
		cube[z][x][y]=1;

		for(int lala=0; lala<9; lala++) {
			clear();
			for(int i=0;i<3;i++) {
				for(int j=0;j<3;j++) {
					if(cube[0][i][j]==1)
						turn_on( i , j );
				}
			}	
			power(0);
			delay_ms(21);

			clear();
			for(int i=0;i<3;i++) {
				for(int j=0;j<3;j++) {
					if(cube[1][i][j]==1)
						turn_on( i , j );
				}
			}	
			power(1);
			delay_ms(21);

			clear();
			for(int i=0;i<3;i++) {
				for(int j=0;j<3;j++) {
					if(cube[2][i][j]==1)
						turn_on( i , j );
				}
			}	
			power(2);
			delay_ms(21);
		}
	}


	// rand rm 
    	for(int z=0;z<3;z++)
		for(int x=0;x<3;x++)
			for(int y=0;y<3;y++)
				cube[z][x][y]=1;

	clear();

	for(int fill=0;fill<27;fill++) {

		int x=myRand(3);
		int y=myRand(3);
		int z=myRand(3);
		while(cube[z][x][y] == 0) {
			x=myRand(3);
			y=myRand(3);
			z=myRand(3);
		}
		cube[z][x][y]=0;

		for(int lala=0; lala<9; lala++) {
			clear();
			for(int i=0;i<3;i++) {
				for(int j=0;j<3;j++) {
					if(cube[0][i][j]==1)
						turn_on( i , j );
				}
			}	
			power(0);
			delay_ms(21);

			clear();
			for(int i=0;i<3;i++) {
				for(int j=0;j<3;j++) {
					if(cube[1][i][j]==1)
						turn_on( i , j );
				}
			}	
			power(1);
			delay_ms(21);

			clear();
			for(int i=0;i<3;i++) {
				for(int j=0;j<3;j++) {
					if(cube[2][i][j]==1)
						turn_on( i , j );
				}
			}	
			power(2);
			delay_ms(21);
		}
	}

/*	clear();
	for(int x=0;x<3;x++) {
		for(int y=0;y<3;y++)
			turn_on( x , y );
	}

	for(int i=0; i<18; i++) {
		power(0);
		delay_ms(21);
		power(1);
		delay_ms(21);
		power(2);
		delay_ms(21);
	}	*/

}

/* inverted randblink */
void invrandbl()
{

	int x=myRand(3);
	int y=myRand(3);
	int z=myRand(3);
	
	for(int i=0; i<9; i++) {
		clear();
		for(int x=0;x<3;x++) {
			for(int y=0;y<3;y++)
				turn_on( x , y );
		}
		if(z==0)
			turn_off( x , y );
		power(0);
		delay_ms(20);

		clear();
		for(int x=0;x<3;x++) {
			for(int y=0;y<3;y++)
				turn_on( x , y );
		}
		if(z==1)
			turn_off( x , y );
		power(1);
		delay_ms(20);

		clear();
		for(int x=0;x<3;x++) {
			for(int y=0;y<3;y++)
				turn_on( x , y );
		}
		if(z==2)
			turn_off( x , y );
		power(2);
		delay_ms(20);
	}	
}



/******  Hauptprogramm  ******/

int main (void) 
{

    /* Output */
    DDRD = (1<<PD0) | (1<<PD1) | (1<<PD2);
    DDRC = (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4) | (1<<PC5);
    DDRB = (1<<PB3) | (1<<PB4) | (1<<PB5);


    // Interupts anschalten für compare Wert
    TIMSK |= (1 << OCIE1A);
	
    // Timer 2 konfigurieren, kein Prescaler
    TCCR1B = (0<<CS12) | (0<<CS11) | (1<<CS10) | (1<<WGM12);

    // compare Wert setzten -> 4*10^6 / 4*10^4 = 10^2; => Interrupt wird jede Millisekunde aufgerufen (100Hz)
    OCR1A = 39999;
	
    // Interupts allg. aktivieren
    sei();


    /******  Endlos-Scheife  ******/

    while(1) {

	switch(step) {

		case 0:
			rain();
			break;
		case 1:
			updown();
			break;
		case 2:
			lauf();
			break;
		case 3:
			sec=0;
			milli=0;
			dreh();
			break;
		case 4:
			sec=0;
			milli=0;
			dreh();		// dreh adding
			break;
		case 5:
			leftright();
			break;
		case 6:
			leftright();	// knight rider
			break;
		case 7:
			updown();	// knight rider
			break;
		case 8:
			frontrear();	// knight rider
			break;
		case 9:
			frontrear();
			break;
		case 10:
			drehfast(9);
			break;
		case 11:
			drehfast(9);	// add remove
			break;
		case 12:
			drehfast(5);	// add remove faster
			break;
		case 13:
			randbl();
			break;
		case 14:
			randrm();
			break;
		case 15:
			randbl();	// double rand blink
			break;
		case 16:
			buildcube();
			break;
		case 17:
			drehagain();
			break;
		case 18:
			lauf2();
			break;
		case 19:
			buildcube2();
			break;
		case 20:
			rain2();
			break;
		case 21:
			randfill();
			break;
		case 22:
			invrandbl();
			break;
	}

    }
    return 0;
}