// Basiskommentare f¸r die SPI Kommunikation

// #define delay_2 __delay_cycles(10);  // eine andere Mˆglichkeit ein Delay zu definieren

#include "msp430F5438A.h"                 // einf¸gen der Mikroprozessordaten
#include "stdint.h"

//Variablen
char addr;
char data;
char receive_byte;
char receive_data;

//Funktionen
void spi_senden();
uint8_t spi_empfang();
uint8_t leseschreib(); //Testmethode für den ID-Empfang
uint8_t koordinatenleseschreib();


//Einstellunmgen ADXL345
void spi_senden_DATA_FORMAT(); 
void spi_senden_BW_RATE();  
void spi_senden_FIFO_CTL();
void spi_senden_POWER_CTL();  // in diesem Register das Measure Bit setzen um eine Messung zu starten
//void spi_senden_FIFO_STATUS();
void spi_beenden_POWER_CTL();      // Messung wieder beenden und in den Standby-Modus wieder zurückkehren

//Koordinatenachsen x,y,z
uint8_t DATAX0leseschreib();
uint8_t DATAX1leseschreib();
uint8_t DATAY0leseschreib();
uint8_t DATAY1leseschreib();
uint8_t DATAZ0leseschreib();
uint8_t DATAZ1leseschreib();

void main (void) // Hauptprogramm starten

{

  WDTCTL=WDTPW+WDTHOLD;    // ausschalten des Watchdogs
  P10SEL|= BIT1 + BIT2 + BIT3;                         //P10SEL|=0x0F;        // PSEL, SPI Konfiguration ausw‰hlen, 0b00001111
  UCB3CTL1|=UCSWRST;                      // **Put state machine in reset** !!!
  P10DIR|= BIT0;             //P10DIR|=0x0D; // SCLK ist 1 auf P10.3 ; MOSI ist 1 auf P10.1 ; SOMI ist 0 auf P10.2, CS(low active) auf 1 am P10.0, 0b00001101

// P10REN= 0b00000100;// CS quer dauerhaft auf low gesetzt, um die Kommunikation zu bewerkstelligen, keine gute Idee

  UCB3CTL0|=UCSYNC | UCMST | UCMSB | UCCKPL; //| UCMODE0;   // synchroner Modus, 4 pin SPI einstellen , Master Modus eingestellt, MSB zuerst   
  UCB3CTL1|=UCSSEL_2;  // Zeitgeber ausw‰hlen, SMCLK 
  UCB3BR0=0x02;       //Zeitgeber einstellen, UCA3BR0 und UCA3BR1, (UCAxBR0 + UCAxBR1 ? 256)
  UCB3BR1=0;  // spaeter ncoh einmal die Berechnung bedenken und mit den Angaben im Datenblatt vergleichen

  UCB3CTL1&=~UCSWRST; // Initialisierung der State machine
  UCB3IE|=UCRXIE + UCTXIE;// Interrupt zulassen
  
  


  while (1)
  {
  //leseschreib();                         // als Test soll die ID gesendet werden
  
  
  
 //Einstellungen ADXL345 im Standby-Modus
// spi_beenden_POWER_CTL();  // Measure Bit auf 0 setzen  
    
// leseschreib();    
spi_senden_DATA_FORMAT(); 
spi_senden_BW_RATE();  
spi_senden_FIFO_CTL(); 
spi_senden_POWER_CTL(); // hier die Messung starten 

//spi_senden_FIFO_STATUS();  
  
 // Koordinatenachsen x,y,z
DATAX0leseschreib();  // LSb X-Achse
DATAX1leseschreib();  // MSb X-Achse
DATAY0leseschreib();  // LSb X-Achse
DATAY1leseschreib();  // MSb X-Achse
DATAZ0leseschreib();  // LSb Z-Achse
DATAZ1leseschreib();  // MSb Z-Achse



spi_beenden_POWER_CTL(); // hier die Messung wieder beenden und in den Standby-Modus setzen   
                         // Measure Bit auf 0 setzen

//      spi_senden();                                

  }

  
} // beenden des Hauptprogrammes


// Register 0x31- DATA_FORMAT  (DATA format control)

void spi_senden_DATA_FORMAT()  
{
       // P10OUT&=~BIT0;                          // CSquer auf low setzen, um die ‹bertragung anzufangen, bei 4 wire

 
            
        while(!(UCB3IFG&UCTXIFG));       // nicht UCB3IFG benutzen, sondern IFG3, wieder zurück geändert
                                        // eventuell das Flag lˆschen  
        UCB3TXBUF=0x31;                      // Addresse,  0x31; 
        __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz
      
        while(!(UCB3IFG&UCTXIFG));             // nicht UCB3IFG benutzen, sondern IFG3

        UCB3TXBUF=0x4E;  //  SELF_TEST | SPI | INT_INVERT | 0 | FULL_RES | Justify | Range      data sozusagen, Manipulierung, 0b01001110,  0x4E; 

        __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz

};       
  //---------------------------------------------------------------------------------------------------          
       
   // Register 0x2C BW_RATE  (Data rate and power mode control) 

 void spi_senden_BW_RATE()  

 {    while (!(UCB3IFG&UCTXIFG));           // UCB3IFG benutzen

                                   
         UCB3TXBUF=0x2C;                       // Addresse

         __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz   

      while (!(UCB3IFG&UCTXIFG));           // UCB3IFG benutzen, sondern IFG3

         UCB3TXBUF = 0x0A;                    //  0 | 0 | 0 | LOW_POWER | Rate | Rate   , Rate auf 100 Hz,data, Manipulierung, 0b00001010

         __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen
 };       
   //----------------------------------------------------------------------------------------------------------    
       
    // Register 0x38- FIFO_CTL 

void spi_senden_FIFO_CTL()   

{     while (!(UCB3IFG & UCTXIFG));               // UCB3IFG benutzen

                                           
          UCB3TXBUF = 0x38;                       // Addresse

         // __delay_cycles(10);  // Wartezeit definieren

      

     while (!(UCB3IFG & UCTXIFG));              // nicht UCB3IFG benutzen, sondern IFG3

          UCB3TXBUF = 0x80 ;    //  FIFO_MODE | FIFO_MODE | Trigger | Samples | Samples  | Samples | Samples | Samples    data sozusagen, Manipulierung, 0b10000000

          __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen  
};


          // Register 0x2D- POWER_CTL   

void spi_senden_POWER_CTL() 

{     while (!(UCB3IFG&UCTXIFG));               // UCB3IFG benutzen
                                         
          UCB3TXBUF=0x2D;                       // Addresse

          __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz

      while (!(UCB3IFG&UCTXIFG));

          UCB3TXBUF=0x04 ;    //  0 | 0 | Link | AUTO_SLEEP | Measure | Sleep | Wakeup          data sozusagen, Manipulierung, 0b0000100

          __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen
};

// Messung beenden und wieder in den Standby-Modus zurückkehren

void spi_beenden_POWER_CTL() 

{     while (!(UCB3IFG&UCTXIFG));               // UCB3IFG benutzen
                                         
          UCB3TXBUF=0x2D;                       // Addresse

          __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz

      while (!(UCB3IFG&UCTXIFG));

          UCB3TXBUF=0x00;    //  0 | 0 | Link | AUTO_SLEEP | Measure | Sleep | Wakeup          data sozusagen, Manipulierung, 0b0000100

          __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen
};







                // Register 0x39-  FIFO_STATUS  
//void spi_senden_FIFO_STATUS() 
//   
//
//{     while (!(UCB3IFG&UCTXIFG));                // nicht UCB3IFG benutzen
//                                         
//
//          UCB3TXBUF=0x39;                       // Addresse
//
//          __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz
//
//      while (!(UCB3IFG&UCTXIFG));   // UCB3IFG benutzen
//
//         UCB3TXBUF=;    //   
//
//       __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen
//};  
//  //--------------------------------------------------------------------------------------------------------- 


//-------------------------------------------------------------------------------

// Testmethode zum einlesen der ID

//uint8_t leseschreib()
//
//{                                                // Beginn der Funktion
//  
//  P10OUT &= ~BIT0;
//  
//  while (!(UCB3IFG&UCTXIFG));
//
//  UCB3TXBUF = 0x00; // 0x41 // Test mit 0x80;
//
//
// __delay_cycles(10);
// 
// 
// while(!(UCB3IFG&UCRXIFG)); 
// 
// 
// return(UCB3RXBUF);
//
//}; 

//-------------------------------------------------------------------------------
  
// Methode zum einlesen der Koordinatenwerte  DATAX0

uint8_t DATAX0leseschreib()                              // Register 0x32-    DATAX0  least significant byte X-axes
{                                                
  
  P10OUT &= ~BIT0;
  
   while (!(UCB3IFG&UCTXIFG));

      UCB3TXBUF = 0x32; // Register 0x32-  DATAX0   least significant byte X-axes


      __delay_cycles(10);
 
 
  while(!(UCB3IFG&UCRXIFG)); 
 
 
      __delay_cycles(10); 
 
 UCB3IFG&=~UCRXIFG;
      
 return(UCB3RXBUF);

}; 

//-------------------------------------------------------------------------------

// Methode zum einlesen der Koordinatenwerte  DATAX1       
         
uint8_t DATAX1leseschreib()             // Register 0x33-    DATAX1    most significant byte X-axes

{              
      while (!(UCB3IFG&UCTXIFG));           // UCB3IFG benutzen
                                        

           UCB3TXBUF=0x33;                       // Addresse

        __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz
 

      while (!(UCB3IFG&UCRXIFG));                  // nicht UCB3IFG benutzen 

          __delay_cycles(10);  
  
  return(UCB3RXBUF);
          
};

 //---------------------------------------------------------------------------------------------------------                 

            
 // Methode zum einlesen der Koordinatenwerte  DATAY0 

uint8_t DATAY0leseschreib()        // Register 0x34-  DATAY0  least significant byte  Y-axes

{
     while (!(UCB3IFG&UCTXIFG));                
     
          UCB3TXBUF=0x34;                       // Addresse

          __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen, eventuell zu kurz

     
    while (!(UCB3IFG&UCRXIFG));               // nicht UCB3IFG benutzen, sondern IFG3

       __delay_cycles(10);  // Wartezeit definieren, 10 Zyklen
        
  return(UCB3RXBUF);
  
}; 

  //---------------------------------------------------------------------------------------------------------         

// Methode zum einlesen der Koordinatenwerte  DATAY1 

uint8_t DATAY1leseschreib()  // Register 0x35-  DATAY1  moct significant byte  Y-axes
  
{
     while (!(UCB3IFG&UCTXIFG));               // nicht UCB3IFG benutzen
                                        
        UCB3TXBUF=0x35;                       // Addresse

        __delay_cycles(10);  
     

    while (!(UCB3IFG&UCTXIFG));              // nicht UCB3IFG benutzen   

        __delay_cycles(10);  

    return(UCB3RXBUF);
         
};

 // ---------------------------------------------------------------------------------------------------------        

// Methode zum einlesen der Koordinatenwerte  DATAZ0 

  
//    Register 0x36-  DATAZ0  least significant byte  Z-axes

uint8_t DATAZ0leseschreib()

{
   while (!(UCB3IFG&UCTXIFG));            // UCB3IFG benutzen
                                        

         UCB3TXBUF=0x36;                       // Addresse

         __delay_cycles(10);  // Wartezeit definieren
   

 while (!(UCB3IFG&UCTXIFG));            // nicht UCB3IFG benutzen  

         __delay_cycles(10);  // Wartezeit definieren
         
 return(UCB3RXBUF);
};

  //---------------------------------------------------------------------------------------------------------     

// Methode zum einlesen der Koordinatenwerte  DATAZ1 


                // Register 0x37-  DATAZ1  most significant byte  Z-axes
uint8_t DATAZ1leseschreib()
{
      while (!(UCB3IFG&UCTXIFG));              // UCB3IFG benutzen
                                       
           UCB3TXBUF=0x37;                   

          __delay_cycles(10);  

      while (!(UCB3IFG&UCTXIFG));                  // UCB3IFG benutzen

         __delay_cycles(10);  // Wartezeit definieren

return(UCB3RXBUF);

 };
         
 //--------------------------------------------------------------------------------------------------------- 









//         IFG3=~UCB3IFG;  // Flag lˆschen

//         P10OUT |= BIT0;                        // CSquer auf high setzen, um die ‹bertragung zu beenden}


//// 3 verschiedene Felder f¸r die ‹bertragung definieren, Informationen f¸r die x-,y-,z-Achsen



//} // Beenden der Methode