?? ccxxx0lib.c.bak
字號:
#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
//================================================================
//延時(shí)L毫秒
//IN：L
//OUT：NONE
//================================================================
void Dly1mS(unsigned int l)
{
int i;
while(l--)
for(i=0;i<54;i++);
}
//=================================================================
//往SPI寫數(shù)據(jù)
//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)
if(P_SO==1)//modify Jason Xiang 2006-9-26 10:26
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數(shù)據(jù)
//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讀單個(gè)寄存器的數(shù)據(jù)
// 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的狀態(tài)
// 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寫數(shù)據(jù)到一個(gè)寄存器
// 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.
// 讀多個(gè)寄存器的數(shù)據(jù)
// 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.
// 寫多個(gè)數(shù)據(jù)到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
// 寫一個(gè)命令到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)
// 發(fā)送數(shù)據(jù)包
// 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);//Modify by Jason Xiang 2006-9-26 16:24
//Dly1mS(10); //Modify by Jason Xiang 2006-9-26 16:24
halSpiWriteBurstReg(CCxxx0_TXFIFO, txBuffer, size);
Dly1mS(10);
halSpiStrobe(CCxxx0_STX);
TMR0=0; T0IF=0;
while(spiGetRxTxStatus()&0x70)
{
Dly1mS(2);
if(T0IF)
{
halSpiStrobe(CCxxx0_SIDLE);//append by Jason Xiang 2006/08/21
return 1;
}
}
return 0;
}// halRfSendPacket
/*BYTE halRfSendPacket(BYTE *txBuffer, UINT8 size)
{
halSpiWriteBurstReg(CCxxx0_TXFIFO, txBuffer, size);
halSpiStrobe(CCxxx0_STX);
while(!P_GDO0);
while(P_GDO0);
return 0;
}// halRfSendPacket*/
//-------------------------------------------------------------------------------------------------------
// BOOL halRfReceivePacket(BYTE *rxBuffer, UINT8 *length)
// 接收數(shù)據(jù)包
//
// 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的狀態(tài)
//-------------------------------------------------------------
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);
}
//----------------------------------------------------------------
// 復(fù)位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;
}
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -