xe1205driver.c

xe1205无线射频芯片驱动程序

/*******************************************************************
** File        : XE1205driver.c                                   **
********************************************************************
**                                                                **
** Version     : V 1.0                                            **
**                                                                **
** Written by   : Miguel Luis                                     **
**                                                                **
** Date        : 19-01-2004                                       **
**                                                                **
** Project     : API-1205                                         **
**                                                                **
********************************************************************
** Changes     : V 2.1 / MiL - 24-04-2004                         **
**                                                                **
**             : V 2.2 / MiL - 30-07-2004                         **
**               - Removed workaround for RX/TX switch FIFO clear **
**                 (chip correction)                              **
**                                                                **
** Changes     : V 2.3 / CRo - 06-06-2006                         **
**               - TempRFState added in ReceiveRfFrame            **
**                                                                **
** Changes     : V 2.4 / CRo - 09-01-2007                         **
**               - No change                                      **
**                                                                **
**                                                                **
********************************************************************
** Description : XE1205 transceiver drivers Implementation for the**
**               XE8000 family products (1205 buffered mode)      **
*******************************************************************/

/*******************************************************************
** Include files                                                  **
*******************************************************************/
#include "XE1205Driver.h"

/*******************************************************************
** Global variables                                               **
*******************************************************************/
static   _U8 RFState = RF_STOP;     // RF state machine
static   _U8 *pRFFrame;             // Pointer to the RF frame
static   _U8 RFFramePos;            // RF frame current position
static   _U8 RFFrameSize;           // RF frame size
static  _U16 ByteCounter = 0;       // RF frame byte counter
static   _U8 PreMode = RF_SLEEP;    // Previous chip operating mode
volatile _U8 EnableSyncByte = true; // Enables/disables the synchronization byte reception/transmission
static   _U8 SyncByte;              // RF synchronization byte counter
static   _U8 PatternSize = 4;       // Size of pattern detection
static   _U8 StartByte[4];          // Pattern detection values
static  _U32 RFFrameTimeOut = RF_FRAME_TIMEOUT(1200); // Reception counter value (full frame timeout generation)

_U16 RegistersCfg[] = { // 1205 configuration registers values
    DEF_MCPARAM1 | RF_MC1_SLEEP | RF_MC1_MODE_CHIP | RF_MC1_BUFFERED_MODE_ON | RF_MC1_DATA_UNIDIR_OFF | RF_MC1_BAND_915 | RF_MC1_FREQ_DEV_MSB_1,
    DEF_MCPARAM2 | RF_MC2_FDEV_200,
    DEF_MCPARAM3 | RF_MC3_KONNEX_OFF | RF_MC3_BAUDRATE_4800,
    DEF_MCPARAM4,
    DEF_MCPARAM5,

    DEF_IRQPARAM1 | RF_IRQ0_RX_IRQ_OFF | RF_IRQ1_RX_IRQ_OFF | RF_IRQ1_TX_IRQ_TX_STOPPED,
    DEF_IRQPARAM2 | RF_IRQ2_START_FILL_PATTERN_DET | RF_IRQ2_START_FILL_FIFO_STOP | RF_IRQ2_START_TX_FIFO_FULL | RF_IRQ2_RSSI_IRQ_OFF | RF_IRQ2_RSSI_THRES_VTHR1,

    DEF_TXPARAM1 | RF_TX1_POWER_0 | RF_TX1_MODUL_ON | RF_TX1_FILTER_OFF | RF_TX1_FIX_BSYNC_NORMAL | RF_TX1_SELECT_DEMOD_1,

    DEF_RXPARAM1 | RF_RX1_BITSYNC_ON | RF_RX1_BW_200 | RF_RX1_BW_MAX_ON | RF_RX1_REG_BW_START_UP | RF_RX1_BOSST_FILTER_START_UP,
    DEF_RXPARAM2 | RF_RX2_RSSI_OFF | RF_RX2_LOW_RANGE | RF_RX2_FEI_OFF | RF_RX2_AFC_STOP | RF_RX2_AFC_CORRECTION_ON,
    DEF_RXPARAM3 | RF_RX3_IQAMP_OFF | RF_RX3_RMODE_MODE_A | RF_RX3_PATTERN_ON | RF_RX3_P_SIZE_32 | RF_RX3_P_TOL_0,

    DEF_RXPARAM6 | 0x69, // Pattern 1
    DEF_RXPARAM7 | 0x81, // Pattern 2
    DEF_RXPARAM8 | 0x7E, // Pattern 3
    DEF_RXPARAM9 | 0x96, // Pattern 4

    DEF_OSCPARAM1 | RF_OSC1_OSC_INT | RF_OSC1_CLKOUT_OFF | RF_OSC1_CLK_FREQ_1_22_MHZ,
    DEF_OSCPARAM2 | RF_OSC2_RES_X_OSC_3800
};

/*******************************************************************
** Configuration functions                                        **
*******************************************************************/

/*******************************************************************
** InitRFChip : This routine initializes the RFChip registers     **
**              Using Pre Initialized variables                   **
********************************************************************
** In  : -                                                        **
** Out : -                                                        **
*******************************************************************/
void InitRFChip (void){
        _U16 i;
    // Initializes XE1205
    SPIInit();
    set_bit(PORTO, (SCK + NSS_DATA + NSS_CONFIG + MOSI));
    set_bit(PORTP, (SCK + NSS_DATA + NSS_CONFIG + MOSI));

    for(i = 0; (i + 2) <= REG_OSCPARAM2; i++){
        if(i < REG_RXPARAM4){
            WriteRegister(i, RegistersCfg[i]);
        }
        else{
            WriteRegister(i + 2, RegistersCfg[i]);
        }
    }

    PatternSize = ((RegistersCfg[REG_RXPARAM3] >> 2) & 0x03) + 1;
    for(i = 0; i < PatternSize; i++){
        StartByte[i] = RegistersCfg[REG_RXPARAM6 - 2 + i];
    }

    if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_1200){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(1200);
    }
    else if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_2400){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(2400);
    }
    else if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_4800){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(4800);
    }
    else if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_9600){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(9600);
    }
    else if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_19200){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(19200);
    }
    else if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_38400){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(38400);
    }
    else if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_76800){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(76800);
    }
    else if(RegistersCfg[REG_MCPARAM3] == RF_MC3_BAUDRATE_153600){
        RFFrameTimeOut = RF_FRAME_TIMEOUT(153600);
    }
    else {
        RFFrameTimeOut = RF_FRAME_TIMEOUT(1200);
    }

    SetRFMode(RF_SLEEP);
#ifdef __DEBUG__
    WriteRegister(25, 0x10); // Debug copy the modulator input to the pin DATA
#endif
}

/*******************************************************************
** SetMode : Sets the XE1205 operating mode                       **
********************************************************************
** In  : mode                                                     **
** Out : -                                                        **
*******************************************************************/
void SetRFMode(_U8 mode){
    if(mode != PreMode){
        if((mode == RF_TRANSMITTER) && (PreMode == RF_SLEEP)){
            PreMode = RF_TRANSMITTER;
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_STANDBY);
            // wait TS_OS
            Wait(TS_OS);
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_TRANSMITTER);
            // wait TS_STR
            Wait(TS_STR);
        }
        else if((mode == RF_TRANSMITTER) && (PreMode == RF_RECEIVER)){
            PreMode = RF_TRANSMITTER;
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_TRANSMITTER);
            // wait TS_TR
            Wait(TS_TR);
        }
        else if((mode == RF_RECEIVER) && (PreMode == RF_SLEEP)){
            PreMode = RF_RECEIVER;
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_STANDBY);
            // wait TS_OS
            Wait(TS_OS);
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_RECEIVER);
            // wait TS_SRE
            Wait(TS_SRE);
        }
        else if((mode == RF_RECEIVER) && (PreMode == RF_TRANSMITTER)){
            PreMode = RF_RECEIVER;
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_RECEIVER);
            // wait TS_RE
            Wait(TS_RE);
        }
        else if(mode == RF_SLEEP){
            PreMode = RF_SLEEP;
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_SLEEP);
        }
        else{
            PreMode = RF_SLEEP;
            WriteRegister(REG_MCPARAM1, (RegistersCfg[REG_MCPARAM1] & 0x3F) | RF_SLEEP);
        }
    }
}

/*******************************************************************
** WriteRegister : Writes the register value at the given address **
**                  on the XE1205                                 **
********************************************************************
** In  : address, value                                           **
** Out : -                                                        **
*******************************************************************/
void WriteRegister(_U8 address, _U16 value){
    SPIInit();

    address = ((address << 1) & 0x3F) | 0x01;
    SPINssData(1);
    SPINssConfig(0);
    SpiInOut(address);
    SpiInOut(value);
    SPINssConfig(1);
}

/*******************************************************************
** ReadRegister : Reads the register value at the given address on**
**                the XE1205                                      **
********************************************************************
** In  : address                                                  **
** Out : value                                                    **
*******************************************************************/
_U16 ReadRegister(_U8 address){
    _U8 value = 0;

    SPIInit();
    SPINssData(1);
    address = ((address << 1) & 0x7F) | 0x41;
    SPINssConfig(0);
    SpiInOut(address);
    value = SpiInOut(0);
    SPINssConfig(1);

    return value;
}

/*******************************************************************
** Communication functions                                        **
*******************************************************************/

/*******************************************************************
** SendRfFrame : Sends a RF frame                                 **
********************************************************************
** In  : *buffer, size                                            **
** Out : *pReturnCode                                             **
*******************************************************************/
void SendRfFrame(_U8 *buffer, _U8 size, _U8 *pReturnCode){
    if(size > RF_BUFFER_SIZE_MAX){
        RFState |= RF_STOP;
        *pReturnCode = ERROR;
        return;
    }
    SetRFMode(RF_TRANSMITTER);

    RFState |= RF_BUSY;
    RFState &= ~RF_STOP;
    RFFrameSize = size;
    pRFFrame = buffer;

    // Select TX IRQ_1 source to FIFO full
    WriteRegister(REG_IRQPARAM1, RF_IRQ1_TX_IRQ_TX_FIFO_FULL);

    for(ByteCounter = 0; ByteCounter < 4; ){
        if(!(RegPAIn & IRQ_1)){ // If FIFO not full send a new byte
            SendByte(0xAA);
            ByteCounter++;
        }
        else{                   // If FIFO is full, waits until it is no more full
            do{
            }while((RegPAIn & IRQ_1));
        }
    }
    for(ByteCounter = 0; ByteCounter < PatternSize; ){
        if(!(RegPAIn & IRQ_1)){ // If FIFO not full send a new byte
            SendByte(StartByte[ByteCounter++]);
        }
        else{                   // If FIFO is full, waits until it is no more full
            do{
            }while((RegPAIn & IRQ_1));
        }
    }

    do{
    }while((RegPAIn & IRQ_1)); // In case the FIFO is full, waits until it is no more full

    SendByte(InvertByte(RFFrameSize));