/*****************\
|   16 LED Herz   |
|   lfuse: 0xE4   |
|   hfuse: 0xF3   |
\*****************/
//Taktrequenz 8 mhz
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

const unsigned char muster1[16][16] PROGMEM = {
//sekunde 1
{0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff},
{0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f},
{0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f},
{0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f},
{0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f},
{0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07},
{0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03},
{0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
//sekunde 2
{0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03},
{0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07},
{0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f},
{0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f},
{0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f},
{0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f}
};
//gesamt: 1,6 sekunden, = 256 bytes speicher = 16 zeilen






volatile unsigned char helligkeit0[8];
    //helligkeit der ersten 8 leds
volatile unsigned char helligkeit1[8];
    //helligkeit der zweiten 8 leds
volatile unsigned char aktHelligkeit[8];
    //helligkeit der gerade aktiven leds
volatile unsigned char haelfte;
    //gerade aktive haelfte (0 oder 1)
volatile unsigned char taktzaehler=0;
    //zaehlt 10 takte zwischen 2 led schritten
volatile unsigned char schritt=0;
    //aktueller schritt

void initTimer1(void)
{
    //Timer 1: Umschalten zwischen den LEDs, alle 20 ms
    //Ein Interrupt alle 10 ms nötig
    //10ms = 80.000 Taktzyklen
    //Prescaler für Timer 0: 512
    //Timer muss bis 156 zählen
    OCR1C  = 156;     //Maximalwert festlegen
    TCCR1A = 0x00;    //Alle Eigenintelligenz abschalten
    TCCR1B = 0x8A;    //Timer 1 einschalten, Maximalwert
                      //aktivieren, Takt/512
    //Timer zählt jetzt mit Systemtakt/512 Hz, immer bis 156.
    TIMSK = 0x04;     //TOV1 Interrupt aktivieren (Timer OverFlow)
}
void initTimer0(void)
{
    //Timer 0: Dieser TImer muss nur zählen. So lange der
    //Zähler unter dem Helligkeitswert der LED ist, bleibt die LED
    //an. je größer der helligkeitswert, desto länger bleibt die
    //LED an.
    TCCR0 = 0x02;    // Timer 0 einschalten, Takt = Systemtakt/8
}
ISR(TIMER1_OVF1_vect)
{
    if(haelfte==0)
    {
        //wenn bis jetzt haelfte 0 aktiviert war, aktiviere 1:
        haelfte=1;
        //schalte transistor 0 aus:
        PORTB &= ~(1<<PB0);
        //schalte transistor 1 an:
        PORTB |= (1<<PB1);
        //ausserdem müssen die neuen helligkeiten geladen werden:
        for(int i=0;i<8;i++)
        {
            aktHelligkeit[i]=helligkeit1[i];
            //die helligkeit von haelfte 1 in die aktuelle
            //helligkeit kopieren
        }
    }
    else
    {
        //wenn bis jetzt haelfte 1 aktiviert war, aktiviere 0:
        haelfte=0;
        //schalte transistor 1 aus:
        PORTB &= ~(1<<PB1);
        //schalte transistor 0 an:
        PORTB |= (1<<PB0);
        //ausserdem müssen die neuen helligkeiten geladen werden:
        for(int i=0;i<8;i++)
        {
            aktHelligkeit[i]=helligkeit0[i];
            //die helligkeit von haelfte 0 in die aktuelle
            //helligkeit kopieren
        }
    }
    //alle 100 ms sollen neue led werte geladen werden. also 10 akte abwarten
    taktzaehler++;
    if(taktzaehler==10)
    {
        taktzaehler=0;
        schritt++;
        if(schritt==16) schritt=0;

        for(int i=0;i<16;i+=2)
        {
            helligkeit0[i]=pgm_read_byte(&muster1[schritt][i]);
            helligkeit1[i]=pgm_read_byte(&muster1[schritt][i+1]);

        }
    }
}
int main(void)
{
    DDRA=0xFF;
    DDRB = 0xFF;
    PORTB |= (1<<PB2);
    initTimer0();
    initTimer1();
    sei();
    helligkeit1[0]=0;
    helligkeit1[1]=128;
    helligkeit1[2]=0;
    helligkeit1[3]=128;
    helligkeit1[4]=0;
    helligkeit1[5]=128;
    helligkeit1[6]=0;
    helligkeit1[7]=128;


    helligkeit0[0]=0;
    helligkeit0[1]=128;
    helligkeit0[2]=0;
    helligkeit0[3]=128;
    helligkeit0[4]=0;
    helligkeit0[5]=64;
    helligkeit0[6]=128;
    helligkeit0[7]=255;



    while(1)
    {
        for(int i=0;i<8;i++)
        {
            if(TCNT0<aktHelligkeit[i])
                PORTA |= (1<<i);
            else
                PORTA &= ~(1<<i);
        }
    }
    return 0;
}