Lampensimulator 2.0

// Software für Lampensimulator mit ATtiny2313

#include <avr/io.h>
#include <stdlib.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define TRUE 1
#define FALSE 0

// Fuse-Bits: --- für internen Clock ---
// efuse = FF
// hfuse = DF
// lfuse = E2 (4 MHz Grundtaktakt ohne Teilung)
// -> Frequenz : 4.000.000 Hz

/* Erläuterung zu Bitmanipulation: PORTB &= ~(1 << PIN0) (Bit löschen)
(1 << n) : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben.
Dies ergibt somit 0b00000001 für (1 << PIN0) und 0b00000100 für (1 << PIN2).
Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 or 0b00000100 wird zu 0b00000101.
~ : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
&= : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.
Quelle: http://www.mikrocontroller.net/articles/Bitmanipulation#AVR-Assembler
*/

// Die Lampen werden durch das Auslesen entsprechender Arrays gesteuert:
// Der Teiler gibt an, wie viele Zyklen (je 130 ms) von TIMER1_OVF_vect
// für eine Hell- bzw. Dunkelphase gebraucht werden:
#define BLINKARRAY1A_LAENGE 2
#define BLINKARRAY1A_TEILER 8 // Takt 0,5 Hz.
#define BLINKARRAY2A_LAENGE 2
#define BLINKARRAY2A_TEILER 4 // Takt 1 Hz.
#define BLINKARRAY3A_LAENGE 2
#define BLINKARRAY3A_TEILER 2 // Takt 2 Hz.

#define BLINKARRAY1B_LAENGE 6
#define BLINKARRAY1B_TEILER 4 // Takt 1 Hz.
#define BLINKARRAY2B_LAENGE 8
#define BLINKARRAY2B_TEILER 4 // Takt 1 Hz.
#define BLINKARRAY3B_LAENGE 10
#define BLINKARRAY3B_TEILER 4 // Takt 1 Hz.


volatile uint8_t BlinkArray1AZaehler = 0; // Normales Wechselblinken LED 1
volatile uint8_t BlinkArray1A[BLINKARRAY1A_LAENGE] = {1,0};

volatile uint8_t BlinkArray2AZaehler = 0; // Normales Wechselblinken LED 2
volatile uint8_t BlinkArray2A[BLINKARRAY2A_LAENGE] = {1,0};

volatile uint8_t BlinkArray3AZaehler = 0; // Normales Wechselblinken LED 3
volatile uint8_t BlinkArray3A[BLINKARRAY3A_LAENGE] = {1,0};

volatile uint8_t BlinkArray1BZaehler = 0; // Position blinken - 2 s Pause und 1 x Puls 0,5 s
volatile uint8_t BlinkArray1B[BLINKARRAY1B_LAENGE] = {0,0,0,0,1,0};

volatile uint8_t BlinkArray2BZaehler = 0; // Position blinken - 2 s Pause und 2 x Puls 0,5 s
volatile uint8_t BlinkArray2B[BLINKARRAY2B_LAENGE] = {0,0,0,0,1,0,1,0};

volatile uint8_t BlinkArray3BZaehler = 0; // Position blinken - 2 s Pause und 3 x Puls 0,5 s
volatile uint8_t BlinkArray3B[BLINKARRAY3B_LAENGE] = {0,0,0,0,1,0,1,0,1,0};

// Speicher-Variablen für die Zustände Wechselblinken oder Positionierungssignal:
// FALSE = Normales Wechselblinken
// TRUE = Positionierungssignal ausgeben
volatile uint8_t taster1toggle = FALSE; // Toggle-Zustand  Taster 1
volatile uint8_t taster2toggle = FALSE; // Toggle-Zustand  Taster 2
volatile uint8_t taster3toggle = FALSE; // Toggle-Zustand  Taster 3

/* -------------------------------------------------------------------------------------
   Timer1-Interrupt-Funktion:
--------------------------------------------------------------------------------------*/
ISR(TIMER1_OVF_vect)
{
    if (taster1toggle == FALSE)
        {
        // Normales Blinken
        if (BlinkArray1A[BlinkArray1AZaehler/BLINKARRAY1A_TEILER]==TRUE)
            {
                PORTB |= (1<<PIN0); // Bit setzen
            }
            else
            {
                PORTB &= ~(1 << PIN0); // Bit löschen
            }

        BlinkArray1AZaehler++;
        if (BlinkArray1AZaehler>(BLINKARRAY1A_LAENGE*BLINKARRAY1A_TEILER))
            {
                BlinkArray1AZaehler=0;
            }
        }
    else
        {
        // Positionierungssignal ausgeben
        if (BlinkArray1B[BlinkArray1BZaehler/BLINKARRAY1B_TEILER]==TRUE)
            {
                PORTB |= (1<<PIN0); // Bit setzen
            }
            else
            {
                PORTB &= ~(1 << PIN0); // Bit löschen
            }

        BlinkArray1BZaehler++;
        if (BlinkArray1BZaehler>(BLINKARRAY1B_LAENGE*BLINKARRAY1B_TEILER))
            {
                BlinkArray1BZaehler=0;
            }
        }

    if (taster2toggle == FALSE)
        {
        // Normales Blinken
        if (BlinkArray2A[BlinkArray2AZaehler/BLINKARRAY2A_TEILER]==TRUE)
            {
                PORTB |= (1<<PIN1); // Bit setzen
            }
            else
            {
                PORTB &= ~(1 << PIN1); // Bit löschen
            }

        BlinkArray2AZaehler++;
        if (BlinkArray2AZaehler>(BLINKARRAY2A_LAENGE*BLINKARRAY2A_TEILER))
            {
                BlinkArray2AZaehler=0;
            }
        }
        else
        {
        // Positionierungssignal ausgeben
        if (BlinkArray2B[BlinkArray2BZaehler/BLINKARRAY2B_TEILER]==TRUE)
            {
                PORTB |= (1<<PIN1); // Bit setzen
            }
            else
            {
                PORTB &= ~(1 << PIN1); // Bit löschen
            }

        BlinkArray2BZaehler++;
        if (BlinkArray2BZaehler>(BLINKARRAY2B_LAENGE*BLINKARRAY2B_TEILER))
            {
                BlinkArray2BZaehler=0;
            }
        }
    if (taster3toggle == FALSE)
        {
        // Normales Blinken
        if (BlinkArray3A[BlinkArray3AZaehler/BLINKARRAY3A_TEILER]==TRUE)
            {
                PORTB |= (1<<PIN2); // Bit setzen
            }
            else
            {
                PORTB &= ~(1 << PIN2); // Bit löschen
            }

        BlinkArray3AZaehler++;
        if (BlinkArray3AZaehler>(BLINKARRAY3A_LAENGE*BLINKARRAY3A_TEILER))
            {
                BlinkArray3AZaehler=0;
            }
        }
        else
        {
        // Positionierungssignal ausgeben
        if (BlinkArray3B[BlinkArray3BZaehler/BLINKARRAY3B_TEILER]==TRUE)
            {
                PORTB |= (1<<PIN2); // Bit setzen
            }
            else
            {
                PORTB &= ~(1 << PIN2); // Bit löschen
            }

        BlinkArray3BZaehler++;
        if (BlinkArray3BZaehler>(BLINKARRAY3B_LAENGE*BLINKARRAY3B_TEILER))
            {
                BlinkArray3BZaehler=0;
            }
        }

}

int Init_Timer1(void)
{
    // Timer 1 ist 16-Bit-Timer
    // CS12=0, CS11=1, CS10=0 => Vorteiler 8;  -> 4.000.000 Hz : 8  = 500 000
    // Der Overflow-Interrupt wird aber erst ausgelöst, wenn der Zähler die Zahl 65 536 (16 Bit) erreicht
    // Zeitintervall = 500 000 : 65 536 = 7,63 Hz (ca. alle 130 ms)
    // Damit lassen sich Frequenzen von 1, 2 und 0,5 Hz. "einigermaßen" genau ableiten
    TCCR1B |= (0<<CS12) | (1<<CS11) | (0<<CS10); // Vorteiler 8
    TIMSK |= (1<<TOIE1); // Enable timer 1 interrupt -> ohne die anderen Bits zu verändern
    sei(); //enable all interrupts
    return 0;
}

//Funktion zum abfragen des Zustands des negierenden Tasters1
int taster1(void)
{


    if (PIND & (1<<PIND0))
        {
            return FALSE;
        }
        else
        {
            return TRUE;
        }

}

//Funktion zum abfragen des Zustands des negierenden Tasters2
int taster2(void)
{


    if (PIND & (1<<PIND1))
        {
            return FALSE;
        }
        else
        {
            return TRUE;
        }

}

//Funktion zum abfragen des Zustands des negierenden Tasters3
int taster3(void)
{


    if (PIND & (1<<PIND2))
        {
            return FALSE;
        }
        else
        {
            return TRUE;
        }

}

int main (void) {

    // Port B Pin0, Pin1, Pin2 auf Ausgang setzen
    DDRB |= (1 << PIN0) | (1 << PIN1) | (1 << PIN2);
    // Port D Pin0, Pin1 und Pin2 (Taster 1, 2 3) als Eingänge setzen
    DDRD &= ~((1 << PIN0) | (1 << PIN1) | (1 << PIN2));

    Init_Timer1();

    uint8_t taster1_alt = FALSE;
    uint8_t taster2_alt = FALSE;
    uint8_t taster3_alt = FALSE;

    while (1)
        {
            if ((taster1()==TRUE) && (taster1_alt == FALSE))
                {
                if (taster1toggle==FALSE)
                    {
                        taster1toggle=TRUE;
                // Sorgt dafür, dass Positionierungs-Ausgabe mit 2 s Pause startet:
                        BlinkArray1BZaehler = 0;
                    }
                    else
                    {
                        taster1toggle=FALSE;
                    }

                }
            taster1_alt=taster1();

            if ((taster2()==TRUE) && (taster2_alt == FALSE))
                {
                if (taster2toggle==FALSE)
                    {
                        taster2toggle=TRUE;
                // Sorgt dafür, dass Positionierungs-Ausgabe mit 2 s Pause startet:
                        BlinkArray2BZaehler = 0;
                    }
                    else
                    {
                        taster2toggle=FALSE;
                    }

                }
            taster2_alt=taster2();

            if ((taster3()==TRUE) && (taster3_alt == FALSE))
                {
                if (taster3toggle==FALSE)
                    {
                        taster3toggle=TRUE;
                // Sorgt dafür, dass Positionierungs-Ausgabe mit 2 s Pause startet:
                        BlinkArray3BZaehler = 0;
                    }
                    else
                    {
                        taster3toggle=FALSE;
                    }
                }
            taster3_alt=taster3();

            _delay_ms(10);
        }
    return 0;
}