/******************************************************************************/

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

#define F_CPU                     800000    // Hz, DCO nach Reset
#define TIMEOUT                     1000    // Bits für Datenempfang
#define CYCLES_PER_UART_BIT_TIME    (F_CPU/9600)    // CPU Takte pro UART-Bit

// ein paar #defines für leichter lesbaren Code
// LEDs sind LOW aktiv
#define LED_GRUEN_EIN   P5OUT &= ~BIT6      
#define LED_GRUEN_AUS   P5OUT |=  BIT6
#define LED_GRUEN_UM    P5OUT ^=  BIT6
#define LED_ROT_EIN     P5OUT &= ~BIT7
#define LED_ROT_AUS     P5OUT |=  BIT7

void programmversion(void);
void UART1_einstellen(void);
void tasten_entprellen(void);
void daten_senden(const unsigned char *data, int cnt);
void daten_ausgeben(unsigned int data);
void Dx_ausgeben(char data);
void temp_ausgeben(unsigned int data);
void antwort_empfangen(void);
void delay_ms(unsigned int ms);
void daten_senden_alt(void);
void daten_tx_festlegen_alt(void);

const 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;  
};

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

unsigned char rx_daten[5],txbuffer_daten[5];
char tmp_string[10];

unsigned int daten1, daten2;

int main(void) {
    WDTCTL = WDTPW | WDTHOLD;     // Stop watchdog timer
    P5DIR |= BIT6 | BIT7;         // für LED   P5.6 + P5.7
    LED_GRUEN_AUS;
    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();
    daten_senden(config_E32, 6);
    P4OUT &= ~BIT0;               // M0 und M1 auf 0 --> E32 senden/empfangen
    P4OUT &= ~BIT1;               // M0 und M1 auf 0 --> E32 senden/empfangen
    delay_ms(4000);
    
    while(1) {
        tasten_entprellen();
        delay_ms(10);
    }
}
void daten_tx_festlegen_alt(void)
{    
  txbuffer_daten[0] = 0x02;  // Adresse 
  txbuffer_daten[1] = 0x02;  // Adresse
  txbuffer_daten[2] = 0x09;  // kanal
  txbuffer_daten[3] = 0x56;  // 0x56 löst in LP161 antwort aus
  txbuffer_daten[4] = 0x56;  
} 
void tasten_entprellen(void) {
    static unsigned char pin_alt;
    unsigned char pin;

    pin = ~P2IN;        // Tasten low active

    // eine einfache Flankenerkennung
    if ( (pin & BIT0) && !(pin_alt & BIT0) ) {            // Taster 2.0 
         LED_ROT_EIN;
        daten_tx_festlegen_alt();
        //daten_senden(tx_daten, 5);
        daten_senden_alt();
         LED_ROT_AUS;
         LED_GRUEN_EIN;
         antwort_empfangen();
         LED_GRUEN_AUS;
    }

    if ( (pin & BIT1) && !(pin_alt & BIT1) ) {            // Taster 2.1   
        LED_GRUEN_UM;
    }

    pin_alt = pin;
}

void antwort_empfangen(void){
    unsigned int i, j;
    
    for (i=0, j=0; i<TIMEOUT && j<4; i++ ){
        if (IFG2 & URXIFG1) {
            rx_daten[j++] = RXBUF1;
        }
        // ca. 5 Bitzeiten warten
        __delay_cycles(CYCLES_PER_UART_BIT_TIME*5);
    }    
    
    if (i==TIMEOUT) {    // timeout, nicht alle Daten empfangen
        // was nun?
     //  LED_ROT_EIN;
    } else {        // 5 Bytes empfangen, dekodieren und anzeigen
       LED_GRUEN_EIN; 
       daten1 = (rx_daten[1]<<8) | rx_daten[2];
       daten2 = (rx_daten[3]<<8) | rx_daten[4]; 
       daten_ausgeben(daten1);
       daten_ausgeben(daten2);
       temp_ausgeben(daten1);
      LED_GRUEN_AUS;
    }
}

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(const unsigned char *data, int cnt) {  
    int i;

    for (i=0; i<cnt; i++); {
        while (!(IFG2 & UTXIFG1));      // USART1 TX buffer ready? 
        TXBUF1 = data[i];
    }
}
void daten_senden_alt(void)
    {  
     char i;
     i=0;
     while (i<5)
    {
     P5OUT &= ~BIT7;                  //LED rot EIN
     TXBUF1 = txbuffer_daten[i];
     while (!(IFG2 & UTXIFG1));     // USART0 TX buffer ready? 
  //   pause400();
     __delay_cycles (900);
     P5OUT |= BIT7;                   //LED rot AUS
     i++;
     }
     } 
 // ms Millisekunden warten 
void delay_ms(unsigned int ms) {
    for (; ms>0; ms--) __delay_cycles(F_CPU/1000);              
}

void programmversion(void) {

    lcd_set_cursor(0, 1);
    lcd_print_string("0200a se an 0202 G1+empf");  
    lcd_set_cursor(0, 2);
    lcd_print_string("antwort von LP161 G1    ");
} 

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

void  Dx_ausgeben(char data) {
   
    lcd_set_cursor(0, 4);
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}   
   
void  daten_ausgeben(unsigned int data) {

    lcd_set_cursor(1, 5);
    sprintf(tmp_string, "%05u", data);
    lcd_print_string(tmp_string);
}

void  temp_ausgeben(unsigned int data) {

    lcd_set_cursor(1, 6);
    sprintf(tmp_string, "%05u°C", data/16);
    lcd_print_string(tmp_string);
}