/* 
 * File:   Kap_Tasten.c
 * Author: ioener
 *
 * Created on 18. Juni 2012, 10:33
 */

#include <stdio.h>
#include <stdlib.h>
#include <p18lf45k22.h>
#include <reset.h>


/* Konfiguration */

#pragma config FOSC = INTIO67       // Interne Oszillator
#pragma config PWRTEN = ON          // Power up Timer
#pragma config BOREN = OFF          // Brown of Reset
#pragma config WDTEN = OFF          // Watchdog Timer
#pragma config LVP = OFF            // Low Voltage ICSP
#pragma config MCLRE = EXTMCLR      // externer MCLR
#pragma code


/* ADCON Register Einstellungen für z.B AD=ON, GO_DONE Datenblatt auf der Seite 304 */

#define Vref 0b01111101
#define Taste1_Abfrage 0b01000101       // ADCON für AN17 der Taste 1 definiert 
#define Taste2_Abfrage 0b01100101       // ADCON für AN25 der Taste 2 definiert
#define Taste3_Abfrage 0b00100001       // ADCON für AN8 der Taste  3 definiert
#define Taste4_Abfrage 0b01001001       // ADCON für AN18 der Taste 4 definiert 
#define Taste5_Abfrage 0b01101001       // ADCON für AN26 der Taste 5 definiert
#define Taste6_Abfrage 0b00100101       // ADCON für AN9 der Taste  6 definiert
#define Taste7_Abfrage 0b01001101       // ADCON für AN19 der Taste 7 definiert
#define Taste8_Abfrage 0b01101101       // ADCON für AN27 der Taste 8 definiert
#define Taste9_Abfrage 0b00101101       // ADCON für AN11 der Taste 9 definiert
#define Taste0_Abfrage 0b00101001       // ADCON für AN10 der Taste 0 definiert
#define TasteStern_Abfrage 0b01100001   // ADCON für AN24 der Taste * definiert
#define TasteRaute_Abfrage 0b00110101   // ADCON für AN13 der Taste # definiert

/* Damit nicht die einzelnen LAT Befehle der Ausgänge Später ausgegeben werden können,
 * werden die Befehle an die definierten Parameter übergeben */

#define LED1 LATDbits.LATD2      // Ausgang RD2 wird auf LED1_Taste1 übergeben
#define LED2 LATDbits.LATD1      // Ausgang RD1 wird auf LED2_Taste2 übergeben
#define LED3 LATDbits.LATD0      // Ausgang RD0 wird auf LED3_Taste3 übergeben
#define LED4 LATCbits.LATC3      // Ausgang RC3 wird auf LED4_Taste4 übergeben
#define LED5 LATCbits.LATC2      // Ausgang RC2 wird auf LED5_Taste5 übergeben
#define LED6 LATCbits.LATC1      // Ausgang RC1 wird auf LED6_Taste6 übergeben
#define LED7 LATEbits.LATE0      // Ausgang RE0 wird auf LED7_Taste7 übergeben
#define LED8 LATAbits.LATA5      // Ausgang RA5 wird auf LED8_Taste8 übergeben
#define LED9 LATAbits.LATA4      // Ausgang RA4 wird auf LED9_Taste9 übergeben
#define LED10 LATAbits.LATA3     // Ausgang RA3 wird auf LED10_Taste0 übergeben
#define LED11 LATAbits.LATA2     // Ausgang RA2 wird auf LED11_Taste* übergeben
#define LED12 LATAbits.LATA1     // Ausgang RA1 wird auf LED12_Taste# übergeben

#define GODONE ADCON0bits.GO_DONE       // GODONE definition

void Initialisierung(void);             // Initialisierungseinstellungen
void Vreferenz(void);                   // Funktion Referenzspannung
void Taste1(void);                      // Funktion Taste1
void Taste2(void);                      // Funktion Taste2
void Taste3(void);                      // Funktion Taste3
void Taste4(void);                      // Funktion Taste4
void Taste5(void);                      // Funktion Taste5
void Taste6(void);                      // Funktion Taste6
void Taste7(void);                      // Funktion Taste7
void Taste8(void);                      // Funktion Taste8
void Taste9(void);                      // Funktion Taste9
void Taste0(void);                      // Funktion Taste0
void TasteStern(void);                  // Funktion TasteStern
void TasteRaute(void);                  // Funktion TasteRaute
unsigned int Ergb(void);                // Hier wird die Ergebnis ausgelesen


void main(void)                         //Hauptprogramm main
{

    Initialisierung();                  // Initialisierung wird fortgesetzt

    do
    {
        /* Aufruf der einzelnen Funktionen */
        Taste1();
        Taste2();
        Taste3();
        Taste4();
        Taste5();
        Taste6();
        Taste7();
        Taste8();
        Taste9();
        Taste0();
        TasteStern();
        TasteRaute();

    }while(1);

}

void Initialisierung(void)
{
    /* Alle Pins auf Digital gesetzt */
    ANSELA = 0x00;
    ANSELB = 0x00;
    ANSELC = 0x00;
    ANSELD = 0x00;
    ANSELE = 0x00;

    /* Alle Pins auf LOW gesetzt */
    PORTA = 0x00;
    PORTB = 0x00;
    PORTC = 0x00;
    PORTD = 0x00;
    PORTE = 0x00;

    /* Alle Pins auf Ausgang gesetzt */
    TRISA = 0x00;
    TRISB = 0x00;
    TRISC = 0x00;
    TRISD = 0x00;
    TRISE = 0x00;

    /* ADCON1 Register Einstellungen für Referenzspannung, Datenblatt auf der Seite 305 */
    ADCON1 = 0b00000000;        // TRIGSEL = CCP5, A/D VREF+ connected to internal signal AVDD als Referenzspannung

    /* ADCON2 Register Einstellungen für TAD, Taktfrequenz der ADC, Datenblatt auf der Seite 306 */
    ADCON2 = 0b10010001;        // Rechtsbündig; 4TAD(8us); FOSC/8 = 500kHz ADC Taktfrequenz
    
    /* OSCCON Register Einstellungen z.B. für Oszillator, Sleep, Datenblatt auf der Seite 32 */
    OSCCON = 0x54;              // Register für die Interne Oszillator

    /* Fixed Voltage Reference Register S.344 */
    VREFCON0 = 0b11100000;      // FVR Ein, FVR (+2,048V)

}

void Vreferenz(void)            // Funktion für die Aufladung des Sample&Hold Kondensator
{

    /* TESTEN */
//    ADCON1bits.PVCFG0 = 0;
//    ADCON1bits.PVCFG1 = 0;
//    ADCON1bits.NVCFG0 = 0;
//    ADCON1bits.NVCFG1 = 0;

    ADCON0 = Vref;
    GODONE =1;
    while(GODONE == 1);

}

void Taste1(void)
{
    unsigned int Ergebnis;      // Dekleration Ergebnis
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++) //Mittelwertbildung der ADC Werte
    {
   
        Vreferenz();                // Aufruf der Funktion Vreferenz() für die Aufladung des Sample&Hold Kondensator
    
        TRISCbits.TRISC5 = 1;       // Taste1 als Eingang gewählt

        ADCON0 = Taste1_Abfrage;    // AN17 Eingang
    
        Ergebnis = Ergb();          // Taste ungedrückt Wert von Ergebnis = 0x016B

        SummeMessungen = SummeMessungen + Ergebnis; // ADC Werte werden aufsumiert und auf "SummeMessungen" gespeichert

        TRISCbits.TRISC5 = 0;       // Taste1 wieder als Ausgang bzw. Csensor wird entladen- Sehr wichtig

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x016C 
    
    if(Ergebnis <= 0x015F)      // Schwellwert bei ca. 3Newton
    {
        LED1 = 1;               // LED1 geht an
    }
    else
    {
        LED1 = 0;               // LED1 geht nicht an
    }
 
}

void Taste2(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISDbits.TRISD5 = 1;

        ADCON0 = Taste2_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISDbits.TRISD5 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x016F

    if(Ergebnis <= 0x0165)      // Schwellwert bei ca. 3Newton
    {
        LED2 = 1;
    }
    else
    {
        LED2 = 0;
    }

}

void Taste3(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISBbits.TRISB2 = 1;

        ADCON0 = Taste3_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISBbits.TRISB2 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0163

    if(Ergebnis <= 0x0158)          // Schwellwert bei ca. 3Newton
    {
        LED3 = 1;
    }
    else
    {
        LED3 = 0;
    }
   
}

void Taste4(void)
{
    unsigned int Ergebnis;               // Dekleration Ergebnis
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISCbits.TRISC6 = 1;       // Taste4 als Eingang gewählt

        ADCON0 = Taste4_Abfrage;    // AN18 Eingang

        Ergebnis = Ergb();          // Wert von Ergebnis = 0x0165

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISCbits.TRISC6 = 0;       // Taste4 wieder als Ausgang

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0169

    if(Ergebnis <= 0x015E)          // Schwellwert bei ca. 3Newton
    {
        LED4 = 1;        // LED4 geht an
    }
    else
    {
        LED4 = 0;        // LED4 geht nicht an
    }

}

void Taste5(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISDbits.TRISD6 = 1;

        ADCON0 = Taste5_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISDbits.TRISD6 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0178

    if(Ergebnis <= 0x016A)          // Schwellwert bei ca. 3Newton
    {
        LED5 = 1;
    }
    else
    {
        LED5 = 0;
    }

}

void Taste6(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISBbits.TRISB3 = 1;

        ADCON0 = Taste6_Abfrage;

        Ergebnis = Ergb();
    
        SummeMessungen = SummeMessungen + Ergebnis;

        TRISBbits.TRISB3 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0175

    if(Ergebnis <= 0x0169)          // Schwellwert bei ca. 3Newton
    {
        LED6 = 1;
    }
    else
    {
        LED6 = 0;
    } 
    
}

void Taste7(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISCbits.TRISC7 =1;

        ADCON0 = Taste7_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISCbits.TRISC7 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0178

    if(Ergebnis <= 0x016B)          // Schwellwert bei ca. 3Newton
    {
        LED7 = 1;
    }
    else
    {
        LED7 = 0;
    }

}

void Taste8(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISDbits.TRISD7 = 1;

        ADCON0 = Taste8_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISDbits.TRISD7 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0183

    if(Ergebnis <= 0x0178)          // Schwellwert bei ca. 3Newton
    {
        LED8 = 1;
    }
    else
    {
        LED8 = 0;
    }

}

void Taste9(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISBbits.TRISB4 = 1;

        ADCON0 = Taste9_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISBbits.TRISB4 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0186

    if(Ergebnis <= 0x0179)          // Schwellwert bei ca. 3Newton
    {
        LED9 = 1;
    }
    else
    {
        LED9 = 0;
    }
   
}

void Taste0(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISBbits.TRISB1 = 1;

        ADCON0 = Taste0_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISBbits.TRISB1 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x018C

    if(Ergebnis <= 0x017F)          // Schwellwert bei ca. 3Newton
    {
        LED10 = 1;
    }
    else
    {
        LED10 = 0;
    }
    
}

void TasteStern(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISDbits.TRISD4 = 1;

        ADCON0 = TasteStern_Abfrage;

        Ergebnis = Ergb();

        SummeMessungen = SummeMessungen + Ergebnis;

        TRISDbits.TRISD4 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0194

    if(Ergebnis <= 0x0188)          // Schwellwert bei ca. 3Newton
    {
        LED11 = 1;
    }
    else
    {
        LED11 = 0;
    }
    
}

void TasteRaute(void)
{
    unsigned int Ergebnis;
    int anzahl=8;
    int AnzahlMessungen;
    unsigned int SummeMessungen=0;

    for(AnzahlMessungen=0; AnzahlMessungen < anzahl; AnzahlMessungen++)
    {

        Vreferenz();

        TRISBbits.TRISB5 = 1;

        ADCON0 = TasteRaute_Abfrage;

        Ergebnis = Ergb();
    
        SummeMessungen = SummeMessungen + Ergebnis;

        TRISBbits.TRISB5 = 0;

    }

    Ergebnis = SummeMessungen / anzahl;     // ~0x0193

    if(Ergebnis <= 0x0188)          // Schwellwert bei ca. 3Newton
    {
        LED12 = 1;
    }
    else
    {
        LED12 = 0;
    }

}

unsigned int Ergb(void)
{
    unsigned int Ergebnis;          // Dekleration Ergebnis

    GODONE = 1;                     // Konvertierung wird gestartet
    while(GODONE == 1);             // Es wird gewartet bis die Konvertierung abgeschlossen ist
    Ergebnis = ADRESH;              // Die Wert in dem Register ADRESH wird an Ergebnis übergeben
    Ergebnis = Ergebnis << 8;       // Ergebnis wird um 8 bit von rechts nach links verschoben
    Ergebnis = Ergebnis + ADRESL;   // Die Wert in dem Register ADRESL wird auf Ergebnis zu Addiert7

    return Ergebnis;                // Ergebnis wird weitergegeben
}


////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////