drv1_cc1000.c

CC1000 multi-frequence driver codes for Lpc213X

#include "config_60_61.h"
#include "config_GD61.h"
#include "include_GD61.h"

///////////////////////////////////////////////////////////////////////////
extern volatile uint16 mSecondTick;		// for delay Function

///////////////////////////////////////////////////////////////////////////
void  InitCC1000Pin(void);
void  WriteToCC1000RegWord(uint16 addranddata);
uint8 ReadFromCC1000Register(uint8 addr);
void  WriteToCC1000Register(uint8 addr, uint8 data);
void  RF_ResetFreqSynth(void);
void  Reset_CC1000(void);
uint8 CalibrateCC1000(void);
uint8 SetupCC1000RX(uint8 RxCurrent,uint8 RF_RxPll);
uint8 SetupCC1000TX(uint8 TxCurrent, uint8 RF_TxPll);
void  SetupCC1000PD(void);
void  WakeUpCC1000ToRX(uint8 RxCurrent, uint8 RF_RxPll);
void  WakeUpCC1000ToTX(uint8 TxCurrent, uint8 RF_TxPll);
void  AverageManualLockCC1000(void);
void  AverageFreeRunCC1000(void);
void  AverageAutoLockCC1000(void);
void  ReadCurrentCalibration(uint8 *val1, uint8 *val2);
void  OverrideCurrentCalibration(uint8 val1, uint8 val2);
void  StopOverridingCalibration(void);

//////////////////////////////////////////////////////////////////////////
void InitCC1000Pin(void)
{	
	IRQDisable();
	
#ifdef ENABLE_FR_AMP
	IO0CLR  = CC_ENAMP_P0o;				// set pin level to low
#endif

	IO0SET  = CC_PPALE_P0o;				// set pin level to high
	IO0SET  = CC_PDATA_P0o;				// set pin level to high
	IO0SET  = CC_PPCLK_P0o;				// set pin level to high

//	IO0DIR  = IO0DIR&(~CC_PDATA_P0o);	// PIN_ESAVE serve as input

	IO0DIR  = IO0DIR|CC_PPALE_P0o;		// PIN_ONOFF serve as output
	IO0DIR  = IO0DIR|CC_PDATA_P0o;		// PIN_ESAVE serve as output
	IO0DIR  = IO0DIR|CC_PPCLK_P0o;		// PIN_HOLD  serve as output

#ifdef ENABLE_FR_AMP
	IO0DIR  = IO0DIR|CC_ENAMP_P0o;		// CC_ENAMP_P0o serve as output
	IO0CLR  = CC_ENAMP_P0o;				// set pin level to low, received mode
#endif

	IO0SET  = CC_PPALE_P0o;				// set pin level to high
	IO0SET  = CC_PDATA_P0o;				// set pin level to high
	IO0SET  = CC_PPCLK_P0o;				// set pin level to high

	IRQEnable();
//	DB_SendString("InitCC1000Pin");
}
/************************************************************************/
/* General I/O pin "bit-bashing" versions of configuration routines.    */
/************************************************************************/
/****************************************************************************/
/*  This routine writes to a single CC1000 register, with address and data  */
/*  given in the same variable                                              */
/****************************************************************************/
void WriteToCC1000RegWord(uint16 addranddata)
{
uint8  BitCounter;
uint16 dataBuff;   

//	TimeElapseStart();
	IRQDisable();
	
// get ready;
//  o_pclk=1;
//  o_pale=1;
	IO0SET   = CC_PPCLK_P0o;			// set pin level to high
   	IO0SET   = CC_PPALE_P0o;			// set pin level to high
    dataBuff = addranddata<<1;		// pass the msb

//  o_pale=0;	//transmission starts
	IO0CLR  = CC_PPALE_P0o;

// Send address bits 
    for (BitCounter=0;BitCounter<7;BitCounter++)
    {
 //     o_pclk  = 1;
		IO0SET  = CC_PPCLK_P0o;				// set pin level to high

//      o_pdata = wdun.W.MSB;
		if((dataBuff&0x8000)==0x8000){
			IO0SET  = CC_PDATA_P0o;		// set pin level to high
		}
		else{	
			IO0CLR  = CC_PDATA_P0o;		// set pin level to high
		}
        dataBuff = dataBuff<<1;

//      o_pclk  = 0;
		IO0CLR  = CC_PPCLK_P0o;				// set pin level to high
    }
  
// Send read/write bit, Ignore bit in data, always use 1 
//  o_pclk  = 1;
//  o_pdata = 1;	wdun.Data = wdun.Data<<1;	//pass the MSB
//  o_pclk  = 0;

	IO0SET	= CC_PPCLK_P0o;
	IO0SET	= CC_PDATA_P0o;	
	IO0CLR	= CC_PPCLK_P0o;   

//  o_pclk  = 1;
//  o_pale  = 1;	//change to data sending

	IO0SET	= CC_PPCLK_P0o;
	IO0SET	= CC_PPALE_P0o;
    
//  Send data bits 
    for (BitCounter=0;BitCounter<8;BitCounter++)
    {
//      o_pclk  = 1;
		IO0SET	= CC_PPCLK_P0o;

//      o_pdata = wdun.W.MSB;
        if((dataBuff&0x8000)==0x8000){
			IO0SET  = CC_PDATA_P0o;		// set pin level to high
		}
		else{	
			IO0CLR  = CC_PDATA_P0o;		// set pin level to high
		}
		
//      wdun.Data = wdun.Data<<1;
        dataBuff = dataBuff<<1;

//      o_pclk  = 0;
		IO0CLR	= CC_PPCLK_P0o;   
    }
//  o_pclk = 1;		//transmission ends
	IO0SET	= CC_PPCLK_P0o;

	IRQEnable();
//	TimeElapseStop("WriteToCC1000RegWord()");
}

//===========================================================================
//= This routine reads from a single CC1000 register                        =
//  state:checked
//===========================================================================
uint8 ReadFromCC1000Register(uint8 addr)
{
uint8 BitCounter;
uint8 dataBuff;

//	TimeElapseStart();
	IRQDisable();
	
//get ready 
//  o_pclk=1;
//  o_pale=1;
   	IO0SET   = CC_PPCLK_P0o;			// set pin level to high
   	IO0SET   = CC_PPALE_P0o;			// set pin level to high
    dataBuff = addr<<1;				// pass the MSB
    
//  o_pale=0;						//transmission begin
	IO0CLR  = CC_PPALE_P0o;

// Send address bits
    for (BitCounter=0;BitCounter<7;BitCounter++)
    {
//      o_pclk=1;
	   	IO0SET   = CC_PPCLK_P0o;			// set pin level to high
	   	
//      o_pdata=byun.B.MSB;		byun.Data=byun.Data<<1;
        if((dataBuff&0x80)==0x80){
			IO0SET  = CC_PDATA_P0o;		// set pin level to high
		}
		else{	
			IO0CLR  = CC_PDATA_P0o;		// set pin level to high
		}

		dataBuff=dataBuff<<1;

//      o_pclk=0;
	   	IO0CLR   	= CC_PPCLK_P0o;			// set pin level to high
    }
    
// Send read/write bit , Ignore bit in data, always use 0
//  o_pclk=1;
//  o_pdata=0;
//  o_pclk=0;

	IO0SET	= CC_PPCLK_P0o;
	IO0CLR	= CC_PDATA_P0o;
	IO0CLR	= CC_PPCLK_P0o;   

//  o_pclk=1;
//  o_pale=1;			//change to data receiving

	IO0SET	= CC_PPCLK_P0o;
	IO0SET	= CC_PPALE_P0o;

//  Receive data bits 
//  o_pdata=1;
	IO0SET	= CC_PDATA_P0o;
//  TRISA |= MK2; 					// Set up o_pdata(RA2) as an input
	IO0DIR  = IO0DIR&(~CC_PDATA_P0o);	// CC_PDATA_P0o serve as input

//    
    for (BitCounter=0;BitCounter<8;BitCounter++)
    {
        dataBuff=dataBuff<<1;

//      o_pclk=0;
		IO0CLR	= CC_PPCLK_P0o;   

//      byun.B.LSB=o_pdata;
		if((IO0PIN&CC_PDATA_P0o)==CC_PDATA_P0o){
			dataBuff=dataBuff|0x01;
		}
		else{
			dataBuff=dataBuff&(~0x01);
		}

//      o_pclk=1;
		IO0SET	= CC_PPCLK_P0o;
    }
  
//  TRISA &= (~MK2); // Set up o_pdata(RA2) as an output again
  	IO0DIR  = IO0DIR|CC_PDATA_P0o;		// CC_PDATA_P0o serve as output

	IRQEnable();
//	TimeElapseStop("ReadFromCC1000Register()");
    return dataBuff;
}

//=======================================================================
//= This routine writes to a single CC1000 register 		            =
//  state: checked
//=======================================================================
void WriteToCC1000Register(uint8 addr, uint8 data)
{
uint16 val;

    val=(((uint16)addr)<<8)|(((uint16)data)&0x00FF);
    WriteToCC1000RegWord(val);
}

/****************************************************************************/
/*  This routine resets the CC1000 frequency synthesizer                    */
/****************************************************************************/
void RF_ResetFreqSynth(void)
{
uint8 modem1_value;

  DB_SendString("ResetFreqSynth");    
  modem1_value = ReadFromCC1000Register(CC1000_MODEM1)&(~0x01);
  WriteToCC1000Register(CC1000_MODEM1,modem1_value);
  WriteToCC1000Register(CC1000_MODEM1,modem1_value|0x01);
}

/****************************************************************************/
/*  This routine resets the CC1000, clearing all registers.                 */
/****************************************************************************/  

void Reset_CC1000(void)
{
uint8 MainValue;
  
//  DB_SendString("Reset_CC1000");
  MainValue=ReadFromCC1000Register(CC1000_MAIN);
  WriteToCC1000Register(CC1000_MAIN,MainValue & 0xFE);         // Reset CC1000
  WriteToCC1000Register(CC1000_MAIN,MainValue | 0x01);         // Bring CC1000 out of reset
}

/****************************************************************************/
/*  This routine calibrates the CC1000                                      */
/*  Returns 0 if calibration fails, non-zero otherwise. Checks the LOCK     */