//******************************************************************************
#include <msp430x16x.h>
#include "TS_LC7981.h"
#include <string.h>            // für Zeichen (Infotext) notwendig
#include <stdio.h>             // für sprint
#include <signal.h>

#define TIMEOUT 100         // für Datenempfang

unsigned int t,k; 
void programmversion(void);
void UART1_einstellen(void);
void tasten_entprellen(void);
void E32_konfigurieren(void);
void daten_senden(void);
void daten_ausgeben(void);
void Dx_ausgeben(void);
void temp_ausgeben(void);
void antwort_empfangen(void);
void pause40000(void);

unsigned char config_E32[] = {
    0xC0, // sichert die Parameter nach Stromausfall
    0x03, // Adresse oberes Byte  
    0x03, // Adresse unteres Byte 
    0x1A, // 8N1, UART baut rate:9600 (bps), Übertragungsrate:2,4k (bps)
    0x09, // Kanal 09 gesendet von von Gerät 3
    0xC7  // "fixed" Übetragungsmodus; TXD und AUX als Ausgang RXD als Eingang;  
};

unsigned char txdaten[] = {
    0x02,  // Adresse 
    0x02,  // Adresse
    0x09,  // kanal
    0x56,  // 0x56 löst in LP161 antwort aus
    0x56  
};

unsigned char rxdaten[5];

unsigned char daten1,daten2;
volatile char flag10ms;

int main(void) {
    WDTCTL = WDTPW + WDTHOLD;     // Stop watchdog timer
    P2IE  |= 0x03;                // an  P2.0, P2.1 Interruptfreigabe 
    P2IES |= 0x03;                // auf H/L Flanke  an P2.0, P2.1 
    P5DIR |= BIT6+ BIT7;          // für LED   P5.6 + P5.7
    P5OUT |= BIT6;                // LED grün AUS
    P5OUT |= BIT7;                // LED rot  AUS
    P4DIR |= BIT0 + BIT1;         // M0; M1
    P4OUT |= BIT0 + BIT1;         // M0 und M1 auf 1 --> E32 konfigurieren
    P1DIR =0xFF;                  // FKA
    text_init();                  // in FKA TS_7981.h
    programmversion();
    UART1_einstellen();
    E32_konfigurieren();
    P4OUT &= ~BIT0;               // M0 und M1 auf 0 --> E32 senden/empfangen
    P4OUT &= ~BIT1;               // M0 und M1 auf 0 --> E32 senden/empfangen
    pause40000();
    _EINT();
    
    while(1) {
        tasten_entprellen();
        __delay_cycles (100); // ca. 10ms delay hier einfügen
    }
}

void antwort_empfangen(void){
    unsigned char i, j;
    
    for (i=0, j=0; i<TIMEOUT && j<5; i++ ){
        if (IFG2 & URXIFG1) {
            rxdaten[j++] = RXBUF1;
        }
         __delay_cycles (100);
        // ca. 5 Bitzeiten warten
        // DELAY irgendwas
    }    
    
    if (i==TIMEOUT) { P5OUT &= ~BIT6;   // LED grün EIN    // timeout, nicht alle Daten empfangen
        // was nun?
    } else {        // 5 Bytes empfangen, dekodieren und anzeigen
        P5OUT &= ~BIT7;   //LED rot EIN
        daten1 = (rxdaten[1]<<8) | rxdaten[2];
        daten2 = (rxdaten[3]<<8) | rxdaten[4]; 
     //   daten_ausgeben(daten1);
     //   daten_ausgeben(daten2);
     //   temp_ausgeben(daten1);
        P5OUT |= BIT7;    //LED rot AUS
    }
}

void tasten_entprellen(void) {
    if ((P2IFG&BIT0) == BIT0) {         //Taster 2.0 
        P5OUT &= ~BIT6;                 // LED grün EIN als Kontrolle
        daten_senden();
        P5OUT |=  BIT6;                  // LED grün AUS als Kontrolle
        P2IFG &= ~BIT0;
        antwort_empfangen();   // evtl ist hier die kritische Stelle !!!!!
    }
    if ((P2IFG&BIT1) == BIT1) {  //Taster 2.1   
        P5OUT ^=  BIT6;          // schaltet LED grün, 
        P2IFG &= ~BIT1;
    }
}

void E32_konfigurieren(void) {  
    int i;

    for (i=0; i<6; i++); {
        while (!(IFG2 & UTXIFG1));     // USART1 TX buffer ready? 
        TXBUF1 = config_E32[i];
    }
}      

void UART1_einstellen(void) {
  
    P3SEL  |= 0xC0;                        // P3.6 = USART1 TXD ; P3.7 = RXD1
    ME2    |= UTXE1 + URXE1;               // Enable USART1 TXD/RXD  
    UCTL1  |= CHAR;                        // 8-bit character
    UTCTL1 |= SSEL0;                       // UCLK = ACLK
    UBR01   = 0x03;                        // 32k/9600 - 3.41
    UBR11   = 0x00;                        //
    UMCTL1  = 0x4A;                        // Modulation
    UCTL1  &= ~SWRST;                      // Initialize USART state machine
//   IE2    |= UTXIE1+ URXIE1;              // Enable USART1 RX interrupt 
//  _BIS_SR(LPM3_bits + GIE);              // Enter LPM3 w/ interrupt
   }

void daten_senden(void) {  
    char i;

    P5OUT &= ~BIT7;                     // LED rot EIN
    for (i=0; i<5; i++); {
        while (!(IFG2 & UTXIFG1));      // USART0 TX buffer ready? 
        TXBUF1 = txdaten[i];
    }
    P5OUT |= BIT7;                      //LED rot AUS
}
 
void programmversion(void) {
    char vers[26], z;

    lcd_write_command(LCD_CMD_CURSOR_LA,26);    //26 Zeilenanfang 2.Zeile --> 26 Zeichen pro Zeile
    lcd_write_command(LCD_CMD_CURSOR_HA,0);
    sprintf(vers,"%s","0199a se an 0202 G1+empf");
    for (z=0; z<25; z++) {
        lcd_write_command(LCD_CMD_WRITE_DATA, vers[z]);  
    }
    lcd_write_command(LCD_CMD_CURSOR_LA,52);    //26 Zeilenanfang 2.Zeile --> 26 Zeichen pro Zeile
    lcd_write_command(LCD_CMD_CURSOR_HA,0);
    sprintf(vers,"%s","antwort von LP161 G1   ");
    for (z=0; z<25; z++) {
        lcd_write_command(LCD_CMD_WRITE_DATA, vers[z]);  
    }
} 

void pause40000(void) {
    unsigned int i;
    for (i=40000;i>0;i--);               // warten 
}


// Für debug, Byte als HEX-Zahl ausgeben



/*
void  Dxausgeben(char data) {
    char vers[5],z,c;
   
    lcd_write_command(LCD_CMD_CURSOR_LA,106);    //26 Zeilenanfang 2.Zeile --> 26 Zeichen pro Zeile
    lcd_write_command(LCD_CMD_CURSOR_HA,0);
    sprintf(vers,"%02X", data);
    for (z=0; z<2;z++) {
        lcd_write_command(LCD_CMD_WRITE_DATA, vers[z]);   
    }
}   
   
void  daten_ausgeben(unsigned int data) {
    char vers[7], z;

    lcd_write_command(LCD_CMD_CURSOR_LA,157);    //26 Zeilenanfang 2.Zeile --> 26 Zeichen pro Zeile
    lcd_write_command(LCD_CMD_CURSOR_HA,0);
    sprintf(vers,"%05u", data);
    for (z=0; z<5; z++) {
        lcd_write_command(LCD_CMD_WRITE_DATA, vers[z]);   
    }
}

void  temp_ausgeben((unsigned int data) {
   char vers[6], z;

    lcd_write_command(LCD_CMD_CURSOR_LA,183);   // 26 Zeilenanfang 2.Zeile --> 26 Zeichen pro Zeile
    lcd_write_command(LCD_CMD_CURSOR_HA,0);
    sprintf(vers,"%05u",data/16);
    for (z=0; z<5; z++) {
        lcd_write_command(LCD_CMD_WRITE_DATA, vers[z]);   
    }
}

*/