spi.c

TI 无线传输芯片CC1100用 TMS320C5509 驱动的发送程序

# include <csl_gpio.h>
# include <csl_gpiodat.h>
# include <csl_gpiohal.h>
# include "spi.h"
# include <csl_mcbsp.h>

extern MCBSP_Handle hMcbsp;
extern Uint16 *dstaddr1;
extern void mcbsp_init();
Uint16 paTable[] = {0x51};
Uint16 paTableLen = 1;

void reset_cc();
void config_cc();
void initSPI();
void TI_CC_SPIWriteReg(Uint16 addr, Uint16 value);
void TI_CC_SPIWriteBurstReg(Uint16 addr, Uint16 *buffer, Uint16 count);
Uint16 TI_CC_SPIReadReg(Uint16 addr);
void TI_CC_SPIReadBurstReg(Uint16 addr, Uint16 *buffer,Uint16 count);
void DELAY(Uint16 cycles);
void TI_CC_SPIStrobe(Uint16 strobe);
void RFSendPacket(Uint16 *txBuffer, Uint16 size);
Uint16 TI_CC_SPIReadStatus(Uint16 addr);

void initSPI()
{
 mcbsp_init();
 MCBSP_start(hMcbsp, 

               MCBSP_SRGR_START | MCBSP_SRGR_FRAMESYNC, 

               0x300

               );
 MCBSP_start(hMcbsp, 

                MCBSP_RCV_START | MCBSP_XMIT_START, 

                0

               );
 reset_cc();
 config_cc();
 TI_CC_SPIWriteBurstReg(TI_CCxxx0_PATABLE, paTable, paTableLen);
 TI_CC_SPIStrobe(TI_CCxxx0_SRX);
 DELAY(200);
 //RFSendPacket(dstaddr1, 44);  //176/4=44;
}





void reset_cc()
{
 GPIO_RSET(IODATA,0x14); 
 DELAY(30);
 GPIO_RSET(IODATA,0x10);
 DELAY(30);
 GPIO_RSET(IODATA,0x14);
 DELAY(45);       //at least 40us ,from Figure 11 
 GPIO_RSET(IODATA,0x10);
 DELAY(30);
  MCBSP_write16(hMcbsp,TI_CCxxx0_SRES) ;  //send strobe
 while (!(MCBSP_xrdy(hMcbsp)));//wait for tramsmitter to become free
 GPIO_RSET(IODATA,0x14);

}

void config_cc()
{
     // Write register settings
    TI_CC_SPIWriteReg(TI_CCxxx0_IOCFG2,   0x0B); // //GDO2 output pin config.同步时钟

    TI_CC_SPIWriteReg(TI_CCxxx0_IOCFG0,   0x06); // //GDO0 output pin config.设置为中断引脚，当受到或者发出数据后产生脉冲
    
    TI_CC_SPIWriteReg(TI_CCxxx0_PKTLEN,   0xff); // //Packet length.              ///在可变长数据包条件下为数据包的最长字数                                           //
    TI_CC_SPIWriteReg(TI_CCxxx0_PKTCTRL1, 0x04); // //Packet automation control.  ///加载两个状态字到数据包里，这两个状态字包含RSSI和LQI的值，以及CRC ok的标志        //
    TI_CC_SPIWriteReg(TI_CCxxx0_PKTCTRL0, 0x05); // //Packet automation control.  ///设置为可变长度的数据包，长度由同步字后的第一个字决定。支持cc2400，且打开CRC校验  //
                                        
    TI_CC_SPIWriteReg(TI_CCxxx0_ADDR,     0x07); // //Device address.设备地址，用于数据报过滤
    TI_CC_SPIWriteReg(TI_CCxxx0_CHANNR,   0x00); // //Channel number.
    
    //TI_CC_SPIWriteReg(TI_CCxxx0_FSCTRL0,  0x00);    //
    TI_CC_SPIWriteReg(TI_CCxxx0_FSCTRL1,  0x0b); // //Freq synthesizer control.
    TI_CC_SPIWriteReg(TI_CCxxx0_FSCTRL0,  0x00); // //Freq synthesizer control.
    
    TI_CC_SPIWriteReg(TI_CCxxx0_FREQ2,    0x10); // //Freq control word, high byte//设置基础时钟频率为436MHZ，频率范围436MHz-463.8MHz 频道数目(0-139)
    TI_CC_SPIWriteReg(TI_CCxxx0_FREQ1,    0xA7); // //Freq control word, mid byte.//？？？？？
    TI_CC_SPIWriteReg(TI_CCxxx0_FREQ0,    0x62); // //Freq control word, low byte.//？？？？？
    
    TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG4,  0x2d); // //Modem configuration.
    TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG3,  0x3b); // //Modem configuration.设置传输速率
    TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG2,  0x73); // //Modem configuration.30/32 sync word bits，MSK调制方式
    TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG1,  0x22); // //Modem configuration.设置4位前导码，2 bit exponent of channel spacing
    TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG0,  0xF8); // //Modem configuration.设置199.951kHz channel spacing
    
    TI_CC_SPIWriteReg(TI_CCxxx0_DEVIATN,  0x00); // //Modem dev (when FSK mod en)
   
    TI_CC_SPIWriteReg(TI_CCxxx0_MCSM1 ,   0x3F); //??MainRadio Cntrl State Machine/设置当数据发送出去后进入RX模式，在数据接受到后保持在RX模式
                                                 //                               /If RSSI below threshold unless currently receiving a packet
    TI_CC_SPIWriteReg(TI_CCxxx0_MCSM0 ,   0x18); // //MainRadio Cntrl State Machine/当从IDLE进入RX和TX模式的时候自动校验
    
    TI_CC_SPIWriteReg(TI_CCxxx0_FOCCFG,   0x1d); // //Freq Offset Compens. Config/频偏补偿
    TI_CC_SPIWriteReg(TI_CCxxx0_BSCFG,    0x1C); //  //Bit synchronization config.
   
    TI_CC_SPIWriteReg(TI_CCxxx0_AGCCTRL2, 0xc7); // //AGC control.//由smartRF给出
    TI_CC_SPIWriteReg(TI_CCxxx0_AGCCTRL1, 0x00); // //AGC control.
    TI_CC_SPIWriteReg(TI_CCxxx0_AGCCTRL0, 0xb2); // //AGC control.
   
    TI_CC_SPIWriteReg(TI_CCxxx0_FREND1,   0xb6); // //Front end RX configuration.//由smartRF给出
    TI_CC_SPIWriteReg(TI_CCxxx0_FREND0,   0x10); // //Front end RX configuration.
    
    TI_CC_SPIWriteReg(TI_CCxxx0_FSCAL3,   0xEA); // //Frequency synthesizer cal.
    TI_CC_SPIWriteReg(TI_CCxxx0_FSCAL2,   0x0A); // //Frequency synthesizer cal.
    TI_CC_SPIWriteReg(TI_CCxxx0_FSCAL1,   0x00); // //Frequency synthesizer cal.
    TI_CC_SPIWriteReg(TI_CCxxx0_FSCAL0,   0x11); // //Frequency synthesizer cal.
    
    TI_CC_SPIWriteReg(TI_CCxxx0_FSTEST,   0x59); // //Frequency synthesizer cal.？？为什么在数据手册中为测试用，这里要写呢？
    TI_CC_SPIWriteReg(TI_CCxxx0_TEST2,    0x88); // //Various test settings.？？
    TI_CC_SPIWriteReg(TI_CCxxx0_TEST1,    0x31); // //Various test settings.？？
    TI_CC_SPIWriteReg(TI_CCxxx0_TEST0,    0x0B); // //Various test settings.？？
}


void TI_CC_SPIWriteReg(Uint16 addr, Uint16 value)
{
   GPIO_RSET(IODATA,0x10);    // /CS enable  (GPIO4)
    // Clear flag from first dummy byte                      
   while (!(MCBSP_xrdy(hMcbsp)));//wait for tramsmitter to become free
//	DELAY(1);  
   MCBSP_write16(hMcbsp,addr);     /* Send address*/
   while (!(MCBSP_xrdy(hMcbsp)));     // Wait for TX to finish 
   MCBSP_write16(hMcbsp,value);   
                 
   while (!(MCBSP_xrdy(hMcbsp)));                // Wait for end of data TX
   GPIO_RSET(IODATA,0x14);      // /CS disable
}

void TI_CC_SPIWriteBurstReg(Uint16 addr, Uint16 *buffer,Uint16 count)
{
    Uint16 i;

    GPIO_RSET(IODATA,0x10);       // /CS enable
  
    while (!(MCBSP_xrdy(hMcbsp)));
    MCBSP_write16(hMcbsp,addr | TI_CCxxx0_WRITE_BURST);// Send address
    while (!(MCBSP_xrdy(hMcbsp)));                // Wait for TX to finish
    for (i = 0; i < count; i++)
    { 
     MCBSP_write16(hMcbsp,buffer[i]);                // Send data
     while (!(MCBSP_xrdy(hMcbsp)));               // Wait for TX to finish 
    }
    GPIO_RSET(IODATA,0x14);       // /CS disable
}

void RFSendPacket(Uint16 *txBuffer, Uint16 size)
{
    TI_CC_SPIWriteBurstReg(TI_CCxxx0_TXFIFO, txBuffer, size); // Write TX data
    TI_CC_SPIStrobe(TI_CCxxx0_STX);         // Change state to TX, initiating
                                            // data transfer
}

Uint16 TI_CC_SPIReadReg(Uint16 addr)
{
  char x;
  Uint16 k;
  ioport Uint16 * ptr_to_ioport;
  ptr_to_ioport=( ioport Uint16 *) (0x2801);
  *ptr_to_ioport=0x1234;
   k=*ptr_to_ioport;
   GPIO_RSET(IODATA,0x10);        // /CS enable
   DELAY(50);

   while (!(MCBSP_xrdy(hMcbsp)));
   k=*ptr_to_ioport;
   MCBSP_write16(hMcbsp,addr | TI_CCxxx0_READ_SINGLE);
   k=*ptr_to_ioport;
  // MCBSP_write16(hMcbsp,addr | TI_CCxxx0_READ_SINGLE); 
  // Send address
  while (!(MCBSP_xrdy(hMcbsp)));                  // Wait for TX to finish
  k=*ptr_to_ioport;
  MCBSP_write16(hMcbsp, 0);     // Dummy write so we can read data
  k=*ptr_to_ioport;
  while (!(MCBSP_rrdy(hMcbsp)));
  x = MCBSP_read16(hMcbsp);              // Read data
  GPIO_RSET(IODATA,0x14);        // /CS disable

  return x;
}


void TI_CC_SPIReadBurstReg(Uint16 addr, Uint16 *buffer, Uint16 count)
{
  unsigned int i;
  
  GPIO_RSET(IODATA,0x10);        // /CS enable
  DELAY(50);

  while (!(MCBSP_xrdy(hMcbsp)));
  MCBSP_write16(hMcbsp,addr | TI_CCxxx0_READ_BURST); 
  while (!(MCBSP_xrdy(hMcbsp)));                 // Wait for TXBUF ready
   MCBSP_write16(hMcbsp, 0);            // Dummy write to read 1st data byte
  // Addr byte is now being TX'ed, with dummy byte to follow immediately after
   while (!(MCBSP_xrdy(hMcbsp)));                 // Wait for end of addr byte TX
   while (!(MCBSP_rrdy(hMcbsp)));                // Wait for end of 1st data byte TX
  // First data byte now in RXBUF
  for (i = 0; i < (count-1); i++)
  {
    MCBSP_write16(hMcbsp, 0);             //Initiate next data RX, meanwhile..
    buffer[i] = MCBSP_read16(hMcbsp);     // Store data from last data RX
    while (!(MCBSP_rrdy(hMcbsp)));               // Wait for end of data RX
  }
  buffer[count-1] = MCBSP_read16(hMcbsp);   // Store last RX byte in buffer
 GPIO_RSET(IODATA,0x14);        // /CS disable
}

Uint16 RFReceivePacket(Uint16 *rxBuffer, Uint16 *length)
{
  Uint16 status[2];
  Uint16 pktLen;

  if ((TI_CC_SPIReadStatus(TI_CCxxx0_RXBYTES) & TI_CCxxx0_NUM_RXBYTES))
  {
    pktLen = TI_CC_SPIReadReg(TI_CCxxx0_RXFIFO); // Read length byte

    if (pktLen <= *length)                  // If pktLen size <= rxBuffer
    {
      TI_CC_SPIReadBurstReg(TI_CCxxx0_RXFIFO, rxBuffer, pktLen); // Pull data
      *length = pktLen;                     // Return the actual size
      TI_CC_SPIReadBurstReg(TI_CCxxx0_RXFIFO, status, 2);
                                            // Read appended status bytes
      return (Uint16)(status[TI_CCxxx0_LQI_RX]&TI_CCxxx0_CRC_OK);
    }                                       // Return CRC_OK bit
    else
    {
      *length = pktLen;                     // Return the large size
      TI_CC_SPIStrobe(TI_CCxxx0_SFRX);      // Flush RXFIFO
      return 0;                             // Error
    }
  }
  else
      return 0;                             // Error
}


void TI_CC_SPIStrobe(Uint16 strobe)
{
  GPIO_RSET(IODATA,0x10);    // /CS enable  (GPIO4)
    // Clear flag from first dummy byte                      
   while (!(MCBSP_xrdy(hMcbsp)));//wait for tramsmitter to become free
   MCBSP_write16(hMcbsp,strobe);     /* Send address*/  
                 
   while (!(MCBSP_xrdy(hMcbsp)));                // Wait for end of data TX
   GPIO_RSET(IODATA,0x14);      //CS disable
}

Uint16 TI_CC_SPIReadStatus(Uint16 addr)
{
  Uint16 x;

  GPIO_RSET(IODATA,0x10);    // /CS enable  (GPIO4)                   
  while (!(MCBSP_xrdy(hMcbsp)))                    // Clear flag set during last write
  MCBSP_write16(hMcbsp, addr | TI_CCxxx0_READ_BURST);  // Send address
  while (!(MCBSP_xrdy(hMcbsp)))                          // Clear flag set during last write
  MCBSP_write16(hMcbsp, 0);                              // Dummy write so we can read data
  while (!(MCBSP_rrdy(hMcbsp)));                 // Wait for RX to finish
  x =  MCBSP_read16(hMcbsp);                              // Read data
  GPIO_RSET(IODATA,0x14);           // /CS disable
  return x;
}

void DELAY(Uint16 cycles)
{
   Uint16 i,j;
   i=cycles*150;
   for(j=0;j<i;j++);
}