cc1100收发

1.定义三个gpio: p0-sclk, p1-sdi, p2-sdo；p0用于模拟spi的clock，p1用于接收数据，p2用于f发送数据；硬件上单片机A的p0接单片机B的p0，A的p1接B的p2，A的p2接B的p1 2.发送程序：clock拉低，sdo输出0或1（数据），延时一定时间，clock拉高，延时一定时间，这样A就发送一位数据到B，循环8次就发送一个字节数据 3.接收程序：检测clock状态，如果为低，就读取sdi，直到clock拉高，结束该次输入，重复8次，读取一个字节 注意： 1。clock空闲状态为高，发送数据就拉低； 2.还需要加入起始停止同步协议，可根据需要进行完善

#include "reg52.h"
#include "intrins.h"
#include "CC1100.h"


#define        INT8U                unsigned char
#define        INT16U                unsigned int


#define     WRITE_BURST         0x40                        //连续写入
#define     READ_SINGLE         0x80                        //读
#define     READ_BURST          0xC0                        //连续读
#define     BYTES_IN_RXFIFO     0x7F                          //接收缓冲区的有效字节数
#define     CRC_OK              0x80                         //CRC校验通过位标志



#define     INT8U        unsigned char
#define     INT16U        unsigned int





sbit     GDO0   =P3^2;
sbit     GDO2   =P3^3;
sbit    CSN       =P1^4;
sbit    MOSI   =P1^5;
sbit    MISO   =P1^6;
sbit    SCLK   =P1^7;
sbit    spz    =P2^4;
sbit    LED1   = P2^1;
sbit    LED2   = P2^1;
sbit    key    =P2^0;





/****************************************************************************************
//全局变量定义
/****************************************************************************************/
//INT16U TimeOutCount[2]={0,0};                            //超时计数器
INT8U code PaTabel[8] = {0xC0, 0xC8, 0x85, 0x51, 0x3A, 0x06, 0x1C, 0x6C};


//*****************************************************************************************
//函数名：delay(unsigned int s)
//输入：时间
//输出：无
//功能描述：普通廷时
//*****************************************************************************************
delay(unsigned int s)
{
    unsigned int i;
    for(i=0; i<s; i++);
    for(i=0; i<s; i++);
}


void halWait(INT16U timeout) {
    do {
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
    } while (--timeout);
}

/*****************************************************************************************
//函数名:UartInit()
//输入：无
//输出：无
//功能描述：串口初始化程序
/*****************************************************************************************/
void UartInit(void)
{

    SCON = 0x50;                // uart in mode 1 (8 bit), REN=1
    TMOD = TMOD | 0x20 ;       // Timer 1 in mode 2
    TH1  = 0xFD;               // 9600 Bds at 11.059MHz
    TL1  = 0xFD;             // 9600 Bds at 11.059MHz
    TR1  = 1;                              // Timer 1 run
}


/*****************************************************************************************
//函数名:void TimerInit(void)
//输入：无
//输出：无
//功能描述：定时器0初始化程序
/*****************************************************************************************/



void SpiInit(void)
{
    CSN=0;
    SCLK=0;
    CSN=1;
}

/*****************************************************************************************
//函数名：CpuInit()
//输入：无
//输出：无
//功能描述：SPI初始化程序
/*****************************************************************************************/
CpuInit(void)
{
        UartInit();
//        TimerInit();
        SpiInit();
        delay(5000);
}

/*
//*****************************************************************************************
//函数名：ResetTimer(INT8U n)
//输入：要复位的计时器
//输出：无
//功能描述：复位计时器
//*****************************************************************************************
void ResetTimer(INT8U n)
{
    ET0 = 0;                                    // Disable Timer0 interrupt
    timer[n & 0x01] = 0;                        // Clear timer[n]
    ET0 = 1;                                    // Enable Timer0 interrupt
}


//*****************************************************************************************
//函数名：INT16U ReadTimer(INT8U n)
//输入：要读的计时器
//输出：读出值
//功能描述：读计时器
//*****************************************************************************************
INT16U ReadTimer(INT8U n)
{
    INT16U tmp;
    ET0 = 0;                                    // Disable Timer0 interrupt
    tmp = timer[n];                             // Clear timer[n]
    ET0 = 1;                                    // Enable Timer0 interrupt
    return tmp;
}
*/
/*****************************************************************************************
//函数名:SendCh(ch)
//输入：无
//输出：无
//功能描述：串口发送一个字符
/*****************************************************************************************/
void SendCh(INT8U ch)
{
    SBUF = ch;
    while(!TI);
    TI = 0;
}


/*****************************************************************************************
//函数名：void SendStr(INT8U *arr)
//输入：发送的字符串
//输出：无
//功能描述：发送一个字符串
/*****************************************************************************************/
//void SendStr(INT8U *arr)
//{
//    INT8U i;

//    i = 0;
//    while(arr[i] != '\0')
//    {
//        SendCh(arr[i]);
//        i++;
//    }
//}

//*****************************************************************************************
//函数名：SpisendByte(INT8U dat)
//输入：发送的数据
//输出：无
//功能描述：SPI发送一个字节
//*****************************************************************************************
INT8U SpiTxRxByte(INT8U dat)
{
    INT8U i,temp;
    temp = 0;

    SCLK = 0;
    for(i=0; i<8; i++)
    {
        if(dat & 0x80)
        {
            MOSI = 1;
        }
        else MOSI = 0;
        dat <<= 1;

        SCLK = 1;
        _nop_();
        _nop_();

        temp <<= 1;
        if(MISO)temp++;
        SCLK = 0;
        _nop_();
        _nop_();
    }
    return temp;
}

//*****************************************************************************************
//函数名：void RESET_CC1100(void)
//输入：无
//输出：无
//功能描述：复位CC1100
//*****************************************************************************************
void RESET_CC1100(void)
{
    CSN = 0;
    while (MISO);
    SpiTxRxByte(CCxxx0_SRES);         //写入复位命令
    while (MISO);
    CSN = 1;
}

//*****************************************************************************************
//函数名：void POWER_UP_RESET_CC1100(void)
//输入：无
//输出：无
//功能描述：上电复位CC1100
//*****************************************************************************************
void POWER_UP_RESET_CC1100(void)
{
    CSN = 1;
    halWait(1);
    CSN = 0;
    halWait(1);
    CSN = 1;
    halWait(41);
    RESET_CC1100();           //复位CC1100
}

//*****************************************************************************************
//函数名：void halSpiWriteReg(INT8U addr, INT8U value)
//输入：地址和配置字
//输出：无
//功能描述：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 MISO to be set -> sync transmitted
    while (!GDO0);

    // Wait for MISO to be cleared -> end of packet
    while (GDO0);
    halSpiStrobe(CCxxx0_SFTX);
}



INT8U halRfReceivePacket(INT8U *rxBuffer, INT8U *length)
{
    INT8U status[2];
    INT8U packetLength;

    halSpiStrobe(CCxxx0_SRX);        //进入接收状态
    while (!GDO0);
    while (GDO0);
    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校验位
            return (status[1] & CRC_OK);            //如果校验成功返回接收成功
        }
         else
        {
            *length = packetLength;
            halSpiStrobe(CCxxx0_SFRX);        //清洗接收缓冲区
            return 0;
        }
    }
    else
     return 0;
}

/******************************************************************************************
*******************************************************************************************
************************************中断服务程序*********************************************
*******************************************************************************************
******************************************************************************************/
/*void Timer0ISR(void) interrupt 1
{
    EA = 0;
    TH0+=TIMER0H;
    TL0+=TIMER0L;
    TimerCount++;
    timer[0]++;
    timer[1]++;
    EA = 1;
}
*/
void delay1ms(int t)
{
  int i,j;
  for(i=0;i<t;i++)
  for(j=0;j<120;j++)
;
}


/******************************************************************************************
*******************************************************************************************
******************************************主程序*******************************************
*******************************************************************************************
******************************************************************************************/
main(void)
{
    INT8U i;
    INT8U leng;
    //INT8U code arrTx[60]="where there is a will,there is a way,trust me,I will be ";
    INT8U xdata arrRx[100]=0;
    CpuInit();
    POWER_UP_RESET_CC1100();
    halRfWriteRfSettings();
    halSpiWriteBurstReg(CCxxx0_PATABLE, PaTabel, 8);
    LED1 = 0;
    delay(60000);
    LED1 = 1;
    delay(30000);
   leng=sizeof arrRx;
    while(1)
    {
       //    if(!key)
       // {
       //  delay1ms(20);
      //  if(!key)
      //   {

    //      halRfSendPacket(arrTx,leng);
    //      LED2 = 0;
    //      delay(1000);
    //      LED2 = 1;
    //      delay(2000);



    if(halRfReceivePacket(arrRx,&leng))
    {

            LED2 = 0;
            delay(10000);
            LED2 = 1;
            halSpiStrobe(CCxxx0_SFRX);
            for(i=0;i<leng;i++)
           {
             SendCh(arrRx[i]);
            }


  }
}

    //    }
//    }
} ...