ccxxx0lib.c

mc68hc908jb8的usb代码

#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) 
{
	while(l--) 
	{
	#asm
	movlw	0xf9
	movwf	_delay
l_loop_dly:
	nop
	decfsz	_delay		
	goto	l_loop_dly
	#endasm
	}
//		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(1);
	halSpiWriteBurstReg(CCxxx0_TXFIFO, txBuffer, size);
	halSpiStrobe(CCxxx0_STX);
	TMR1H=0;TMR1L=0;TMR1IF=0;
//	while((spiGetRxTxStatus()&0x70))	
//	{
//		Dly1mS(2);
//		if(T0IF)
//		{ 
//			halSpiStrobe(CCxxx0_SIDLE);
//			return 1;
//		}	
//			
//	}
	while(!P_GDO0)