1100无线双向遥控程序贡献分享.txt

1100无线双向遥控程序

//输入：地址和配置字 
//输出：无 
//功能描述：SPI写寄存器 
//***************************************************************************************** 
void halSpiWriteReg(INT8U addr, INT8U value)  
{ 
    CSN = 0; 
    while (MISO); 
    SpiTxRxByte(addr);                //写地址 
    SpiTxRxByte(value);                //写入配置 
    CSN = 1; 
} 

//***************************************************************************************** 
//函数名：void halSpiWriteBurstReg(INT8U addr, INT8U *buffer, INT8U count) 
//输入：地址，写入缓冲区，写入个数 
//输出：无 
//功能描述：SPI连续写配置寄存器 
//***************************************************************************************** 
void halSpiWriteBurstReg(INT8U addr, INT8U *buffer, INT8U count)  
{ 
    INT8U i, temp; 
        temp = addr | WRITE_BURST; 
    CSN = 0; 
    while (MISO); 
    SpiTxRxByte(temp); 
    for (i = 0; i < count; i++) 
         { 
        SpiTxRxByte(buffer[i]); 
    } 
    CSN = 1; 
} 

//***************************************************************************************** 
//函数名：void halSpiStrobe(INT8U strobe) 
//输入：命令 
//输出：无 
//功能描述：SPI写命令 
//***************************************************************************************** 
void halSpiStrobe(INT8U strobe)  
{ 
    CSN = 0; 
    while (MISO); 
    SpiTxRxByte(strobe);                //写入命令 
    CSN = 1; 
} 





//***************************************************************************************** 
//函数名：INT8U halSpiReadReg(INT8U addr) 
//输入：地址 
//输出：该寄存器的配置字 
//功能描述：SPI读寄存器 
//***************************************************************************************** 
INT8U halSpiReadReg(INT8U addr)  
{ 
        INT8U temp, value; 
    temp = addr|READ_SINGLE;//读寄存器命令 
        CSN = 0; 
        while (MISO); 
        SpiTxRxByte(temp); 
        value = SpiTxRxByte(0); 
        CSN = 1; 
        return value; 
} 


//***************************************************************************************** 
//函数名：void halSpiReadBurstReg(INT8U addr, INT8U *buffer, INT8U count) 
//输入：地址，读出数据后暂存的缓冲区，读出配置个数 
//输出：无 
//功能描述：SPI连续写配置寄存器 
//***************************************************************************************** 
void halSpiReadBurstReg(INT8U addr, INT8U *buffer, INT8U count)  
{ 
    INT8U i,temp; 
        temp = addr | READ_BURST;                //写入要读的配置寄存器地址和读命令 
    CSN = 0; 
    while (MISO); 
        SpiTxRxByte(temp);    
    for (i = 0; i < count; i++)  
        { 
        buffer[i] = SpiTxRxByte(0); 
    } 
    CSN = 1; 
} 


//***************************************************************************************** 
//函数名：INT8U halSpiReadReg(INT8U addr) 
//输入：地址 
//输出：该状态寄存器当前值 
//功能描述：SPI读状态寄存器 
//***************************************************************************************** 
INT8U halSpiReadStatus(INT8U addr)  
{ 
    INT8U value,temp; 
        temp = addr | READ_BURST;                //写入要读的状态寄存器的地址同时写入读命令 
    CSN = 0; 
    while (MISO); 
    SpiTxRxByte(temp); 
        value = SpiTxRxByte(0); 
        CSN = 1; 
        return value; 
} 
//***************************************************************************************** 
//函数名：void halRfWriteRfSettings(RF_SETTINGS *pRfSettings) 
//输入：无 
//输出：无 
//功能描述：配置CC1100的寄存器 
//***************************************************************************************** 
void halRfWriteRfSettings(void)  
{ 

        halSpiWriteReg(CCxxx0_FSCTRL0,  rfSettings.FSCTRL2);//自已加的 
    // Write register settings 
    halSpiWriteReg(CCxxx0_FSCTRL1,  rfSettings.FSCTRL1); 
    halSpiWriteReg(CCxxx0_FSCTRL0,  rfSettings.FSCTRL0); 
    halSpiWriteReg(CCxxx0_FREQ2,    rfSettings.FREQ2); 
    halSpiWriteReg(CCxxx0_FREQ1,    rfSettings.FREQ1); 
    halSpiWriteReg(CCxxx0_FREQ0,    rfSettings.FREQ0); 
    halSpiWriteReg(CCxxx0_MDMCFG4,  rfSettings.MDMCFG4); 
    halSpiWriteReg(CCxxx0_MDMCFG3,  rfSettings.MDMCFG3); 
    halSpiWriteReg(CCxxx0_MDMCFG2,  rfSettings.MDMCFG2); 
    halSpiWriteReg(CCxxx0_MDMCFG1,  rfSettings.MDMCFG1); 
    halSpiWriteReg(CCxxx0_MDMCFG0,  rfSettings.MDMCFG0); 
    halSpiWriteReg(CCxxx0_CHANNR,   rfSettings.CHANNR); 
    halSpiWriteReg(CCxxx0_DEVIATN,  rfSettings.DEVIATN); 
    halSpiWriteReg(CCxxx0_FREND1,   rfSettings.FREND1); 
    halSpiWriteReg(CCxxx0_FREND0,   rfSettings.FREND0); 
    halSpiWriteReg(CCxxx0_MCSM0 ,   rfSettings.MCSM0 ); 
    halSpiWriteReg(CCxxx0_FOCCFG,   rfSettings.FOCCFG); 
    halSpiWriteReg(CCxxx0_BSCFG,    rfSettings.BSCFG); 
    halSpiWriteReg(CCxxx0_AGCCTRL2, rfSettings.AGCCTRL2); 
        halSpiWriteReg(CCxxx0_AGCCTRL1, rfSettings.AGCCTRL1); 
    halSpiWriteReg(CCxxx0_AGCCTRL0, rfSettings.AGCCTRL0); 
    halSpiWriteReg(CCxxx0_FSCAL3,   rfSettings.FSCAL3); 
        halSpiWriteReg(CCxxx0_FSCAL2,   rfSettings.FSCAL2); 
        halSpiWriteReg(CCxxx0_FSCAL1,   rfSettings.FSCAL1); 
    halSpiWriteReg(CCxxx0_FSCAL0,   rfSettings.FSCAL0); 
    halSpiWriteReg(CCxxx0_FSTEST,   rfSettings.FSTEST); 
    halSpiWriteReg(CCxxx0_TEST2,    rfSettings.TEST2); 
    halSpiWriteReg(CCxxx0_TEST1,    rfSettings.TEST1); 
    halSpiWriteReg(CCxxx0_TEST0,    rfSettings.TEST0); 
    halSpiWriteReg(CCxxx0_IOCFG2,   rfSettings.IOCFG2); 
    halSpiWriteReg(CCxxx0_IOCFG0,   rfSettings.IOCFG0);     
    halSpiWriteReg(CCxxx0_PKTCTRL1, rfSettings.PKTCTRL1); 
    halSpiWriteReg(CCxxx0_PKTCTRL0, rfSettings.PKTCTRL0); 
    halSpiWriteReg(CCxxx0_ADDR,     rfSettings.ADDR); 
    halSpiWriteReg(CCxxx0_PKTLEN,   rfSettings.PKTLEN); 
} 

//***************************************************************************************** 
//函数名：void halRfSendPacket(INT8U *txBuffer, INT8U size) 
//输入：发送的缓冲区，发送数据个数 
//输出：无 
//功能描述：CC1100发送一组数据 
//***************************************************************************************** 

void halRfSendPacket(INT8U *txBuffer, INT8U size)  
{ 
        halSpiWriteReg(CCxxx0_TXFIFO, size); 
    halSpiWriteBurstReg(CCxxx0_TXFIFO, txBuffer, size);        //写入要发送的数据 

    halSpiStrobe(CCxxx0_STX);                //进入发送模式发送数据 

    // Wait for GDO0 to be set -> sync transmitted 
    while (!GDO0); 
    // Wait for GDO0 to be cleared -> end of packet 
    while (GDO0); 
        halSpiStrobe(CCxxx0_SFTX); 
} 


void setRxMode(void) 
{ 
    halSpiStrobe(CCxxx0_SRX);                //进入接收状态 
} 

/* 
// Bit masks corresponding to STATE[2:0] in the status byte returned on MISO 
#define CCxx00_STATE_BM                 0x70 
#define CCxx00_FIFO_BYTES_AVAILABLE_BM  0x0F 
#define CCxx00_STATE_TX_BM              0x20 
#define CCxx00_STATE_TX_UNDERFLOW_BM    0x70 
#define CCxx00_STATE_RX_BM              0x10 
#define CCxx00_STATE_RX_OVERFLOW_BM     0x60 
#define CCxx00_STATE_IDLE_BM            0x00 

static INT8U RfGetRxStatus(void) 
{ 
        INT8U temp, spiRxStatus1,spiRxStatus2; 
        INT8U i=4;// 循环测试次数 
    temp = CCxxx0_SNOP|READ_SINGLE;//读寄存器命令 
        CSN = 0; 
        while (MISO); 
        SpiTxRxByte(temp); 
        spiRxStatus1 = SpiTxRxByte(0); 
        do 
        { 
                SpiTxRxByte(temp); 
                spiRxStatus2 = SpiTxRxByte(0); 
                if(spiRxStatus1 == spiRxStatus2) 
                { 
                        if( (spiRxStatus1 & CCxx00_STATE_BM) == CCxx00_STATE_RX_OVERFLOW_BM) 
                        { 
               halSpiStrobe(CCxxx0_SFRX); 
                           return 0; 
                        } 
                    return 1; 
                } 
                 spiRxStatus1=spiRxStatus2; 
        } 
        while(i--); 
        CSN = 1; 
    return 0;         
} 
 */ 
INT8U halRfReceivePacket(INT8U *rxBuffer, INT8U *length)  
{ 
    INT8U status[2]; 
    INT8U packetLength; 
        INT8U i=(*length)*4;  // 具体多少要根据datarate和length来决定 

    halSpiStrobe(CCxxx0_SRX);                //进入接收状态 
        //delay(5); 
    //while (!GDO1); 
    //while (GDO1); 
        delay(2); 
        while (GDO0) 
        { 
                delay(2); 
                --i; 
                if(i<1) 
                   return 0;              
        }          
    if ((halSpiReadStatus(CCxxx0_RXBYTES) & BYTES_IN_RXFIFO)) //如果接的字节数不为0 
        { 
        packetLength = halSpiReadReg(CCxxx0_RXFIFO);//读出第一个字节，此字节为该帧数据长度 
        if (packetLength <= *length)                 //如果所要的有效数据长度小于等于接收到的数据包的长度 
                { 
            halSpiReadBurstReg(CCxxx0_RXFIFO, rxBuffer, packetLength); //读出所有接收到的数据 
            *length = packetLength;                                //把接收数据长度的修改为当前数据的长度 
         
            // Read the 2 appended status bytes (status[0] = RSSI, status[1] = LQI) 
            halSpiReadBurstReg(CCxxx0_RXFIFO, status, 2);         //读出CRC校验位 
                        halSpiStrobe(CCxxx0_SFRX);                //清洗接收缓冲区 
            return (status[1] & CRC_OK);                        //如果校验成功返回接收成功 
        } 
                 else  
                { 
            *length = packetLength; 
            halSpiStrobe(CCxxx0_SFRX);                //清洗接收缓冲区 
            return 0; 
        } 
    }  
        else 
         return 0; 
} 
/* 
void Delay(unsigned int s) 
{ 
        unsigned int i; 
        for(i=0; i<s; i++); 
        for(i=0; i<s; i++); 
} 

*/ 
void main(void) 
{ 
        INT8U leng =0; 
        INT8U tf =0; 
        INT8U TxBuf[8]={0};         // 8字节, 如果需要更长的数据包,请正确设置 
        INT8U RxBuf[8]={0};         
        CpuInit(); 
        POWER_UP_RESET_CC1100(); 
        halRfWriteRfSettings(); 
        halSpiWriteBurstReg(CCxxx0_PATABLE, PaTabel, 8); 

        //TxBuf[0] = 8 ; 
        TxBuf[1] = 1 ; 
        TxBuf[2] = 1 ; 
        halRfSendPacket(TxBuf,8);        // Transmit Tx buffer data 
        delay(6000); 
        P0=0xBF; 
                led0=0;led1=0;led2=0;led3=0; 
        while(1) 
        { 
            //setRxMode(); 
            if(KEY1 ==0 )  
                  { 
                           LED1 = 0;  
                    TxBuf[1] = 1 ; 
                    tf = 1 ;  
                        //while(KEY1 ==0); 
            } 
           if(KEY2 ==0 ) 
           { 
                        LED2 = 0; 
                        TxBuf[2] = 1 ; 
                        tf = 1 ;  
           } 

           if (tf==1) 
       {         
                        halRfSendPacket(TxBuf,8);        // Transmit Tx buffer data 
                        TxBuf[1] = 0xff; 
                        TxBuf[2] = 0xff; 
                        tf=0; 
                        delay(500); 
                led0=0;led1=0;led2=0;led3=0; 
           } 

                leng =8; // 预计接受8 bytes 
                   if(halRfReceivePacket(RxBuf,&leng)) 
                { 
                                                 
                        if(        RxBuf[1]==1) 
                        {                  
                                P0=0xF7; 
                        led0=0;led1=0;led2=0;led3=0; 
                        } 
                        if(        RxBuf[2]==1) 
                        { 
                                P0=0xFE;         
                        led0=0;led1=0;led2=0;led3=0; 
                        } 
                delay(1000); 
                        led0=1;led1=1;led2=1;led3=1; 
                } 

                RxBuf[1] = 0xff; 
                RxBuf[2] = 0xff; 
        } 
         
}