cc2500lib.c

CHIPCON公司射频芯片CC1100驱动程序

#define BYTE unsigned char
#define UINT8 unsigned char

void WriteBurstReg(BYTE addr, BYTE *buffer, BYTE count);

void ReadBurstReg(BYTE addr, BYTE *buffer, BYTE count);

void halSpiWriteReg(BYTE addr, BYTE value);

void Strobe(BYTE strobe);

BYTE halSpiReadReg(BYTE addr);

BYTE ReadStatus(BYTE addr);

BYTE SendPacket(BYTE *txBuffer, UINT8 size);

BYTE halReceivePacket(BYTE *rxBuffer, UINT8 length);

void halWriteRfSettings_CC2500();

void POWER_UP_RESET_CC2500();

BYTE spiGetRxTxStatus(void);
BYTE SPI_write(BYTE value);
BYTE SPI_read();
unsigned char packetLength;
BYTE status[2];

#define WRITE_BURST     0x40
#define READ_SINGLE     0x80
#define READ_BURST      0xC0
//================================================================
//4mhz;0.25us
//延时L毫秒
//IN：L
//OUT：NONE
//================================================================
//
//	software spi 
//
//=================================================================
BYTE SPI_write(BYTE value)
{
	unsigned char i,spi_status;
	for(i=0;i<8;i++) 
	{
		P3OUT &= ~SCLK; //P_SCLK=0; 
		if(value&0x80) 
			  P3OUT |= SI;  //P_SI=1;
		else 
			  P3OUT &= ~SI; //P_SI=0;
		value <<=1;
    P3OUT |= SCLK; //P_SCLK=1;  
		spi_status<<=1;	
		if(P3IN & SO)
		   spi_status |= 0x01;
		else
		   spi_status &= ~0x01;
	}
	P3OUT &= ~SCLK;  //P_SCLK=0;
	return(spi_status);
}

//--------------------------------------------------------------------
BYTE SPI_read()
{
	unsigned char i,value;
	for(i=0;i<8;i++) 
	{ 
		value <<=1;
		P3OUT |= SCLK; //P_SCLK=1;
		if(P3IN & SO) value |= 0x01;
		else value &= ~0x01;
               
		P3OUT &= ~SCLK;  //P_SCLK=0;
    asm("nop"); asm("nop");
	}

	return value;
}

//==========================================================
//	读单个寄存器的值
//==========================================================
BYTE halSpiReadReg(BYTE addr) 
{
	unsigned char value;
	P3OUT &= ~CSn;          //CSN=0
	while(P3IN & SO);
	addr|=READ_SINGLE;
	SPI_write(addr);
	value=SPI_read();
	P3OUT |= CSn;          //CSN=1
	return value;
}

//============================================================
//	写一个数到地址为<addr>的寄存器里
//===========================================================
void halSpiWriteReg(BYTE addr, BYTE value) 
{
	P3OUT &= ~CSn;          //CSN=0
	while(P3IN & SO);
   
	addr&=0x7F;
	SPI_write(addr);
	SPI_write(value);

	P3OUT |= CSn;          //CSN=1

}

//===========================================================
//	读RF的地址为<addr>的状态寄存器
//===========================================================
BYTE ReadStatus(BYTE addr) 
{
	unsigned char value;
	P3OUT &= ~CSn;          //CSN=0
	while(P3IN & SO);
  
	addr|=READ_BURST;
	SPI_write(addr);
	value=SPI_read();
	P3OUT |= CSn;          //CSN=1
        //cRSSI = value;
	return value;
}




//============================================================
//	读多个寄存器的值
//	起始地址：addr
//	数量：count
//	保存地方：*buffer
//============================================================

void ReadBurstReg(BYTE addr, BYTE *buffer, BYTE count) 
{
	unsigned char j,value;
	P3OUT &= ~CSn;          //CSN=0
	while(P3IN & SO);
   
	addr|=READ_BURST;
	SPI_write(addr);
	for(j=0;j<count;j++) 
	{
	  value=SPI_read();
	  buffer[j]=value;
	}
	P3OUT |= CSn;          //CSN=1
}



//===========================================================
//	写多个值到寄存器里
//	起始地址：addr
//	数量：count
//	数据来源：*buffer
//
//============================================================
void halSpiWriteBurstReg(BYTE addr, BYTE *buffer, BYTE count)
{
	unsigned char i,j,value;
	P3OUT &= ~CSn;          //CSN=0
	while(P3IN & SO);
  
	addr|=WRITE_BURST;
	SPI_write(addr);
	for(j=0;j<count;j++) {
	  value=buffer[j];
	  SPI_write(value);
	 
	  for(i=0;i<10;i++);
	}
	P3OUT |= CSn;          //CSN=1
}



//===========================================================
//	写一个命令到RF里
//===========================================================

void halSpiStrobe(BYTE strobe) 
{
	P3OUT &= ~CSn;          //CSN=0
	while(P3IN & SO);
	SPI_write(strobe);
	
	P3OUT |= CSn;          //CSN=1

}


//=========================================================
//	发送数据包（查询方式）
//	数据来源：*txBuffer
//	数据包长度：size
//=========================================================

BYTE halRfSendPacket(BYTE *txBuffer, UINT8 size) 
{
	UINT8 j;
	unsigned int i;
	halSpiStrobe(CC2500_SIDLE);
	halSpiStrobe(CC2500_SFTX);
	halSpiWriteBurstReg(CC2500_TXFIFO, txBuffer, size);
	halSpiStrobe(CC2500_STX);
  	j=size*10;					//note:j<0xff具体多少要根据datarate和size来决定 
  	while ((P2IN&GDO0)==0)			//等待开始发射
  	{
		for(i=0;i<1000;i++);	//delay 1ms
		j--;
		if(j==0)
		{
			halSpiStrobe(CC2500_SIDLE);//不发射，退出
			return 1;
		}  				
  	}

    j=size*10;					//note:j<0xff具体多少要根据datarate和size来决定
  	while (P2IN&GDO0)			//等待发射结束
  	{
  		for(i=0;i<1000;i++);	//delay 1ms
		j--;
		if(j==0)
		{
			halSpiStrobe(CC2500_SIDLE);//发射失败，退出
			return 1;
		}  	
  	}

	return 0;
}



//=========================================================
//	接收数据包（查询方式）
//	保存在：*txBuffer
//	数据包长度：length
//=========================================================
#define RSSI 0
#define LQI	 1 
BYTE ReceivePacket(BYTE *rxBuffer, UINT8 length) 
{
 //   unsigned char status=0;
    UINT8 j;
    int i;
    Dly1mS(1);
	if(ReadStatus(CC2500_RXBYTES)==0)  return 0;
	Dly1mS(2);
  	j=length*10;					//note:j<0xff具体多少要根据datarate和length来决定
  	while (P2IN&GDO0)			//等待接收结束
  	{
  		for(i=0;i<1000;i++);	//delay 1ms
		j--;
		if(j==0)
		{
			Strobe(CC2500_SIDLE);//接收失败，退出
			return 0;
		}  	
  	}
  
    	packetLength = halSpiReadReg(CC2500_RXFIFO);
  
    	if (packetLength == length) 
		{
			ReadBurstReg(CC2500_RXFIFO, rxBuffer, packetLength); 
            ReadBurstReg(CC2500_RXFIFO, status, 2); 
       
            return (status[LQI] & CRC_OK);
        	
    	} 
		else 
		{
            Strobe(CC2500_SIDLE);
			Strobe(CC2500_SFRX);
        	return 0;
		}
  
}


//============================================================
//	配置寄存器
//============================================================
void halRfWriteRfSettings(void)
{
    halSpiWriteReg(CC2500_FSCTRL1,  rfSettings.FSCTRL1);
    halSpiWriteReg(CC2500_FSCTRL0,  rfSettings.FSCTRL0);
    halSpiWriteReg(CC2500_FREQ2,    rfSettings.FREQ2);
    halSpiWriteReg(CC2500_FREQ1,    rfSettings.FREQ1);
    halSpiWriteReg(CC2500_FREQ0,    rfSettings.FREQ0);
    halSpiWriteReg(CC2500_MDMCFG4,  rfSettings.MDMCFG4);
    halSpiWriteReg(CC2500_MDMCFG3,  rfSettings.MDMCFG3);
    halSpiWriteReg(CC2500_MDMCFG2,  rfSettings.MDMCFG2);
    halSpiWriteReg(CC2500_MDMCFG1,  rfSettings.MDMCFG1);
    halSpiWriteReg(CC2500_MDMCFG0,  rfSettings.MDMCFG0);
    halSpiWriteReg(CC2500_CHANNR,   rfSettings.CHANNR);
    halSpiWriteReg(CC2500_DEVIATN,  rfSettings.DEVIATN);
    halSpiWriteReg(CC2500_FREND1,   rfSettings.FREND1);
    halSpiWriteReg(CC2500_FREND0,   rfSettings.FREND0);
    halSpiWriteReg(CC2500_MCSM0 ,   rfSettings.MCSM0 );
    halSpiWriteReg(CC2500_FOCCFG,   rfSettings.FOCCFG);
    halSpiWriteReg(CC2500_BSCFG,    rfSettings.BSCFG);
    halSpiWriteReg(CC2500_AGCCTRL2, rfSettings.AGCCTRL2);
    halSpiWriteReg(CC2500_AGCCTRL1, rfSettings.AGCCTRL1);
    halSpiWriteReg(CC2500_AGCCTRL0, rfSettings.AGCCTRL0);
    halSpiWriteReg(CC2500_FSCAL3,   rfSettings.FSCAL3);
    halSpiWriteReg(CC2500_FSCAL2,   rfSettings.FSCAL2);
    halSpiWriteReg(CC2500_FSCAL1,   rfSettings.FSCAL1);
    halSpiWriteReg(CC2500_FSCAL0,   rfSettings.FSCAL0);
    halSpiWriteReg(CC2500_FSTEST,   rfSettings.FSTEST);
    halSpiWriteReg(CC2500_TEST2,    rfSettings.TEST2);
    halSpiWriteReg(CC2500_TEST1,    rfSettings.TEST1);
    halSpiWriteReg(CC2500_TEST0,    rfSettings.TEST0);
    halSpiWriteReg(CC2500_IOCFG2,   rfSettings.IOCFG2);
    halSpiWriteReg(CC2500_IOCFG0,   rfSettings.IOCFG0);
    halSpiWriteReg(CC2500_PKTCTRL1, rfSettings.PKTCTRL1);
    halSpiWriteReg(CC2500_PKTCTRL0, rfSettings.PKTCTRL0);
    halSpiWriteReg(CC2500_ADDR,     rfSettings.ADDR);
    halSpiWriteReg(CC2500_PKTLEN,   rfSettings.PKTLEN);
	/////// for sync detect
    //halSpiWriteReg(CC2500_FIFOTHR,  rfSettings.FIFOTHR);
   // halSpiWriteReg(CC2500_SYNC1,    rfSettings.SYNC1);
    //halSpiWriteReg(CC2500_SYNC0,    rfSettings.SYNC0);
	/////// for WOR
   // halSpiWriteReg(CC2500_MCSM2,    rfSettings.MCSM2);
    halSpiWriteReg(CC2500_MCSM1,    rfSettings.MCSM1);
   // halSpiWriteReg(CC2500_WOREVT1,  rfSettings.WOREVT1);
   // halSpiWriteReg(CC2500_WOREVT0,  rfSettings.WOREVT0);
   // halSpiWriteReg(CC2500_WORCTRL,  rfSettings.WORCTRL);
}// halRfWriteRfSettings
/*
void WriteRfSettings_TEST()	//76.8K
{
    WriteReg(CC2500_FSTEST, 0x59);
	WriteReg(CC2500_TEST2, 0x88);
	WriteReg(CC2500_TEST1, 0x31);
	WriteReg(CC2500_TEST0, 0x09);
}

*/
//========================================================
/*
BYTE spiGetRxTxStatus(void) 
{
	unsigned char RxTxstatus;
	P6OUT &= ~CSn;          //CSN=0
	while (P3IN & SO);
	RxTxstatus=SPI_write(CC2500_SNOP);

	P6OUT |= CSn;           //CSN=1;
    return(RxTxstatus);
} */

//==========================================================
//	复位CC2500
//=========================================================
void POWER_UP_RESET_CC2500() {
	int i; 
	halSpiStrobe(CC2500_SIDLE);
	P3OUT |= CSn;           //CSN=1;
	for(i=0;i<50;i++);  
	P3OUT &= ~CSn;          //CSN=0
	for(i=0;i<50;i++); 
	P3OUT |= CSn;           //CSN=1;
	for(i=0;i<600;i++);  
	P3OUT &= ~CSn;          //CSN=0
	while(P3IN & SO);
	halSpiStrobe(CC2500_SRES);
	P3OUT |= CSn;           //CSN=1;

}