cc1000ppv2.c

Communication with chipcon cc1000.

/*  to check for success.                                                   */
/****************************************************************************/

char CalibrateCC1000(void)
{  
  unsigned int TimeOutCounter;

  WriteToCC1000Register(CC1000_PA_POW,0x00); // Turn off PA to avoid spurs
                                             // during calibration in TX mode
  WriteToCC1000Register(CC1000_CAL,0xA6); // Start calibration
  PORTB.2=1;

  // Wait for calibration complete
  for(TimeOutCounter=CAL_TIMEOUT; ((ReadFromCC1000Register(CC1000_CAL)&0x08)==0)&&(TimeOutCounter>0); TimeOutCounter--);
  PORTB.0=(ReadFromCC1000Register(CC1000_CAL)&0x08);
  
  // Wait for lock
  for(TimeOutCounter=LOCK_TIMEOUT; ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0)&&(TimeOutCounter>0); TimeOutCounter--);
  //delay_ms(40);
  PORTB.1=(ReadFromCC1000Register(CC1000_LOCK)&0x01);
  
  WriteToCC1000Register(CC1000_CAL,0x26); /* End calibration */
  WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); /* Restore PA setting */
  PORTB.2=0;
  PORTB.0=0;
  PORTB.1=0;
  return ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==1);
}

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

char SetupCC1000RX(char RXCurrent,char RXPLL) 
{   
  CC1000mode=idle;
  WriteToCC1000Register(CC1000_MAIN,0x11);    // Switch into RX, switch to freq. reg A 
  WriteToCC1000Register(CC1000_CURRENT,RX_CURRENT); // Program VCO current for RX 
  WriteToCC1000Register(CC1000_PLL,RX_PLL);   // Use RX refdiv setting 

  CC1000mode = RXmode;
  DDRB &= ~(1<<DIO);//som receiver skal DIO v鎟e input
  return 1;
} 
/****************************************************************************/
/*  This routine puts the CC1000 into TX mode (from RX). When switching to  */
/*  TX from PD, use WakeupCC1000ToTX first                                  */
/****************************************************************************/

char SetupCC1000TX(char TXCurrent,char TXPLL) 
{ 
  CC1000mode=idle;
  WriteToCC1000Register(CC1000_PA_POW,0x00);   // Turn off PA to avoid frequency splatter 
 
  WriteToCC1000Register(CC1000_MAIN,0xE1);    // Switch into TX, switch to freq. reg B 
  WriteToCC1000Register(CC1000_PLL,TX_PLL);   // Use TX refdiv setting 
  WriteToCC1000Register(CC1000_CURRENT,TX_CURRENT); // Program VCO current for TX 

  // Increase output power 
  WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); // Restore PA setting 
  CC1000mode = TXmode; 
  DDRB |= (1<<DIO);//som transmitter skal DIO v鎟e output   
    
  return 1; 
} 

/****************************************************************************/
/*  This routine puts the CC1000 into power down mode. Use WakeUpCC1000ToRX */
/*  followed by SetupCC1000RX or WakeupCC1000ToTX followed by SetupCC1000TX */
/*  to wake up from power down                                              */
/****************************************************************************/

void SetupCC1000PD(void)
{
  WriteToCC1000Register(CC1000_MAIN,0x3F);    // Put CC1000 into power-down
  WriteToCC1000Register(CC1000_PA_POW,0x00);  // Turn off PA to minimise current draw
}

/****************************************************************************/
/*  This routine wakes the CC1000 up from PD mode to RX mode, call          */
/*  SetupCC1000RX after this routine is finished.                           */
/****************************************************************************/

void WakeUpCC1000ToRX(char RXCurrent)
{
  unsigned int i;
  
  
  WriteToCC1000Register(CC1000_MAIN,0x3B);  // Turn on xtal oscillator core
  WriteToCC1000Register(CC1000_CURRENT,RXCurrent); // Program VCO current for RX 
  WriteToCC1000Register(CC1000_PLL,RX_PLL); // Use RX refdiv setting
  
  // Insert wait routine here, must wait for xtal oscillator to stabilise, 
  // typically takes 2-5ms.
  for (i=0;i<0x7FFE;i++);
  
  WriteToCC1000Register(CC1000_MAIN,0x39);  // Turn on bias generator
  // Wait for 250us, insert wait loop here
  WriteToCC1000Register(CC1000_MAIN,0x31);  // Turn on frequency synthesiser
}

/****************************************************************************/
/*  This routine wakes the CC1000 up from PD mode to TX mode, call          */
/*  SetupCC1000TX after this routine is finished.                           */
/****************************************************************************/

void WakeUpCC1000ToTX(char TXCurrent)
{
  unsigned int i;
  
  
  WriteToCC1000Register(CC1000_MAIN,0xFB);  // Turn on xtal oscillator core
  WriteToCC1000Register(CC1000_CURRENT,TXCurrent); // Program VCO current for TX
  WriteToCC1000Register(CC1000_PLL,TX_PLL); // Use TX refdiv setting
  
  // Insert wait routine here, must wait for xtal oscillator to stabilise, 
  // typically takes 2-5ms. 
  for (i=0;i<0x7FFE;i++);
  
  WriteToCC1000Register(CC1000_MAIN,0xF9);  // Turn on bias generator
  // Wait for 250us, insert wait loop here
  WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); // Turn on PA
  WriteToCC1000Register(CC1000_MAIN,0xF1);  // Turn on frequency synthesiser
}

/****************************************************************************/
/*  This routine locks the averaging filter of the CC1000                   */
/****************************************************************************/

void AverageManualLockCC1000(void)
{
  WriteToCC1000Register(CC1000_MODEM1,0x19);
}

/****************************************************************************/
/*  This routine unlocks the averaging filter of the CC1000                 */
/****************************************************************************/

void AverageFreeRunCC1000(void)
{
  WriteToCC1000Register(CC1000_MODEM1,0x09);
}

/****************************************************************************/
/*  This routine sets up the averaging filter of the CC1000 for automatic   */
/*  lock. This can be used in polled receivers.                             */
/****************************************************************************/

void AverageAutoLockCC1000(void)
{
  WriteToCC1000Register(CC1000_MODEM1,0x01);
}

/****************************************************************************/
/*  This routine reads the current calibration values from the CC1000       */
/****************************************************************************/

void ReadCurrentCalibration(char *val1, char *val2)
{
  *val1=ReadFromCC1000Register(CC1000_TEST0);
  *val2=ReadFromCC1000Register(CC1000_TEST2);
}

/****************************************************************************/
/*  This routine overrides the current calibration of the CC1000            */
/****************************************************************************/

void OverrideCurrentCalibration(char val1, char val2)
{
  WriteToCC1000Register(CC1000_TEST5,(val1&0x0F)|0x10);
  WriteToCC1000Register(CC1000_TEST6,(val2&0x1F)|0x20);
}

/****************************************************************************/
/*  This routine stops override of the CC1000 calibration values            */
/****************************************************************************/

void StopOverridingCalibration(void)
{
  WriteToCC1000Register(CC1000_TEST5,0x00);
  WriteToCC1000Register(CC1000_TEST6,0x00);
}
  

/****************************************************************************/
/*  This CC1000 frequency synthesizer                                       */
/****************************************************************************/
void ResetFreqSynth(void)
{
  char modem1_value;
  modem1_value = ReadFromCC1000Register(CC1000_MODEM1)&~0x01;
  WriteToCC1000Register(CC1000_MODEM1,modem1_value);
  WriteToCC1000Register(CC1000_MODEM1,modem1_value|0x01);
}
   
void initCC1000interrupt(void){
  preamberror=0;
  //til transmit
  sendstringpos=0;
  sendbytepos=0;
  sendSOFstatus=0;
  sendpreambcount=0;
  //til receive
  modtagbytepos=0;
  modtagstringpos=0;
  modtagpreambcount=0;
  SOFstatus=0;
}
unsigned char CC1000TXinterrupt(void){ 
  if(sendbytepos==0){
	//hele forrige byte er sendt - ny loades
	if(sendpreambcount <= preambmax){
	  sendbyte = 0x55;
	  sendbytepos=8;
	  sendpreambcount++;
	}
	else{  
	  if(sendSOFstatus < 2){
		sendbyte = SOF;
		sendSOFstatus++;
		sendbytepos=8;
	  }
	  else{
		if(sendstringpos == TXsize){
		  //reset:
		  sendstringpos=0;
		  sendbytepos=0;
		  sendSOFstatus=0;
		  sendpreambcount=0;
		  //alt er sendt
		  CC1000status &= ~sender;//sender ikke mere		  
		  
		}
		else{
		  if(sendSOFstatus == 2){
			sendbyte = TXsize;//send l鎛gden
			sendbytepos=8;
			sendSOFstatus++;
		  }
		  else{
			sendbyte = TXbytes[sendstringpos];
			sendbytepos=8;
			sendstringpos++;	  
		  }
		}
	  }
	}
  }
  sendbytepos--;  
  sendbit = (sendbyte & (1<<sendbytepos))>>sendbytepos;
  return sendbit;
}

void CC1000RXinterrupt(unsigned char modtagbit){
  modtagbyte = (modtagbyte << 1) | modtagbit;      
  if(!modtagpreambdetected){
    	if((modtagbyte == 0x55) || (modtagbyte == 0xAA)){
	  modtagpreambdetected=1; 	   
	}
  }
  else{        
  switch(SOFstatus){
  case 0:  
	if(modtagbyte == SOF){	  
	  SOFstatus = 1;
	  //PORTB.1=1;
	  //SOFmodtaget=1;
	  //CC1000status=modtager;
	  modtagbytepos=0;
	}
	else{
	  if(!((modtagbyte == 0x55) || (modtagbyte == 0xAA))){		
		if(preamberror>7){
		  modtagpreambdetected=0;
		  preamberror=0;
		}
		preamberror++;
		}
	  }
	break;
  case 1:
	if(modtagbytepos==8){
	  if(modtagbyte == SOF){
		SOFmodtaget=1;
		SOFstatus=2;
	  }
	  else{		
		SOFstatus=0;
	  }
	  modtagbytepos = 0;
	}
	break;
  case 2:
	if(modtagbytepos == 8){//8 bit (1 byte) er modtaget		
	  RXsize = modtagbyte;
	  SOFstatus = 3;
	  modtagbytepos=0;
	}
	break;
  case 3:
	//2 SOF's og l鎛gden er modtaget og selve indholdet kan modtages
	if(RXsize > modtagstringpos){
	  //hvis alt endnu ikke er modtaget
	  if(modtagbytepos == 8){//8 bit (1 byte) er modtaget				  
		//modtag
		RXbytes[modtagstringpos] = modtagbyte;
		modtagbytepos=0;
		modtagstringpos++;			
	  }
	}
	else{
	  modtagpreambdetected = 0;
	  preamberror=0;
	  SOFmodtaget=0;
	  RXbytes[modtagstringpos] = '\0';
	  CC1000status &= ~modtager;
	  //reset
	  modtagstringpos=0;
	  modtagbytepos=0;
	  SOFstatus=0;
	  datamodtaget=1;
	}
	break;
	}
  modtagbytepos++;
  }
}