CC2500程序代码

zhaofaohua

CC2500程序代码 [复制链接]

This routine sets up  SPI transfer 

void SetupSPI(void)

{

  SSPSTAT=0x40; 

  SSPCON=0x21;

}

void SetupSPI_CC1000(void)

{

  SSPSTAT=0x40; 

  SSPCON=0x31;

}

//============================================================

BYTE SPI_write(BYTE value)

{

unsigned char data;

int i;

SSPBUF=value;

  // SSPBUF=(addr<<1)|0x01; // Write address to rf, write bit is always 1

 

   // Wait until data is written 

i=0x500;

   while (STAT_BF==0) 

{

i--;

if(i==0) return 0;

  }

   data=SSPBUF;  

  

return data;

}

//===============================================================

BYTE SPI_read()

{

  char Value;

  int i;

  

  SSPBUF=0xFF; // Dummy write 

  i=0x500;

  while (STAT_BF==0)

  {

i--;

if(i==0) return 0;

  }

  Value=SSPBUF;

  return Value;

}

shilaike

要发就发工程嘛。。。。

rogerangel

至少应该弄个原理图之类的，这样看，看不太清楚

zhaofaohua

需要这方面资料可以加QQ聊聊。284382376

huomanying

这程序代码段应该更具可读性一点

dean11

不要钱下了，CC2500PA???

何雪

好象不完整？？

evoc

这好像是SPI的读写程序，下了先，谢谢楼主。

rock_chu

呵呵，刚有这一段有什么用？

sabart

学习！！！！！！！！！！！！

huangfei

这个用的是PIC的单片机吗？

shmilylo

谢谢分享 希望提供更全面点的

zhaofaohua

//往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;
}*/
//=======================================================================
//
//        use hardware spi
//================================================================

//-------------------------------------------------------------------------------------------------------
//  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);
        addr|=READ_SINGLE;
        SPI_write(addr);
        value=SPI_read();
        P_CSn=1;
        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);
  
        addr|=READ_BURST;
        SPI_write(addr);
        value=SPI_read();
        P_CSn=1;
        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);
   
        addr&=0x7F;
        SPI_write(addr);
        SPI_write(value);

        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);
   
        addr|=READ_BURST;
        SPI_write(addr);
        for(j=0;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);
  
        addr|=WRITE_BURST;
        SPI_write(addr);
        for(j=0;j           value=buffer[j];
          SPI_write(value);
         
          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_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)
{
        UINT8 j;
//        halSpiStrobe(CCxxx0_SIDLE);
//        halSpiStrobe(CCxxx0_SFTX);
        halSpiWriteBurstReg(CCxxx0_TXFIFO, txBuffer, size);
        Dly1mS(1);
        halSpiStrobe(CCxxx0_STX);
//        TMR1H=0;TMR1L=0;TMR1IF=0;
        j=size*10;
//        if(sysmodule==cc1150pa || sysmodule==cc1100pa ||sysmodule==cc2550pa ||sysmodule==cc2500pa)
//        {
        while((spiGetRxTxStatus()&0x70))       
        {
                Dly1mS(2);
                j--;
                if(!j)
                {
                        halSpiStrobe(CCxxx0_SIDLE);
                        SYSERRORLED=1;
                        return 1;
                }       
                       
        }
/*        }
        else
        {
        while(!P_GDO0)
        {
//                Dly1mS(1);
                if(TMR1H>0xF0)
                {         
                        halSpiStrobe(CCxxx0_SIDLE);
                        SYSERRORLED=1;
                        return 1;
                }
        }
       
        j=size*5;//j=size*50;
        while(P_GDO0)
        {
                Dly1mS(2);
                j--;
                if(!j)
                {
                        halSpiStrobe(CCxxx0_SIDLE);
                        SYSERRORLED=1;
                        return 1;
                }
        }
        }*/
        SYSERRORLED=0;       
        return 0;
}// halRfSendPacket




//-------------------------------------------------------------------------------------------------------
//  BOOL halRfReceivePacket(BYTE *rxBuffer, UINT8 *length)
//        接收数据包
//  
//  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

//=========================================================================
void RSSI_test(void)
{
        unsigned char RSSI_DATA;
       
        RSSI_DATA=halSpiReadStatus(CCxxx0_RSSI);
        if(RSSI_DATA>=128)
        {
                RSSI_DATA=~RSSI_DATA;
                RSSI_DATA++;
                RSSI_DATA/=2;
                RSSI_DATA=RSSI_DATA+75;
        }       
        else
        {
                RSSI_DATA/=2;
                RSSI_DATA=75-RSSI_DATA;
        }
        if(RSSI_DATA>50) halSpiWriteReg(CCxxx0_FIFOTHR,0x07);
        else
                 halSpiWriteReg(CCxxx0_FIFOTHR,0x27);
}
















//================================================================================





//-------------------------------------------------------------------------------------------------------
BYTE halRfReceivePacket(BYTE *rxBuffer, UINT8 length)
{

    UINT8 j;
        BYTE status[2];
        halSpiStrobe(CCxxx0_SRX);
        Dly1mS(1);
        RSSI_test();
        if(halSpiReadStatus(CCxxx0_RXBYTES)==0) return 0;
        Dly1mS(2);

        j=length*90;
        while((halSpiReadStatus(CCxxx0_MARCSTATE)&0x1f)!=0x01)
        {
               
                Dly1mS(1);
                j--;
                if(!j)
                {
                        halSpiStrobe(CCxxx0_SIDLE);
                        halSpiStrobe(CCxxx0_SFRX);                       
                        return 0;
                }
        }
               
            PacketLength = halSpiReadReg(CCxxx0_RXFIFO);
            if((PacketLength<0x20) && (PacketLength>0))
                {
                        halSpiReadBurstReg(CCxxx0_RXFIFO, rxBuffer, PacketLength);
        
                // Read the 2 appended status bytes (status[0] = RSSI, status[1] = LQI)
            halSpiReadBurstReg(CCxxx0_RXFIFO, status, 2);
                return (status[1] & CRC_OK);
            }
                else
                {
                        halSpiStrobe(CCxxx0_SIDLE);
                        halSpiStrobe(CCxxx0_SFRX);
                return 0;
                }

  
}






//-------------------------------------------------------------
//        通过写NOP获得RF的状态
//-------------------------------------------------------------
BYTE spiGetRxTxStatus(void)
{
        unsigned char RxTxstatus;
        P_CSn = 0;
        while (P_SO);
        RxTxstatus=SPI_write(CCxxx0_SNOP);

        P_CSn=1;
    return(RxTxstatus);
}

//----------------------------------------------------------------
//        复位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;

}

上官梦舞

用的什么单片机，程序兼容吗啊？