cc1100lib.c

这是一个在PIC单片机上对射频收发器CC1100的操作程序。里面包含了一个发送和一个接收程序。采用C语言编的。

//-------------------------------------------------------------------------------------------------------
//  void halSpiStrobe(BYTE strobe)
//
//  DESCRIPTION:
//      Function for writing a strobe command to the CC1100
//
//  ARGUMENTS:
//      BYTE strobe
//          Strobe command
//-------------------------------------------------------------------------------------------------------
void halSpiStrobe(BYTE strobe) {
	unsigned char i;
	P_CSn=0;
	for(i=0;i<8;i++) {
		if(strobe&0x80) P_SI=1;
		else P_SI=0;
		P_SCLK=1;
		strobe <<=1;
//		asm("nop"); asm("nop"); asm("nop"); asm("nop");
//		asm("nop"); asm("nop"); asm("nop"); asm("nop");
//		asm("nop"); asm("nop"); asm("nop"); asm("nop");
		P_SCLK=0; 
	}
	P_SI=0;
	P_CSn=1;

}// halSpiStrobe

//-------------------------------------------------------------------------------------------------------
//  void RfWriteRfSettings(RF_SETTINGS *pRfSettings)
//
//  DESCRIPTION:
//      This function is used to configure the CC1100 based on a given rf setting
//
//  ARGUMENTS:
//      RF_SETTINGS *pRfSettings
//          Pointer to a struct containing rf register settings
//-------------------------------------------------------------------------------------------------------
void halRfWriteRfSettings1() {
    // Write register settings
    halSpiWriteReg(CC1100_FSCTRL1,  rfSettings1.FSCTRL1);
    halSpiWriteReg(CC1100_FSCTRL0,  rfSettings1.FSCTRL0);
    halSpiWriteReg(CC1100_FREQ2,    rfSettings1.FREQ2);
    halSpiWriteReg(CC1100_FREQ1,    rfSettings1.FREQ1);
    halSpiWriteReg(CC1100_FREQ0,    rfSettings1.FREQ0);
    halSpiWriteReg(CC1100_MDMCFG4,  rfSettings1.MDMCFG4);
    halSpiWriteReg(CC1100_MDMCFG3,  rfSettings1.MDMCFG3);
    halSpiWriteReg(CC1100_MDMCFG2,  rfSettings1.MDMCFG2);
    halSpiWriteReg(CC1100_MDMCFG1,  rfSettings1.MDMCFG1);
    halSpiWriteReg(CC1100_MDMCFG0,  rfSettings1.MDMCFG0);
    halSpiWriteReg(CC1100_CHANNR,   rfSettings1.CHANNR);
    halSpiWriteReg(CC1100_DEVIATN,  rfSettings1.DEVIATN);
    halSpiWriteReg(CC1100_FREND1,   rfSettings1.FREND1);
    halSpiWriteReg(CC1100_FREND0,   rfSettings1.FREND0);
    halSpiWriteReg(CC1100_MCSM0 ,   rfSettings1.MCSM0 );
    halSpiWriteReg(CC1100_FOCCFG,   rfSettings1.FOCCFG);
    halSpiWriteReg(CC1100_BSCFG,    rfSettings1.BSCFG);
    halSpiWriteReg(CC1100_AGCCTRL2, rfSettings1.AGCCTRL2);
    halSpiWriteReg(CC1100_AGCCTRL0, rfSettings1.AGCCTRL0);
    halSpiWriteReg(CC1100_FSCAL3,   rfSettings1.FSCAL3);
    halSpiWriteReg(CC1100_FSCAL2,   rfSettings1.FSCAL2);
    halSpiWriteReg(CC1100_FSCAL0,   rfSettings1.FSCAL0);
    halSpiWriteReg(CC1100_FSTEST,   rfSettings1.FSTEST);
    halSpiWriteReg(CC1100_TEST2,    rfSettings1.TEST2);
    halSpiWriteReg(CC1100_TEST1,    rfSettings1.TEST1);
    halSpiWriteReg(CC1100_TEST0,    rfSettings1.TEST0);
    halSpiWriteReg(CC1100_IOCFG2,   rfSettings1.IOCFG2);
    halSpiWriteReg(CC1100_IOCFG0,   rfSettings1.IOCFG0);    
    halSpiWriteReg(CC1100_PKTCTRL1, rfSettings1.PKTCTRL1);
    halSpiWriteReg(CC1100_PKTCTRL0, rfSettings1.PKTCTRL0);
    halSpiWriteReg(CC1100_ADDR,     rfSettings1.ADDR);
    halSpiWriteReg(CC1100_PKTLEN,   rfSettings1.PKTLEN);
}// halRfWriteRfSettings


void halRfWriteRfSettings2() {
    // Write register settings
    halSpiWriteReg(CC1100_FSCTRL1,  rfSettings2.FSCTRL1);
    halSpiWriteReg(CC1100_FSCTRL0,  rfSettings2.FSCTRL0);
    halSpiWriteReg(CC1100_FREQ2,    rfSettings2.FREQ2);
    halSpiWriteReg(CC1100_FREQ1,    rfSettings2.FREQ1);
    halSpiWriteReg(CC1100_FREQ0,    rfSettings2.FREQ0);
    halSpiWriteReg(CC1100_MDMCFG4,  rfSettings2.MDMCFG4);
    halSpiWriteReg(CC1100_MDMCFG3,  rfSettings2.MDMCFG3);
    halSpiWriteReg(CC1100_MDMCFG2,  rfSettings2.MDMCFG2);
    halSpiWriteReg(CC1100_MDMCFG1,  rfSettings2.MDMCFG1);
    halSpiWriteReg(CC1100_MDMCFG0,  rfSettings2.MDMCFG0);
    halSpiWriteReg(CC1100_CHANNR,   rfSettings2.CHANNR);
    halSpiWriteReg(CC1100_DEVIATN,  rfSettings2.DEVIATN);
    halSpiWriteReg(CC1100_FREND1,   rfSettings2.FREND1);
    halSpiWriteReg(CC1100_FREND0,   rfSettings2.FREND0);
    halSpiWriteReg(CC1100_MCSM0 ,   rfSettings2.MCSM0 );
    halSpiWriteReg(CC1100_FOCCFG,   rfSettings2.FOCCFG);
    halSpiWriteReg(CC1100_BSCFG,    rfSettings2.BSCFG);
    halSpiWriteReg(CC1100_AGCCTRL2, rfSettings2.AGCCTRL2);
    halSpiWriteReg(CC1100_AGCCTRL0, rfSettings2.AGCCTRL0);
    halSpiWriteReg(CC1100_FSCAL3,   rfSettings2.FSCAL3);
    halSpiWriteReg(CC1100_FSCAL2,   rfSettings2.FSCAL2);
    halSpiWriteReg(CC1100_FSCAL0,   rfSettings2.FSCAL0);
    halSpiWriteReg(CC1100_FSTEST,   rfSettings2.FSTEST);
    halSpiWriteReg(CC1100_TEST2,    rfSettings2.TEST2);
    halSpiWriteReg(CC1100_TEST1,    rfSettings2.TEST1);
    halSpiWriteReg(CC1100_TEST0,    rfSettings2.TEST0);
    halSpiWriteReg(CC1100_IOCFG2,   rfSettings2.IOCFG2);
    halSpiWriteReg(CC1100_IOCFG0,   rfSettings2.IOCFG0);    
    halSpiWriteReg(CC1100_PKTCTRL1, rfSettings2.PKTCTRL1);
    halSpiWriteReg(CC1100_PKTCTRL0, rfSettings2.PKTCTRL0);
    halSpiWriteReg(CC1100_ADDR,     rfSettings2.ADDR);
    halSpiWriteReg(CC1100_PKTLEN,   rfSettings2.PKTLEN);
}// halRfWriteRfSettings


//-------------------------------------------------------------------------------------------------------
//  void halRfSendPacket(BYTE *txBuffer, UINT8 size)
//
//  DESCRIPTION:
//      This function can be used to transmit a packet with packet length up to 63 bytes.
//      To use this function, GD02 must be configured to be asserted when sync word is sent and 
//      de-asserted at the end of the packet => halSpiWriteReg(CC1100_IOCFG2, 0x06);
//      The function implements polling of GDO2. First it waits for GD02 to be set and then it waits
//      for it to be cleared.  
//      
//  ARGUMENTS:
//      BYTE *txBuffer
//          Pointer to a buffer containg the data that are going to be transmitted
//
//      UINT8 size
//          The size of the txBuffer
//-------------------------------------------------------------------------------------------------------
void halRfSendPacket(BYTE *txBuffer, UINT8 size) {

    halSpiWriteBurstReg(CC1100_TXFIFO, txBuffer, size);
    halSpiStrobe(CC1100_STX);
    // Wait for GDO0 to be set -> sync transmitted
    while (!P_GD00);

    // Wait for GDO0 to be cleared -> end of packet
    while (P_GD00);

}// halRfSendPacket

//-------------------------------------------------------------------------------------------------------
//  BOOL halRfReceivePacket(BYTE *rxBuffer, UINT8 *length)
//
//  DESCRIPTION: 
//      This function can be used to receive a packet of variable packet length (first byte in the packet
//      must be the length byte). The packet length should not exceed the RX FIFO size.
//      To use this function, GD02 must be configured to be asserted when sync word is sent and 
//      de-asserted at the end of the packet => halSpiWriteReg(CC1100_IOCFG2, 0x06);
//      The function implements polling of GDO2. First it waits for GD02 to be set and then it waits
//      for it to be cleared.  
//  
//  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;
    UINT8 packetLength;

    halSpiStrobe(CC1100_SRX);
    // Wait for GDO0 to be set -> sync received

//	TMR0=0; T0IF=0;  // Wait 65mS Option : 0x87 4MHz;
    while (!P_GD00);// if(TMR1H & T1Mask) return 0;

    // Wait for GDO2 to be cleared -> end of packet
//	TMR0=0; T0IF=0;	// Wait 65mS Option : 0x87 4MHz;
    while (P_GD00);//  if(TMR1H & T1Mask) return 0;
    status = halSpiReadStatus(CC1100_PKTSTATUS);

    // Read pdata from RX FIFO and store them in rxBuffer
    packetLength = halSpiReadReg(CC1100_RXFIFO);
    
    if (packetLength <= *length) {
        halSpiReadBurstReg(CC1100_RXFIFO, rxBuffer, packetLength); 
        *length = packetLength;
        
        // Flush RX FIFO
        halSpiStrobe(CC1100_SFRX);
        return (status & CRC_OK);
    } else {
        *length = packetLength;

        // Flush RX FIFO
        halSpiStrobe(CC1100_SFRX);
        return 0;
    }     
}// halRfReceivePacket

void POWER_UP_RESET_CC1100() {
	unsigned char i,strobe; 
//	P_SCLK=1; P_SI=0;
	P_CSn=1;
	for(i=0;i<5;i++);  // In 8MHz 6uS
	P_CSn=0;
	for(i=0;i<5;i++);  // In 8MHz 6uS	 
	P_CSn=1;
	for(i=0;i<40;i++);  // In 8MHz 60uS , need 40uS(Min)
	P_CSn=0;
	strobe=CC1100_SRES;
	for(i=0;i<8;i++) {
		if(strobe&0x80) P_SI=1;
		else P_SI=0;
		P_SCLK=1;
		strobe <<=1;
		asm("nop"); asm("nop"); asm("nop"); asm("nop");
		asm("nop"); asm("nop"); asm("nop"); asm("nop");
		asm("nop"); asm("nop"); asm("nop"); asm("nop");
		P_SCLK=0; 
	}
	while(P_SO);
	P_CSn=1;

}