ccxxx0lib.c

是运用PIC单片机控制CC1000的源程序

#define BYTE unsigned char
#define UINT8 unsigned char

void halSpiWriteBurstReg(BYTE addr, BYTE *buffer, BYTE count);
void halSpiReadBurstReg(BYTE addr, BYTE *buffer, BYTE count);
void halSpiWriteReg(BYTE addr, BYTE value);
void halSpiStrobe(BYTE strobe);
BYTE halSpiReadReg(BYTE addr);
BYTE halSpiReadStatus(BYTE addr);
void halRfWriteRfSettings_CC1100();
void halRfWriteRfSettings_CC2500();
BYTE halRfSendPacket(BYTE *txBuffer, UINT8 size);
BYTE halRfReceivePacket(BYTE *rxBuffer, UINT8 length);
void POWER_UP_RESET_CCxxx0();
BYTE spiGetRxTxStatus(void);
BYTE SPI_write(BYTE value);
BYTE SPI_read();
#define WRITE_BURST     0x40
#define READ_SINGLE     0x80
#define READ_BURST      0xC0
//================================================================
//延时L毫秒
//IN：L
//OUT：NONE
//================================================================
void Dly1mS(unsigned int l) 
{
	int i;
	while(l--) 
		for(i=0;i<54;i++);
	
}
//=================================================================
//往SPI写数据
//IN：value
//OUT：spi_status
//=======================================================================
BYTE SPI_write(BYTE value)
{
	unsigned char i,spi_status;
	for(i=0;i<8;i++) { 
		if(value&0x80) 
			{
			  P_SCLK=0;
			  P_SI=1;
			}
		else 
			{
			  P_SCLK=0;
			  P_SI=0;
			}	
		asm("nop"); asm("nop"); asm("nop"); asm("nop");asm("nop");
		P_SCLK=1;
		value <<=1;
		spi_status<<=1;	
		if(P_SO=1)
		   spi_status=spi_status|0x01;
		else
			spi_status=spi_status&0xfe;
	}
	P_SCLK=0;
//	asm("nop"); asm("nop"); asm("nop"); asm("nop");asm("nop");
	return(spi_status);
}
//=================================================================
//从SPI读RF数据
//IN：NONE
//OUT：value
//=======================================================================
BYTE SPI_read()
{
	unsigned char i,value;
	for(i=0;i<8;i++) 
	{ 
		value <<=1;
		P_SCLK=1;
		if(P_SO) value|=0x01;
		else value&=0xFE;
//		asm("nop"); asm("nop"); asm("nop"); asm("nop");asm("nop");
		P_SCLK=0;	
	}
//	asm("nop"); asm("nop"); asm("nop"); asm("nop");asm("nop");
	return value;
}
//=======================================================================

//-------------------------------------------------------------------------------------------------------
//  BYTE halSpiReadReg(BYTE addr) 
//
//  DESCRIPTION:
//      This function gets the value of a single specified CCxxx0 register.
//		通过SPI读单个寄存器的数据
//  ARGUMENTS:
//      BYTE addr
//          Address of the CCxxx0 register to be accessed.
//
//  RETURN VALUE:
//      BYTE
//          Value of the accessed CCxxx0 register.
//-------------------------------------------------------------------------------------------------------
BYTE halSpiReadReg(BYTE addr) 
{
	unsigned char value;
	P_CSn=0;
	while(P_SO);
    P_SCLK=0;
	addr|=READ_SINGLE;
	SPI_write(addr);
	value=SPI_read();
	P_CSn=1;
	P_SCLK=0;
	P_SI=0;
	return value;
}


//-------------------------------------------------------------------------------------------------------
//  BYTE halSpiReadStatus(BYTE addr)
//
//  DESCRIPTION:
//      This function reads a CCxxx0 status register.
//		通过SPI读RF的状态
//  ARGUMENTS:
//      BYTE addr
//          Address of the CCxxx0 status register to be accessed.
//
//  RETURN VALUE:
//      BYTE
//          Value of the accessed CCxxx0 status register.
//-------------------------------------------------------------------------------------------------------
BYTE halSpiReadStatus(BYTE addr) 
{
	unsigned char value;
	P_CSn=0;
	while(P_SO);
    P_SCLK=0;
	addr|=READ_BURST;
	SPI_write(addr);
	value=SPI_read();
	P_CSn=1;
	P_SCLK=0;
	P_SI=0;
	return value;
}// halSpiReadStatus


//-------------------------------------------------------------------------------------------------------
//  void halSpiWriteReg(BYTE addr, BYTE value)
//
//  DESCRIPTION:
//      Function for writing to a single CCxxx0 register
//		通过SPI写数据到一个寄存器
//  ARGUMENTS:
//      BYTE addr
//          Address of a specific CCxxx0 register to accessed.
//      BYTE value
//          Value to be written to the specified CCxxx0 register.
//-------------------------------------------------------------------------------------------------------
void halSpiWriteReg(BYTE addr, BYTE value) 
{
	P_CSn=0;
	while(P_SO);
    P_SCLK=0;
	addr&=0x7F;
	SPI_write(addr);
	SPI_write(value);
	P_SI=0;
	P_CSn=1;

}// halSpiWriteReg


//-------------------------------------------------------------------------------------------------------
//  void halSpiReadBurstReg(BYTE addr, BYTE *buffer, BYTE count)
//
//  DESCRIPTION:
//      This function reads multiple CCxxx0 register, using SPI burst access.
//		读多个寄存器的数据
//  ARGUMENTS:
//      BYTE addr
//          Address of the first CCxxx0 register to be accessed.
//      BYTE *buffer
//          Pointer to a byte array which stores the values read from a
//          corresponding range of CCxxx0 registers.
//      BYTE count
//          Number of bytes to be written to the subsequent CCxxx0 registers.
//-------------------------------------------------------------------------------------------------------
void halSpiReadBurstReg(BYTE addr, BYTE *buffer, BYTE count) 
{
	unsigned char j,value;
	P_CSn=0;
	while(P_SO);
    P_SCLK=0;
	addr|=READ_BURST;
	SPI_write(addr);
	for(j=0;j<count;j++) 
	{
	  value=SPI_read();
	  buffer[j]=value;
	}
	P_CSn=1;
}// halSpiReadBurstReg



//-------------------------------------------------------------------------------------------------------
//  void halSpiWriteBurstReg(BYTE addr, BYTE *buffer, BYTE count)
//
//  DESCRIPTION:
//      This function writes to multiple CCxxx0 register, using SPI burst access.
//		写多个数据到RF寄存器里
//  ARGUMENTS:
//      BYTE addr
//          Address of the first CCxxx0 register to be accessed.
//      BYTE *buffer
//          Array of bytes to be written into a corresponding range of
//          CCxx00 registers, starting by the address specified in _addr_.
//      BYTE count
//          Number of bytes to be written to the subsequent CCxxx0 registers.   
//-------------------------------------------------------------------------------------------------------
void halSpiWriteBurstReg(BYTE addr, BYTE *buffer, BYTE count)
{
	unsigned char i,j,value;
	P_CSn=0;
	while(P_SO);
    P_SCLK=0;
	addr|=WRITE_BURST;
	SPI_write(addr);
	for(j=0;j<count;j++) {
	  value=buffer[j];
	  SPI_write(value);
	  P_SCLK=0;	
	  P_SI=0;
	  for(i=0;i<10;i++);
	}
	P_CSn=1;
}// halSpiWriteBurstReg




//-------------------------------------------------------------------------------------------------------
//  void halSpiStrobe(BYTE strobe)
//
//  DESCRIPTION:
//      Function for writing a strobe command to the CCxxx0
//		写一个命令到RF
//  ARGUMENTS:
//      BYTE strobe
//          Strobe command
//-------------------------------------------------------------------------------------------------------
void halSpiStrobe(BYTE strobe) 
{
	P_CSn=0;
	while(P_SO);
	SPI_write(strobe);
	P_SCLK=0;
	P_SI=0;
	P_CSn=1;

}// halSpiStrobe



//-------------------------------------------------------------------------------------------------------
//  void halRfSendPacket(BYTE *txBuffer, UINT8 size)
//	发送数据包    
//  ARGUMENTS:
//      BYTE *txBuffer
//          Pointer to a buffer containg the data that are going to be transmitted
//
//      UINT8 size
//          The size of the txBuffer
//-------------------------------------------------------------------------------------------------------
BYTE halRfSendPacket(BYTE *txBuffer, UINT8 size) 
{
	halSpiStrobe(CCxxx0_SFTX);
	Dly1mS(10);
	halSpiWriteBurstReg(CCxxx0_TXFIFO, txBuffer, size);
	Dly1mS(10);
	halSpiStrobe(CCxxx0_STX);
	
	TMR0=0; T0IF=0;
	while(spiGetRxTxStatus()&0x70)	
	{
		Dly1mS(2);
		if(T0IF) return 1;
			
	}

	return 0;
}// halRfSendPacket




//-------------------------------------------------------------------------------------------------------
//  BOOL halRfReceivePacket(BYTE *rxBuffer, UINT8 *length)
//	接收数据包
//  
//  ARGUMENTS:
//      BYTE *rxBuffer
//          Pointer to the buffer where the incoming data should be stored
//      UINT8 *length
//          Pointer to a variable containing the size of the buffer where the incoming data should be
//          stored. After this function returns, that variable holds the packet length.
//          
//  RETURN VALUE:
//      BOOL
//          TRUE:   CRC OK
//          FALSE:  CRC NOT OK
//-------------------------------------------------------------------------------------------------------
BYTE halRfReceivePacket(BYTE *rxBuffer, UINT8 length) 
{
    BYTE status=0;
    UINT8 packetLength;
	status = halSpiReadStatus(CCxxx0_RXBYTES);
	if((status & 0x7F)==0x00) 
	{
		
		if(halSpiReadStatus(CCxxx0_MARCSTATE)!=0x0D) halSpiStrobe(CCxxx0_SRX);
		return 0;
	}
	TMR0=0; T0IF=0;
	while((halSpiReadStatus(CCxxx0_MARCSTATE)&0x1f)!=0x01) 
	{
		
		if(T0IF)
		{ 
			halSpiStrobe(CCxxx0_SFRX);
			return 0;
		}
	}
    packetLength = halSpiReadReg(CCxxx0_RXFIFO);
    
    if (packetLength == length) {
		halSpiReadBurstReg(CCxxx0_RXFIFO, rxBuffer, packetLength); 
        
        halSpiStrobe(CCxxx0_SFRX);
        
        return 1;//(status & CRC_OK);
    } else {

		halSpiStrobe(CCxxx0_SFRX);
        return 0;
    }     
}// halRfReceivePacket




//-------------------------------------------------------------------------------------------------------
//  void RfWriteRfSettings()
//	配置RF寄存器
//  DESCRIPTION:
//      This function is used to configure the CCxxx0 based on a given rf setting
//
//  ARGUMENTS:
//      
//         
//-------------------------------------------------------------------------------------------------------
void halRfWriteRfSettings_CC1100() 
{
l_setCC1100:	
	halSpiWriteReg(CCxxx0_FSCTRL1, 0x0C);	
	halSpiWriteReg(CCxxx0_FSCTRL0, 0x00);	
	halSpiWriteReg(CCxxx0_FREQ2, 0x10);
	halSpiWriteReg(CCxxx0_FREQ1, 0xB0);
	halSpiWriteReg(CCxxx0_FREQ0, 0x71);
	halSpiWriteReg(CCxxx0_MDMCFG4, 0xC6);
	halSpiWriteReg(CCxxx0_MDMCFG3, 0x83); 
	halSpiWriteReg(CCxxx0_MDMCFG2, 0x02);
	halSpiWriteReg(CCxxx0_MDMCFG1, 0x22);
	halSpiWriteReg(CCxxx0_MDMCFG0, 0xF8);
	halSpiWriteReg(CCxxx0_CHANNR, 0x00);
	halSpiWriteReg(CCxxx0_DEVIATN, 0x30);
	halSpiWriteReg(CCxxx0_FREND1, 0x56);
	halSpiWriteReg(CCxxx0_FREND0, 0x10);
	halSpiWriteReg(CCxxx0_MCSM0, 0x18);
	halSpiWriteReg(CCxxx0_FOCCFG, 0x15);
	halSpiWriteReg(CCxxx0_BSCFG, 0x6C);
	halSpiWriteReg(CCxxx0_AGCCTRL2, 0x03);
	halSpiWriteReg(CCxxx0_AGCCTRL0, 0x91);
	halSpiWriteReg(CCxxx0_FSCAL3, 0xA9);
	halSpiWriteReg(CCxxx0_FSCAL2, 0x2A);
	halSpiWriteReg(CCxxx0_FSCAL0, 0x0D);
	halSpiWriteReg(CCxxx0_FSTEST, 0x59);
	halSpiWriteReg(CCxxx0_TEST2, 0x86);
	halSpiWriteReg(CCxxx0_TEST1, 0x3D);
	halSpiWriteReg(CCxxx0_TEST0, 0x09);
	halSpiWriteReg(CCxxx0_IOCFG2, 0x24);
	halSpiWriteReg(CCxxx0_IOCFG0, 0x06);
	halSpiWriteReg(CCxxx0_PKTCTRL1, 0x04);
	halSpiWriteReg(CCxxx0_PKTCTRL0, 0x05);
	halSpiWriteReg(CCxxx0_ADDR, 0x00);
	halSpiWriteReg(CCxxx0_PKTLEN, 0xFF);
   
	if(halSpiReadReg(CCxxx0_MDMCFG1)!=0x22)	
		goto l_setCC1100;
}


void halRfWriteRfSettings_CC2500() 
{
l_setCC2500:	
	halSpiWriteReg(CCxxx0_FSCTRL1, 0x0C);	
	halSpiWriteReg(CCxxx0_FSCTRL0, 0x00);	
	halSpiWriteReg(CCxxx0_FREQ2, 0x5D);
	halSpiWriteReg(CCxxx0_FREQ1, 0x93);
	halSpiWriteReg(CCxxx0_FREQ0, 0xB1);
	halSpiWriteReg(CCxxx0_MDMCFG4, 0x2D);
	halSpiWriteReg(CCxxx0_MDMCFG3, 0x3B); 
	halSpiWriteReg(CCxxx0_MDMCFG2, 0x73);
	halSpiWriteReg(CCxxx0_MDMCFG1, 0x22);
	halSpiWriteReg(CCxxx0_MDMCFG0, 0xF8);
	halSpiWriteReg(CCxxx0_CHANNR, 0x00);
	halSpiWriteReg(CCxxx0_DEVIATN, 0x00);
	halSpiWriteReg(CCxxx0_FREND1, 0x56);
	halSpiWriteReg(CCxxx0_FREND0, 0x10);
	halSpiWriteReg(CCxxx0_MCSM0, 0x18);
	halSpiWriteReg(CCxxx0_FOCCFG, 0x15);
	halSpiWriteReg(CCxxx0_BSCFG, 0x6C);
	halSpiWriteReg(CCxxx0_AGCCTRL2, 0xC3);
	halSpiWriteReg(CCxxx0_AGCCTRL0, 0x91);
	halSpiWriteReg(CCxxx0_FSCAL3, 0xEA);
	halSpiWriteReg(CCxxx0_FSCAL2, 0x0A);
	halSpiWriteReg(CCxxx0_FSCAL0, 0x11);
	halSpiWriteReg(CCxxx0_FSTEST, 0x59);
	halSpiWriteReg(CCxxx0_TEST2, 0x8F);
	halSpiWriteReg(CCxxx0_TEST1, 0x21);
	halSpiWriteReg(CCxxx0_TEST0, 0x0B);
	halSpiWriteReg(CCxxx0_IOCFG2, 0x29);
	halSpiWriteReg(CCxxx0_IOCFG0, 0x06);
	halSpiWriteReg(CCxxx0_PKTCTRL1, 0x04);
	halSpiWriteReg(CCxxx0_PKTCTRL0, 0x05);
	halSpiWriteReg(CCxxx0_ADDR, 0x00);
	halSpiWriteReg(CCxxx0_PKTLEN, 0xFF);
   
	if(halSpiReadReg(CCxxx0_MDMCFG1)!=0x22)	
		goto l_setCC2500;
}
//-------------------------------------------------------------
//	通过写NOP获得RF的状态
//-------------------------------------------------------------
BYTE spiGetRxTxStatus(void) 
{
	unsigned char RxTxstatus;
	P_CSn = 0;
	while (P_SO);
	RxTxstatus=SPI_write(CCxxx0_SNOP);
	P_SCLK=0;
	P_SI=0;
	P_CSn=1;
    return(RxTxstatus);
} 

//----------------------------------------------------------------
//	复位RF
//----------------------------------------------------------------
void POWER_UP_RESET_CCxxx0() {
	unsigned char i; 
	halSpiStrobe(CCxxx0_SIDLE);
	P_CSn=1;
	for(i=0;i<5;i++);  
	P_CSn=0;
	for(i=0;i<5;i++);  
	P_CSn=1;
	for(i=0;i<200;i++);  
	P_CSn=0;
	while(P_SO);
	halSpiStrobe(CCxxx0_SRES);
	P_CSn=1;
	P_SCLK=0;
	P_SI=0;
}