//           ********************
//           *Testschaltung 1611*
//           ********************
//   graph. Flüssigkristallanzeige  FKA LC7981
//             Uhr DS32C35 

//                 MSP430F1611
//              -----------------
//              |              XIN|- 32,768kHz
//              |                 |
//  Taster rot--|RST (58)     XOUT|- 32,768kHz
//                            P5.7|LED rot
//              |             P5.6|LED Grün
// 8  Mhz X2IN- |             P2.1|Taster 
//              |             P2.0|Taster 
// 8 MHz X2OUT- |       P1.0..P1.7|Daten FKA 
//              |                 |
//              |             P3.0|   SPI BL1    		                (28)
//       UTXD0  |P3.4         P3.1|-> Daten Ausgang           SPI/I²C   	(29)
//       URXD0  |P3.5         P3.2|<- Data In  (SOMI0)        SPI/I²C          (30)
// grau  UTXD1  |P3.6         P3.3|-> Serial Clock Out (SCL)  SPI/I²C   (31)        
// rosa  URXD1  |P3.7																																																				
//              |             P4.0| M0   E32_868T  grün
//                            P4.1| M1   E32_868T
//                            P4.2| AUX  E32_868T
//                            P4.3|
//	        |             P4.6| 	
//              |	      P4.7| 									
//(44)SD-CS     |P5.0         P2.7| SD Karte Einsteckkontrolle  								
//    SD-DI     |P5.1         P2.6| 
//    SD-DO     |P5.2         P2.5| RST RV1805
//    SD-CLK    |P5.3         P2.4| 
// nCSB	ADS1293	|P5.4         P2.3| 
//              |P5.5         P2.2| 
//   LED grün   |P5.6         P6.7|  
//   LED rot    |P5.7         P6.6| Steuerung FKA RS    
//                            P6.5| Steuerung FKA R/W
//                            P6.3| Steuerung FKA E
//******************************************************************************

#include <msp430x16x.h>
#include "0200_lc7981.c"
#include <string.h>            // für Zeichen (Infotext) notwendig
#include <stdio.h>             // für sprint
#include <signal.h>
#include "TS_0218_SD_MAINTI.c"
#define F_CPU                     800000    // Hz, DCO nach Reset
#define TIMEOUT                   7000      // Bits für Datenempfang 7000
#define CYCLES_PER_UART_BIT_TIME    (F_CPU/9600)    // CPU Takte pro UART-Bit

// ein paar #defines für leichter lesbaren Code

#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_1_ausgeben(unsigned int data);
void daten_2_ausgeben(unsigned int data);
void daten_3_ausgeben(unsigned int data);
void daten_4_ausgeben(unsigned int data);
void  daten_5_ausgeben(unsigned int data);
void  daten_6_ausgeben(unsigned int data);
void  daten_7_ausgeben(unsigned int data);
//void Dx_ausgeben(unsigned int hexwe);

void antwort_empfangen(void);
void delay_ms(unsigned int ms);
void Datenanfang(void);
void grunddaten(void);

//unsigned char rx_daten[5]; 
//unsigned char rx_daten[8];
unsigned char rx_daten[512];
char tmp_string[10];
unsigned char daten1, daten2, daten3, daten4,daten5,daten6,daten7,d3[512],d2[512],d1[512],ZeitOB=0xFF,ZeitUB=0xFF;
unsigned int sector=619,k;
const unsigned char config_E32[] = {
    0xC0, // sichert die Parameter nach Stromausfall
    0x02, // Adresse oberes Byte  
    0x02, // Adresse unteres Byte 
    0x1A, // 8N1, UART baut rate:9600 (bps), Übertragungsrate:2,4k (bps)
    0x09, // Kanal 09 gesendet von von Gerät 3
    0xC4  // "fixed" Übetragungsmodus; TXD und AUX als Ausgang RXD als Eingang;  
};

const unsigned char tx_daten[] = {
    0x44,  // Adresse 
    0x44,  // Adresse
    0x09,  // kanal
    0x56,  // Marke 0x56 löst antwort bei DS10 aus
    0x56  
};



int main(void) {
    WDTCTL = WDTPW | WDTHOLD;     // Stop watchdog timer
    P5DIR |= BIT0 + BIT6 + BIT7;  // für LED   P5.6 + P5.7, 5.0 =ST1-SD
    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(2000);
  // SD_Beginn();
  // Datenanfang();
    while(1) {
        tasten_entprellen();
        delay_ms(10);
    }
}

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 
       i=0;
       // LED_ROT_EIN;
        daten_senden(tx_daten, 5);               //sendet adresse, Kanal und Marke = 0x56
       // LED_ROT_AUS;
        antwort_empfangen();
    }
    if ( (pin & BIT1) && !(pin_alt & BIT1) ) {         // Taster 2.1   keine besondere Funktion
        LED_GRUEN_UM;                                  
    }                                                
    pin_alt = pin;
}
void antwort_empfangen(void){
    unsigned int  j,k;
     
    for (k=0, j=0; k<TIMEOUT && j<512; k++ )
    {
        LED_GRUEN_EIN;
        if (IFG2 & URXIFG1) {
        rx_daten[j++] = RXBUF1;
        }
         // ca. 5 Bitzeiten warten
        __delay_cycles(CYCLES_PER_UART_BIT_TIME*5);
        LED_GRUEN_AUS;
    }    
    
    if (i==TIMEOUT) {    // timeout, nicht alle Daten empfangen
        // was nun?
       LED_ROT_EIN;     //bei Zeitüberschreitung
    } else {             
       LED_ROT_EIN;
       daten1 =  rx_daten[1];  // wird richtig übertragen
       daten2 =  rx_daten[2];  // wird richtig übertragen
       daten3 =  rx_daten[15]; // wird richtig übertragen
       daten4 =  rx_daten[58]; // 58 = max Bytes ?, Byte [58] wird richtig übertragen
       daten5 =  rx_daten[59]; // wird zu 0x00; Byte nicht übertragen?
       daten6 =  rx_daten[60]; // wird zu 0x00; Byte nicht übertragen?
       daten7 =  rx_daten[61]; // wird zu 0x00; Byte nicht übertragen?
      
       daten_1_ausgeben(daten1);
       daten_2_ausgeben(daten2);
       daten_3_ausgeben(daten3);
       daten_4_ausgeben(daten4);
       daten_5_ausgeben(daten5);
       daten_6_ausgeben(daten6);
       daten_7_ausgeben(daten7);
       LED_ROT_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    |=  URXIE1;      //UTXIE1+        // 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];
        }
}

 // 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("0218 antwort speichern-SD");  
    lcd_set_cursor(0, 2);
    lcd_print_string("antwort von DS10");
} 

void  daten_1_ausgeben(unsigned int data) {

    lcd_set_cursor(1, 4);              // Spalte 1, Zeile 5
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}
   
void  daten_2_ausgeben(unsigned int data) {

    lcd_set_cursor(4, 4);
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}
   
void  daten_3_ausgeben(unsigned int data) {

    lcd_set_cursor(7, 4);
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}

void  daten_4_ausgeben(unsigned int data) {

    lcd_set_cursor(10, 4);
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}
void  daten_5_ausgeben(unsigned int data) {

    lcd_set_cursor(13, 4);
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}
void  daten_6_ausgeben(unsigned int data) {

    lcd_set_cursor(16, 4);
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}
void  daten_7_ausgeben(unsigned int data) {

    lcd_set_cursor(19, 4);
    sprintf(tmp_string, "%02X", data);
    lcd_print_string(tmp_string);
}