rfcc.cpp

См. документацию.
00001 
00002 #include "rfcc.h"
00003 
00005 #define RFCC_WAIT_READY()   loop_until_bit_is_set(SPI_PORT, SPI_MISO)
00006 
00007 namespace rfcc
00008 {
00009     void init(settings_t *p)
00010     {
00011         rfspi::init();
00012 
00013         powerupReset();
00014 
00015         rfspi::writeReg( RFCC_FSCTRL0, p->FSCTRL0 );
00016         rfspi::writeReg( RFCC_FREQ2, p->FREQ2 );
00017         rfspi::writeReg( RFCC_FREQ1, p->FREQ1 );
00018         rfspi::writeReg( RFCC_FREQ0, p->FREQ0 );
00019         rfspi::writeReg( RFCC_MDMCFG4, p->MDMCFG4 );
00020         rfspi::writeReg( RFCC_MDMCFG3, p->MDMCFG3 );
00021         rfspi::writeReg( RFCC_MDMCFG2, p->MDMCFG2 );
00022         rfspi::writeReg( RFCC_MDMCFG1, p->MDMCFG1 );
00023         rfspi::writeReg( RFCC_MDMCFG0, p->MDMCFG0 );
00024         rfspi::writeReg( RFCC_CHANNR, p->CHANNR );
00025         rfspi::writeReg( RFCC_DEVIATN, p->DEVIATN );
00026         rfspi::writeReg( RFCC_FREND1, p->FREND1 );
00027         rfspi::writeReg( RFCC_FREND0, p->FREND0 );
00028         rfspi::writeReg( RFCC_MCSM2, p->MCSM2 );
00029         rfspi::writeReg( RFCC_MCSM1, p->MCSM1 );
00030         rfspi::writeReg( RFCC_MCSM0, p->MCSM0 );
00031         rfspi::writeReg( RFCC_FOCCFG, p->FOCCFG );
00032         rfspi::writeReg( RFCC_BSCFG, p->BSCFG );
00033         rfspi::writeReg( RFCC_AGCCTRL2, p->AGCCTRL2 );
00034         rfspi::writeReg( RFCC_AGCCTRL1, p->AGCCTRL1 );
00035         rfspi::writeReg( RFCC_AGCCTRL0, p->AGCCTRL0 );
00036         rfspi::writeReg( RFCC_FSCAL3, p->FSCAL3 );
00037         rfspi::writeReg( RFCC_FSCAL2, p->FSCAL2 );
00038         rfspi::writeReg( RFCC_FSCAL1, p->FSCAL1 );
00039         rfspi::writeReg( RFCC_FSCAL0, p->FSCAL0 );
00040         rfspi::writeReg( RFCC_FSTEST, p->FSTEST );
00041         rfspi::writeReg( RFCC_TEST2, p->TEST2 );
00042         rfspi::writeReg( RFCC_TEST1, p->TEST1 );
00043         rfspi::writeReg( RFCC_TEST0, p->TEST0 );
00044         rfspi::writeReg( RFCC_IOCFG2, p->IOCFG2 );
00045         rfspi::writeReg( RFCC_IOCFG0, p->IOCFG0 );
00046         rfspi::writeReg( RFCC_PKTCTRL1, p->PKTCTRL1 );
00047         rfspi::writeReg( RFCC_PKTCTRL0, p->PKTCTRL0 );
00048         rfspi::writeReg( RFCC_ADDR, p->ADDR );
00049         rfspi::writeReg( RFCC_PKTLEN, p->PKTLEN );
00050         rfspi::writeReg( RFCC_FIFOTHR, p->FIFOTHR );
00051     }
00052 
00053     void powerupReset()
00054     {
00055         SPI_CS_DISABLE();
00056         _delay_us(40);
00057         SPI_CS_ENABLE();
00058         _delay_us(40);
00059         SPI_CS_DISABLE();
00060         _delay_us(45);
00061         SPI_CS_ENABLE();
00062 
00063         RFCC_WAIT_READY();
00064         spi::transfer(RFCC_SRES);
00065         RFCC_WAIT_READY();
00066         SPI_CS_DISABLE();
00067         _delay_ms(45);
00068     }
00069 
00070     void sendPacket(char *txBuffer, char size)
00071     {
00072         rfspi::writeBurstReg(RFCC_TXFIFO, txBuffer, size);  // Write TX data
00073         rfspi::strobe(RFCC_STX);                            // Change state to TX, initiating
00074     }
00075 
00076     char receivePacket(char *rxBuffer, char *length)
00077     {
00078         char status[2];
00079         char pktLen;
00080             
00081         if ((rfspi::readStatus(RFCC_RXBYTES) & RFCC_NUM_RXBYTES))
00082         {
00083             
00084             pktLen = rfspi::readReg(RFCC_RXFIFO);   // Read length byte
00085             if (pktLen <= *length)                  // If pktLen size <= rxBuffer
00086             {
00087                 rfspi::readBurstReg(RFCC_RXFIFO, rxBuffer, pktLen); // Pull data
00088                 *length = pktLen;                   // Return the actual size
00089                 rfspi::readBurstReg(RFCC_RXFIFO, status, 2);
00090                 LQI  = status[1];
00091                 RSSI = status[0];                   // Read appended status bytes
00092                 return (char)(status[RFCC_LQI_RX]&RFCC_CRC_OK);
00093             }                                       // Return CRC_OK bit
00094             else
00095             {
00096                 *length = pktLen;                   // Return the large size
00097                 rfspi::strobe(RFCC_SFRX);           // Flush RXFIFO
00098                 return 0;                           // Error
00099             }
00100         }
00101         else
00102         {
00103             return 0;                               // Error
00104         }
00105     }
00106 
00107     namespace rfspi
00108     {
00109         void init()
00110         {
00111             spi::init();
00112         }
00113 
00114         void writeReg(char addr, char value)
00115         {
00116             SPI_CS_ENABLE();
00117             RFCC_WAIT_READY();
00118             spi::transfer(addr);    // Send address
00119             spi::transfer(value);   // Send data
00120             SPI_CS_DISABLE();
00121         }
00122 
00123         void writeBurstReg(char addr, char *buffer, char count)
00124         {
00125             char i;
00126 
00127             SPI_CS_ENABLE();
00128             RFCC_WAIT_READY();
00129             spi::transfer(addr | RFCC_WRITE_BURST); // Send address
00130             for (i = 0; i < count; i++)
00131                 spi::transfer(buffer[i]);           // Send data
00132             SPI_CS_DISABLE();
00133         }
00134 
00135         char readReg(char addr)
00136         {
00137             char x;
00138 
00139             SPI_CS_ENABLE();
00140             RFCC_WAIT_READY();
00141             spi::transfer(addr | RFCC_READ_SINGLE); //Send address
00142             x = spi::transfer();                    // Read data
00143             SPI_CS_DISABLE();
00144             return x;
00145         }
00146 
00147         void readBurstReg(char addr, char *buffer, char count)
00148         {
00149             char i;
00150 
00151             SPI_CS_ENABLE();
00152             RFCC_WAIT_READY();
00153             spi::transfer(addr | RFCC_READ_BURST);  // Send address
00154             for (i = 0; i < count; i++)
00155                 buffer[i] = spi::transfer();        // Read data
00156             SPI_CS_DISABLE();
00157         }
00158 
00159         char readStatus(char addr)
00160         {
00161             char x;
00162 
00163             SPI_CS_ENABLE();
00164             RFCC_WAIT_READY();
00165             spi::transfer(addr | RFCC_READ_BURST);  // Send address
00166             x = spi::transfer();                    // Read data
00167             SPI_CS_DISABLE();
00168             return x;
00169         }
00170 
00171         void strobe(char strobe_)
00172         {
00173             SPI_CS_ENABLE();
00174             RFCC_WAIT_READY();
00175             spi::transfer(strobe_); // Send strobe
00176             SPI_CS_DISABLE();
00177         }
00178     }; // namespace rfspi
00179 };

Документация по CC-2-CC. Последние изменения: Thu Feb 14 09:31:59 2008. Создано системой  doxygen 1.5.3