#include<reg51.h>
#include<stdio.h>
#include<stdlib.h> 

#define uchar unsigned char
#define uint unsigned int



sfr P4=0xc0;

sbit PALE=P2^3; //定義P1.0

sbit PDATA=P2^4; //定義P1.0

sbit PCLK=P2^2; //定義P1.0

sbit DCLK=P3^2; //定義P1.0

sbit DIO=P2^1; //定義P1.0

sbit DENG=P4^0; //定義P1.0







#define CC1000_MAIN            0x00
#define CC1000_FREQ_2A         0x01
#define CC1000_FREQ_1A         0x02
#define CC1000_FREQ_0A         0x03
#define CC1000_FREQ_2B         0x04
#define CC1000_FREQ_1B         0x05
#define CC1000_FREQ_0B         0x06
#define CC1000_FSEP1           0x07
#define CC1000_FSEP0           0x08
#define CC1000_CURRENT         0x09
#define CC1000_FRONT_END       0x0A
#define CC1000_PA_POW          0x0B
#define CC1000_PLL             0x0C
#define CC1000_LOCK            0x0D
#define CC1000_CAL             0x0E
#define CC1000_MODEM2          0x0F
#define CC1000_MODEM1          0x10
#define CC1000_MODEM0          0x11
#define CC1000_MATCH           0x12
#define CC1000_FSCTRL          0x13
#define CC1000_FSHAPE7         0x14
#define CC1000_FSHAPE6         0x15
#define CC1000_FSHAPE5         0x16
#define CC1000_FSHAPE4         0x17
#define CC1000_FSHAPE3         0x18
#define CC1000_FSHAPE2         0x19
#define CC1000_FSHAPE1         0x1A
#define CC1000_FSDELAY         0x1B
#define CC1000_PRESCALER       0x1C
#define CC1000_TEST6           0x40
#define CC1000_TEST5           0x41
#define CC1000_TEST4           0x42
#define CC1000_TEST3           0x43
#define CC1000_TEST2           0x44
#define CC1000_TEST1           0x45
#define CC1000_TEST0           0x46



void NOP(){}



void delay1mS(uchar time)
{
 uchar i;
 uchar j;
 for(j=0;j<time;j++)
 {
  for(i=0;i<220;i++)
   NOP();
 }
}


/****************************************************************************/
/*   CC1000    寫內部寄存器子程序             
/****************************************************************************/
void WriteToCC1000Register(char Register, char DATA)
{
 char i;
 PCLK=1;
 PDATA=1;
 PALE=0;
 Register=(Register<<1)+0x01;
 for(i=8;i>0;i--)
 {
  if(Register&0x80)PDATA=1;
  else PDATA=0;
  PCLK=0;
  Register<<=1;
  NOP();
  PCLK=1;                               
 }

 NOP();
 PCLK=1;
 PALE=1;
 for(i=8;i>0;i--)
 {
  if(DATA&0x80)PDATA=1;
  else PDATA=0;
  PCLK=0;
  DATA<<=1;
  NOP();
  PCLK=1;                                
 }

 NOP();
 PCLK=1;
 PDATA=1;
}




/****************************************************************************/
/*   CC1000    讀內部寄存器子程序             
/****************************************************************************/
char ReadfromCC1000Register(char addr)
{
  char Result=0;
  char i;
  PCLK=1;
  PDATA=1;
  PALE=0;
  addr=addr<<1;
  for(i=8;i>0;i--)
  {
   if(addr&0x80)PDATA=1;
    else PDATA=0;
    PCLK=0;
    addr<<=1;
 
    NOP();
    PCLK=1;                                
  }
  PDATA=1;
  NOP();
  PCLK=1;
  PALE=1;
  for(i=8;i>0;i--)
  {
   PCLK=0;
   Result=(Result<<1)|PDATA;
  
   NOP(); 
   PCLK=1; 
     NOP();                      
 }
 PCLK=1;
 return(Result);
}




/****************************************************************************/
/*  This routine puts the CC1000 into RX mode . When switching to  */
/*  RX from PD, use WakeupC1000ToRX first                                   */
/****************************************************************************/

void CC1000_init()
{
 char cal_complete;
 //char time;
 WriteToCC1000Register(CC1000_PA_POW,0x00); 
 WriteToCC1000Register(CC1000_MAIN,0x3f);
 //P1=ReadfromCC1000Register(CC1000_MAIN);

 WriteToCC1000Register(CC1000_MAIN,0x3a);          //RXTX=0;F_REQ=0(RX:Register A ,TX:Register B);RX_PD=1;TX_PD=1;FS_PD=1;CORE_PD=0;BIAS_PD=1;REST_N=0

 
 WriteToCC1000Register(CC1000_MAIN,0x3b);       
 //cal_complete=ReadfromCC1000Register(CC1000_MAIN);
// cal_complete=0;
// WriteToCC1000Register(CC1000_MAIN,cal_complete);
 //P1=ReadfromCC1000Register(CC1000_MAIN);

 delay1mS(5);
 
// WriteToCC1000Register(CC1000_MAIN,0x01);
// writes 24-bit frequency value used for RX to 433.302 MHz.
// Check CC1000 data sheet for equations used to find
// 0x580000.
 WriteToCC1000Register(CC1000_FREQ_2A,0x58); 
 //P0=ReadfromCC1000Register(CC1000_FREQ_2A);     
 WriteToCC1000Register(CC1000_FREQ_1A,0x00);
 WriteToCC1000Register(CC1000_FREQ_0A,0x00);
// writes 24-bit frequency value used for TX to 433.302 MHz.
// Check CC1000 data sheet for equations used to find
// 0x580625.
 WriteToCC1000Register(CC1000_FREQ_2B,0x58);       
 WriteToCC1000Register(CC1000_FREQ_1B,0x06);
 WriteToCC1000Register(CC1000_FREQ_0B,0x25);
// sets frequency separation between 0 value and 1 value
//設定誤碼率
 WriteToCC1000Register(CC1000_FSEP1,0x03);
 WriteToCC1000Register(CC1000_FSEP0,0x55);
 WriteToCC1000Register(CC1000_CURRENT,0x44);
// sets some internal current levels, and enables RSSI output to pin
 WriteToCC1000Register(CC1000_FRONT_END,0x00);
 WriteToCC1000Register(CC1000_PA_POW,0xff);
// sets the PLL reference divider to divide by 6
 WriteToCC1000Register(CC1000_PLL,0x60);   
// sets External LNA control lock indicator to output on the CHP_OUT pin                  
 WriteToCC1000Register(CC1000_LOCK,0xa0);
 WriteToCC1000Register(CC1000_CAL,0x26);   
// sets threshold level for peak detector (not used in this design) 
 WriteToCC1000Register(CC1000_MODEM2,0x16);    
// sets the averaging filter to free-running and controlled by writes
// to bit 4 of this register.
// Sets averaging filter sensitivity to .6dB worst-case loss of sensitivity
 WriteToCC1000Register(CC1000_MODEM1,0x67); 
// baud rate to 4.8k, NRZ, and crystal freq. to 11.0592 MHz
 WriteToCC1000Register(CC1000_MODEM0,0x54);            
// sets capacitor array values for RX and TX
 WriteToCC1000Register(CC1000_MATCH,0x70); 
// disables dithering and data shaping  
 WriteToCC1000Register(CC1000_FSCTRL,0x01); 
// sets prescaling to nominal values  
/*
 WriteToCC1000Register(CC1000_FSHAPE7,0x1c);
 WriteToCC1000Register(CC1000_FSHAPE6,0x16);
 WriteToCC1000Register(CC1000_FSHAPE5,0x10);
 WriteToCC1000Register(CC1000_FSHAPE4,0x0a);
 WriteToCC1000Register(CC1000_FSHAPE3,0x06);
 WriteToCC1000Register(CC1000_FSHAPE2,0x03);
 WriteToCC1000Register(CC1000_FSHAPE1,0x01);
*/
 WriteToCC1000Register(CC1000_FSDELAY,0x1f);
 WriteToCC1000Register(CC1000_PRESCALER,0x00);

// sets charge pump current scaling factor, which determines the bandwidth
// of the PLL.
// WriteToCC1000Register(CC1000_TEST4,0x25);
// Calibration Process
// RX Calibration
// set transceiver to RX mode



WriteToCC1000Register(CC1000_TEST4 ,0x3f);
 
WriteToCC1000Register(CC1000_MAIN,0x11);
WriteToCC1000Register(CC1000_CAL,0xa6);
WriteToCC1000Register(CC1000_CURRENT,0x44);// RX mode current


/*
 for(time=0;time<100;time++){
cal_complete =ReadfromCC1000Register(CC1000_CAL);
 P1=cal_complete;
 if(!(cal_complete & 0x08))
 P0=time;
 else break;
 }


*/



 cal_complete = 0;
 do
 {
  cal_complete =ReadfromCC1000Register(CC1000_CAL);
  /*
  P1=cal_complete;
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
  */

 }
 while(!(cal_complete & 0x08)); // spin until calibration is complete

 WriteToCC1000Register(CC1000_CAL,0x26);

// TX Calibration
 WriteToCC1000Register(CC1000_MAIN,0xE1);
 WriteToCC1000Register(CC1000_CAL,0xa6);
 
 
 WriteToCC1000Register(CC1000_CURRENT,0x81);// TX mode current
 WriteToCC1000Register(CC1000_PA_POW,0x00);
 WriteToCC1000Register(CC1000_PLL,0x60);   
// calibration



 
 cal_complete = 0;
 do
 {
  cal_complete =ReadfromCC1000Register(CC1000_CAL);
 
 }
 while(!(cal_complete & 0x08)); // spin until calibration is complete
 WriteToCC1000Register(CC1000_CAL,0x26);
 WriteToCC1000Register(CC1000_MAIN,0x3d);
 WriteToCC1000Register(CC1000_PA_POW,0xff);


   DENG=0;


}

//-----------------------------------------------------------------------------
// C1000_RX_MODE
//-----------------------------------------------------------------------------
// C1000_RX_MODE sets the transceiver to RX mode and
// then initializes the 250 microsecond counter
// that gets incremented in the ADC ISR.
void C1000_RX_MODE(void)
{
WriteToCC1000Register(CC1000_PA_POW,0x00); 
 WriteToCC1000Register(CC1000_MAIN,0x11); // set to RX mode
 WriteToCC1000Register(CC1000_CURRENT,0x44); // set RX current level
 WriteToCC1000Register(CC1000_PLL,0x60);   
 WriteToCC1000Register(CC1000_PA_POW,0xff); // no  outputpower needed 
}


//-----------------------------------------------------------------------------
// C1000_TX_MODE
//-----------------------------------------------------------------------------
// C1000_TX_MODE sets the transceiver to TX mode and
// then initializes the 250 microsecond counter
void C1000_TX_MODE(void)
{
WriteToCC1000Register(CC1000_PA_POW,0x00); 
 WriteToCC1000Register(CC1000_MAIN,0xe1); // set to TX mode
 WriteToCC1000Register(CC1000_PLL,0x60); 
 WriteToCC1000Register(CC1000_CURRENT,0x81); // set TX current level
 
 WriteToCC1000Register(CC1000_PA_POW,0xff); // no  outputpower needed 
}

void TX(char TXDATA)
{
 char i;

 for(i=8;i>0;i--)
 {
  while(DCLK==1);
  if(TXDATA&0x80)DIO=1;
  else DIO=0;
  TXDATA<<=1;
  while(DCLK==0);

 }
}



void main(){ 


   CC1000_init();
	//while(1){
	C1000_RX_MODE();
delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);
 delay1mS(250);

//}

   C1000_TX_MODE(); 
   while(1){
	
      TX(0xa5);
       delay1mS(250); 
	 }

}