//******************************************************************************
//  MSP430F20x2/3 Demo - SPI full-Duplex 3-wire Master
//
//  Description: SPI Master communicates full-duplex with SPI Slave using
//  3-wire mode. The level on P1.4 is TX'ed and RX'ed to P1.0.
//  Master will pulse slave reset for synch start.
//  ACLK = n/a, MCLK = SMCLK = Default DCO
//
//                Slave                      Master
//               MSP430F20x2/3              MSP430F20x2/3
//             -----------------          -----------------
//            |              XIN|-    /|\|              XIN|-
//            |                 |      | |                 |
//            |             XOUT|-     --|RST          XOUT|-
//            |                 | /|\    |                 |
//            |          RST/NMI|--+<----|P1.2             |
//      LED <-|P1.0             |        |             P1.4|<-
//          ->|P1.4             |        |             P1.0|-> LED
//            |         SDI/P1.7|<-------|P1.6/SDO         |
//            |         SDO/P1.6|------->|P1.7/SDI         |
//            |        SCLK/P1.5|<-------|P1.5/SCLK        |
//
//  M. Buccini / L. Westlund
//  Texas Instruments Inc.
//  October 2005
//  Built with IAR Embedded Workbench Version: 3.40A
//******************************************************************************

#include <msp430x20x3.h>

#define RF_CLK  0x20//P1
#define MISO    0x40//P1
#define MISI    0x80//P1
#define IRQ     0x10//P1
#define CSN     0x40//P2
#define CE      0x80//P2

unsigned int j;
volatile unsigned int i;
unsigned char PTX_RF_Address_P0[5]={0x07,0xFF,0xFF,0xFF,0xFF};
unsigned char PRX_RF_Address_P1[5]={0x01,0xEE,0xEE,0xEE,0xEE};
unsigned char ad_data[1];
unsigned char spi_read,buffer[16],buffer_1[10];
unsigned int ad_value;
void delay_10ms(void)
{
  unsigned int dt;
    dt=30000;
    do{
    }while(dt-->0);
}

void delay_10us(void)
{
  unsigned char dt;
  dt=30;
  do{
  }while(dt-->0);
}

void init_SPI(void)
{
  USICTL0 |= USIPE7 + USIPE6 + USIPE5 + USISWRST + USIMST + USIOE; // Port, SPI master
  USICTL1 |= USICKPH;// + USIIE;           // Counter interrupt, flag remains set
  USICKCTL = USIDIV_4 + USISSEL_2;      // /16 SMCLK
  USICTL0 &= ~USISWRST;                 // USI released for operation

  USICNT = 1;
  do{
  }while(!(USIIFG & USICTL1));
}

unsigned char RF_Read(unsigned char adr){
  P2OUT &=~CSN;
  USISRL = adr; // init-load data
  USICNT = 8;
  do{
  }while(!(USIIFG & USICTL1));
  USICNT = 8;
  do{
  }while(!(USIIFG & USICTL1));

  P2OUT |=CSN;
  return(USISRL);
}

void RF_ReadS(unsigned char adr,unsigned char read_cnt,unsigned char *read_buffer){
  unsigned char i;
  P2OUT &=~CSN;
  USISRL = adr; // init-load data
  USICNT = 8;
  do{
  }while(!(USIIFG & USICTL1));

  for(i=0;i<read_cnt;i++)
  {
    USICNT=8;
    do{
    }while(!(USIIFG & USICTL1));
    *(read_buffer+i)=USISRL;
  }
  P2OUT |=CSN;
}

void RF_Write(unsigned char adr,unsigned char cmd){
  adr |= 0x20;
  P2OUT &=~CSN;
  USISRL = adr; // init-load data
  USICNT = 8;
  do{
  }while(!(USIIFG & USICTL1));
  USISRL = cmd;
  USICNT = 8;
  do{
  }while(!(USIIFG & USICTL1));

  P2OUT |=CSN;
}

void RF_WriteS(unsigned char adr,unsigned char write_cnt,unsigned char *write_buffer){
  unsigned char i;
  adr |= 0x20;
  P2OUT &=~CSN;
  USISRL = adr; // init-load data
  USICNT = 8;
  do{
  }while(!(USIIFG & USICTL1));

  for(i=0;i<write_cnt;i++)
  {
    USISRL = *(write_buffer+i); // init-load data
    USICNT=8;
    do{
    }while(!(USIIFG & USICTL1));
  }

  P2OUT |=CSN;
}


void main(void)
{
  unsigned char dt_cnt;

  WDTCTL = WDTPW + WDTHOLD;             // Stop watchdog timer
  P1DIR |= 0x01;
  P2DIR |= (CSN | CE);
  P2IES =0x00;
  P2SEL=0x00;

  P1IE  |= IRQ;                        // P2.0 interrupt enabled
  P1IES |= IRQ;                        // P2.0 Hi/lo edge
  P1IFG &= ~IRQ;                       // P2.0 IFG cleared

  P1OUT &=~0x01;
  SD16CTL = SD16REFON + SD16SSEL_1;         // 1.2V ref, SMCLK
  SD16INCTL0 = SD16INCH_4;                  // A4+/-

  SD16CCTL0 =  SD16UNI + SD16IE + SD16IFG;            // 256OSR, unipolar, interrupt enable
  SD16AE = SD16AE1;                         // P1.1 A4+, A4- = VSS
  //SD16CCTL0 |= SD16SC;                      // Set bit to start conversion



  init_SPI();

  //RF_Write(0x01,0x3F);// auto ack.
  RF_Write(0x01,0x00);// no auto ack.
  RF_Write(0x02,0x3F);// enable data pipe0
  RF_Write(0x03,0x03);// set address width 5bytes
  RF_Write(0x05,0x00);// set RF channel 0
  RF_Write(0x06,0x0F);// set 2Mbps , 0dBm

  RF_WriteS(0x0A,5,PRX_RF_Address_P1);//set receive address
  RF_WriteS(0x10,5,PRX_RF_Address_P1);

  RF_Write(0x11,0x04);//set receive pipe0  width
  RF_Write(0x12,0x04);//set receive pipe1  width

  RF_Write(0xE2,0x00);//clear payload
  RF_Write(0x07,0x40);

  _BIS_SR(GIE);

  P2OUT &=~ CE;
  RF_Write(0x00,0x0F);//power up, RX mode
  for(dt_cnt=0;dt_cnt<200;dt_cnt++)//powerdown goto standby-I mode must be wait 1.5ms
    delay_10us();

  P2OUT |= CE;
  for(dt_cnt=0;dt_cnt<200;dt_cnt++)//powerdown goto standby-I mode must be wait 1.5ms
    delay_10us();

  //RF_WriteS(0x0A,5,buffer);
  //RF_ReadS(0x0b,5,buffer);
//delay_10us();


  while(1){
   
    //if(ad_value>32767)
    //  P1OUT |= 0x01;
    //else
    //  P1OUT &=~ 0x01;
   
    spi_read=RF_Read(0x17);
    if(spi_read & 0x04){
      RF_Write(0xE2,0x00);//clear payload
      RF_Write(0x07,0x40);
    }

  }
}

#pragma vector = SD16_VECTOR
__interrupt void SD16ISR(void)
{
  if ((int)SD16MEM0 < 0x2AAA)           	    // SD16MEM0 > 0.3V?, clears IFG
    P1OUT &=~ 0x01;
  else
    P1OUT |= 0x01;
}

#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{
  if((P1IFG & IRQ) ==IRQ){
    do{
      RF_ReadS(0x61,4,buffer);
    }while((RF_Read(0x17) & 0x01)==0x00);
    ad_value=(unsigned int)buffer[0]+ (unsigned int)(buffer[1]<<8);
    RF_Write(0xE2,0x00);//clear payload
    RF_Write(0x07,0x40);

    P1IFG &= ~IRQ;
  }
}