Ueb.4.3

/********************************************************************/
/*  Hochschule fuer Technik und Wirtschaft                          */
/*  Fakultät fuer Ingenieurwissenschaften                           */
/*  Labor fuer Eingebettete Systeme                                 */
/*  Mikroprozessortechnik                                           */
/********************************************************************/
/*                                                                  */
/*  C_Übung.C:                                                      */
/*    Programmrumpf fuer C-Programme mit dem Keil                   */
/*    Entwicklungsprogramm uVision fuer ARM-Mikrocontroller         */
/*                                                                  */
/********************************************************************/
/*  Aufgaben-Nr.: 2.1                   *                                   */
/*                                      *                                   */
/********************************************************************/
/*  Gruppen-Nr.: 12                     *                                   */
/*                                      *                                   */
/********************************************************************/
/*  Name / Matrikel-Nr.:                *                                   */
/*  Dennis Groß 3777596        *                                   */
/*  Klaus Luhan                                 *                                   */
/********************************************************************/
/*  Abgabedatum: 17.01.19       *                                   */
/*                                      *                                   */
/********************************************************************/

#include <LPC21xx.H>        /* LPC21xx Definitionen                     */

#define D_ZERO  0x0FC0000                   // a, b, c, d, e, f         -> 0
#define D_ONE   0x180000                        // b,c                                  -> 1
#define D_TWO   0x16C0000                   // a, b, d, e, g                -> 2
#define D_THREE 0x13C0000                   // a, b, c, d, g                -> 3
#define D_FOUR  0x1980000                   // b, c, f, g                   -> 4
#define D_FIVE  0x1B40000                   // a, c, d, f, g                -> 5
#define D_SIX       0x1F40000                   // a, c, d, e, f, g         -> 6
#define D_SEVEN 0x1C0000                        // a, b, c                          -> 7
#define D_EIGHT 0x1FC0000                   // a, b, c, d, e, f, g  -> 8
#define D_NINE  0x1BC0000                   // a, b, c, d, f, g         -> 9

/*
 * Bitmuster für den Kippschalter
 */
#define FLIP 0x2000000

/*
 * Forward delaration
 */
void flip_switcher(void) __irq;

/*
 * Zählervariable
 */
volatile int count = 0;

/*
 * digits enthälrt HEX Werte für die 7 Segment Anzeige für 0-9
 */
unsigned long digits[10]={
    D_ZERO,
    D_ONE,
  D_TWO,
    D_THREE,
    D_FOUR,
  D_FIVE,
  D_SIX,
  D_SEVEN,
  D_EIGHT,
  D_NINE
};

int main(void){
    /*
     * IODIR0 definiert ob ein Port als Eingang oder Ausgang gesetzt ist
     * 0x1FC0000 in binär 1111111000000000000000000
     * Setze die 7 Segmente auf Ausgang
     */
  IODIR0 = 0x1FC0000;

    /*
     * IOCLR0 sendet LOW Pegel
     * 0x1FC0000 in binär 1111111000000000000000000
     * Setze alle Segmente auf Grundstellung (aus)
     */
    IOCLR0 = 0x1FC0000;

    /*
     * Setze den Prescalar auf einen Wert der den Takt auf eine Milisekunde festlegt
     * p_clock / prescaler = Takt
     * p_clock ist 12,5 MhZ / 12500 = 1 milisekunde Takt
        */
    T0PR = 12500; /*Prescaler einstellen */

    /*
     * Reset timer auf 0
     */
    T0TCR = 0x02;

    /*
     * Starte timer
     */
    T0TCR = 0x01;

    /*
     * Setze folgede Matcher Bits:
     * 0 - interrupt bei MR0 (Interrupt bei Gleichheit mit dem MR0-Register)
     * 1 - Timer-Reset bei MR0 (Zählerstand rücksetzen bei Gleichheit mit MR0)
     */
    T0MCR = 0x03;

    /*
     * Setze den Matcher auf jede Sekunde
     * Takt nach prescaler steht auf 1 Milisekunde pro Takt,
     * 1s ^= 1000 ms
     */
    T0MR0 = 1000;

    /*
     * Setze Addresse für Service Interrupt Routine
     */
    VICVectAddr0 = (unsigned long) flip_switcher;

    /*
     * 0x24 in binär 100100
     * 00100 steht für Kanal 4 (TIMER0)
     * das 5 te bit aktiviert den Kanal
     */
    VICVectCntl0 = 0x24;

    /*
     * 0x10 in binär 10000
     * Erlaube Interrupt auf Kanal 4 in dem das 5te bit auf 1 gesetzt wird
     * Jedes bit entspricht einem Kanal
     */
    VICIntEnable = 0x10; /*erlaubt Kanal 4 einen Interrupt auszulösen*/

    /*
     * main loop
     */
    while(1) {
        ;
    }
}

/*
 * Service Interrupt Routine
 * __irg deklariert die Interrupt Routine als IRQ
 */
void flip_switcher(void) __irq{
  if(IOPIN1 & FLIP) {
        /*
         * Fall Schalter gesetzt -> dekrementiere Zahlen auf der 7 Segment Anzeige
         */

        /*
         * Setze mit IOCLR auf Grundstellung (8 wird angezeigt)
         * ICLR0 sendet LOW-Pegel
         */
    IOCLR0 = D_EIGHT;

        /*
         * dekrementiere count um 1 und rechne mod 10 sodass das Ergebnis immer in 0 - 9 liegt
         * Bekomme die entsprechende HEX Zahl vom digits array und sende einen HIGH Pegel für die
         * entsprechenden bits der HEX Zahl
         */
    IOSET0 = digits[count-- % 10];

        /*
         * wenn die erste Zahl (0) erreicht wurde beginne mit der höchsten im nächsten Durchlauf (9)
         */
    if(count < 0) {
      count = 9;
    }
  } else {
        /*
         * Fall Schalter nicht gesetzt -> inkrementiere Zahlen auf der 7 Segment Anzeige
         */

        /*
         * Setze mit IOCLR auf Grundstellung (8 wird angezeigt)
         * ICLR0 sendet LOW-Pegel
         */
    IOCLR0 = D_EIGHT;

        /*
         * inkrementiere count um 1 und rechne mod 10 sodass das Ergebnis immer in 0 - 9 liegt
         * Bekomme die entsprechende HEX Zahl vom digits array und sende einen HIGH Pegel für die
         * entsprechenden bits der HEX Zahl
         */
    IOSET0 = digits[count++ % 10];

        /*
         * wenn die letzte Zahl (9) erreicht wurde beginne mit der niedrigsten im nächsten Durchlauf (0)
         */
    if(count > 9) {
      count = 0;
    }
  }

    /*
     * Rücksetzen des Interrupt Flags
     */
    T0IR |= 0x10;

    /*
     * Ende Interrupt Routine
     */
    VICVectAddr=0x00;
}