📄 xe1205driver.c
字号:
}
else{
if(EnableSyncByte){
SyncByte++;
}
RegRfifTx = pRFFrame[RFFramePos++];
}
asm("halt");
}
while(((RegRfifTxSta & 0x01) == 0));
RFState |= RF_STOP;
RFState &= ~RF_TX_DONE;
*pReturnCode = OK;
} // void SendRfFrame(_U8 *buffer, _U8 size, _U8 *pReturnCode)
/*******************************************************************
** ReceiveRfFrame : Receives a RF frame **
********************************************************************
** In : - **
** Out : *buffer, size, *pReturnCode **
*******************************************************************/
void ReceiveRfFrame(_U8 *buffer, _U8 *size, _U8 *pReturnCode){
*pReturnCode = RX_RUNNING;
if(RFState & RF_STOP){
pRFFrame = buffer;
RFFramePos = 0;
SetRFMode(RF_RECEIVER);
EnableTimeOut(true);
RFState |= RF_BUSY;
RFState &= ~RF_STOP;
RFState &= ~RF_TIMEOUT;
return;
}
else if(RFState & RF_RX_DONE){
*size = RFFrameSize;
*pReturnCode = OK;
RFState |= RF_STOP;
EnableTimeOut(false);
RFState &= ~RF_RX_DONE;
return;
}
else if(RFState & RF_ERROR){
RFState |= RF_STOP;
RFState &= ~RF_ERROR;
*pReturnCode = ERROR;
return;
}
else if(RFState & RF_TIMEOUT){
RFState |= RF_STOP;
RFState &= ~RF_TIMEOUT;
EnableTimeOut(false);
*pReturnCode = RX_TIMEOUT;
return;
}
} // void ReceiveRfFrame(_U8 *buffer, _U8 size, _U8 *pReturnCode)
/*******************************************************************
** Transceiver specific functions **
*******************************************************************/
/*******************************************************************
** AutoFreqControl : Calibrates the receiver LO frequency to the **
** transmitter LO frequency **
********************************************************************
** In : - **
** Out : *pReturnCode **
*******************************************************************/
void AutoFreqControl(_U8 *pReturnCode){
_S16 Result = 0;
_S16 LoRegisterValue = 0;
_U8 Done = false;
_U8 TimeOut = 20;
// Initializes the FEI to enable his reading
InitFei();
do{
// FEI and LO register reading
Result = ReadFei();
LoRegisterValue = ReadLO();
LoRegisterValue = LoRegisterValue - Result;
WriteLO(LoRegisterValue);
TimeOut --;
if((Result >= -1) && (Result <= 1)){
Done = true;
}
if(TimeOut == 0){
*pReturnCode = RX_TIMEOUT;
return;
}
}while(!Done);
*pReturnCode = OK;
}
/*******************************************************************
** ReadLO : Reads the LO frequency value from XE1205 **
********************************************************************
** In : - **
** Out : value **
*******************************************************************/
_U16 ReadLO(void){
_U16 value;
value = ReadRegister(REG_MCPARAM4) << 8;
value |= ReadRegister(REG_MCPARAM5) & 0xFF;
return value;
}
/*******************************************************************
** WriteLO : Writes the LO frequency value on the XE1205 **
********************************************************************
** In : value **
** Out : - **
*******************************************************************/
void WriteLO(_U16 value){
WriteRegister(REG_MCPARAM4, (_U8) (value >> 8));
WriteRegister(REG_MCPARAM5, (_U8) value);
}
/*******************************************************************
** InitFei : Initializes the XE1205 to enable the FEI reading **
********************************************************************
** In : - **
** Out : - **
*******************************************************************/
void InitFei(void){
_U8 BitRate = 0;
BitRate = ReadRegister(REG_MCPARAM3);
Wait(TS_FEI(BitRate));
}
/*******************************************************************
** ReadFei : Reads the FEI value from XE1205 **
********************************************************************
** In : - **
** Out : value **
*******************************************************************/
_S16 ReadFei(void){
_S16 value;
value = ReadRegister(REG_RXPARAM5); // Reads the FEI result LSB first (For trig)
value = value | (ReadRegister(REG_RXPARAM4) << 8); // Reads the FEI result MSB
return value;
}
/*******************************************************************
** InitRssi : Initializes the XE1205 to enable the RSSI reading **
********************************************************************
** In : - **
** Out : - **
*******************************************************************/
void InitRssi(void){
Wait(TS_RSSI);
}
/*******************************************************************
** ReadRssi : Reads the Rssi value from XE1205 **
********************************************************************
** In : - **
** Out : value **
*******************************************************************/
_U16 ReadRssi(void){
_U16 value;
value = ReadRegister(REG_RXPARAM2) & 0x03; // Reads the RSSI result
return value;
}
/*******************************************************************
** Utility functions **
*******************************************************************/
/*******************************************************************
** Wait : This routine uses the counter A&B to create a delay **
** using the RC ck source **
********************************************************************
** In : cntVal **
** Out : - **
*******************************************************************/
void Wait(_U16 cntVal){
RegCntOn &= 0xFC; // Disables counter A&B
RegEvnEn &= 0x7F; // Disables events from the counter A&B
RegEvn = 0x80; // Clears the event from the CntA on the event register
RegCntCtrlCk = (RegCntCtrlCk & 0xFC) | 0x01; // Selects RC frequency as clock source for counter A&B
RegCntConfig1 |= 0x34; // A&B counters count up, counter A&B are in cascade mode
RegCntA = (_U8)(cntVal); // LSB of cntVal
RegCntB = (_U8)(cntVal >> 8); // MSB of cntVal
RegEvnEn |= 0x80; // Enables events from CntA
RegEvn |= 0x80; // Clears the event from the CntA on the event register
asm("clrb %stat, #0"); // Clears the event on the CoolRISC status register
RegCntOn |= 0x03; // Enables counter A&B
do{
asm("halt");
}while ((RegEvn & 0x80) == 0x00); // Waits the event from counter A
RegCntOn &= 0xFE; // Disables counter A
RegEvnEn &= 0x7F; // Disables events from the counter A
RegEvn |= 0x80; // Clears the event from the CntA on the event register
asm("clrb %stat, #0"); // Clears the event on the CoolRISC status register
} // void Wait(_U16 cntVal)
/*******************************************************************
** EnableTimeOut : Enables/Disables the RF frame timeout **
********************************************************************
** In : enable **
** Out : - **
*******************************************************************/
void EnableTimeOut(_U8 enable){
RegCntCtrlCk = (RegCntCtrlCk & 0xFC) | 0x03; // Selects 128 Hz frequency as clock source for counter A&B
RegCntConfig1 |= 0x34; // A&B counters count up, counter A&B are in cascade mode
RegCntA = (_U8)RFFrameTimeOut; // LSB of RFFrameTimeOut
RegCntB = (_U8)(RFFrameTimeOut >> 8); // MSB of RFFrameTimeOut
if(enable){
RegIrqEnHig |= 0x10; // Enables IRQ for the counter A&B
RegCntOn |= 0x03; // Enables counter A&B
}
else{
RegIrqEnHig &= ~0x10; // Disables IRQ for the counter A&B
RegCntOn &= ~0x03; // Disables counter A&B
}
} // void EnableTimeOut(_U8 enable)
/*******************************************************************
** InvertByte : Inverts a byte. MSB -> LSB, LSB -> MSB **
********************************************************************
** In : b **
** Out : b **
*******************************************************************/
_U8 InvertByte(_U8 b){
asm(" move %r0, #0x08");
asm("LoopInvertByte:");
asm(" shl %r3");
asm(" shrc %r2");
asm(" dec %r0");
asm(" jzc LoopInvertByte");
} // _U8 InvertByte(_U8 b)
/*******************************************************************
** SpiInOut : Sends and receives a byte from the SPI bus **
********************************************************************
** In : outputByte **
** Out : inputByte **
*******************************************************************/
_U8 SpiInOut (_U8 outputByte){
_U8 bitCounter;
_U8 inputByte = 0;
SPIClock(0);
for(bitCounter = 0x80; bitCounter != 0x00; bitCounter >>= 1){
if (outputByte & bitCounter){
SPIMosi(1);
}
else{
SPIMosi(0);
}
SPIClock(1);
if (SPIMisoTest()){
inputByte |= bitCounter;
}
SPIClock(0);
} // for(BitCounter = 0x80; BitCounter != 0x00; BitCounter >>= 1)
SPIMosi(0);
return inputByte;
} // _U8 SpiInOut (_U8 outputByte)
/*******************************************************************
** BitJockey interrupt handlers **
*******************************************************************/
/*******************************************************************
** Handle_Irq_RfifRx : Handles the interruption from the RF **
** Interface Rx bit **
********************************************************************
** In : - **
** Out : - **
*******************************************************************/
void Handle_Irq_RfifRx(void){
_U8 dummy;
if(RFState & RF_BUSY){
RFState |= RF_BUSY;
if(RegRfifCmd3 & RFIF_RX_IRQ_START){
RFFramePos = 0;
RFFrameSize = 2;
SyncByte = 0;
RegRfifCmd3 = RFIF_RX_IRQ_EN_NEW | RFIF_RX_IRQ_START | RFIF_EN_RX; // Interrupts are generated every byte
}
else if(RegRfifCmd3 & RFIF_RX_IRQ_NEW){
RegRfifCmd3 |= RFIF_RX_IRQ_NEW;
if(RFFramePos < RFFrameSize + 1){
if(RFFramePos == 0){
RFFrameSize = RegRfifRx;
}
else{
if(SyncByte == SYNC_BYTE_FREQ){
if(EnableSyncByte){
SyncByte = 0;
dummy = RegRfifRx;
RFFramePos--;
}
}
else{
pRFFrame[RFFramePos-1] = RegRfifRx;
if(EnableSyncByte){
SyncByte++;
}
}
}
RFFramePos++;
}
else{
RFState |= RF_RX_DONE;
RFState &= ~RF_BUSY;
}
}
if(RFFrameSize >= RF_BUFFER_SIZE_MAX){
RFState |= RF_ERROR;
RFState &= ~RF_BUSY;
}
}
} //End Handle_Irq_RfifRx
/*******************************************************************
** Handle_Irq_RfifTx : Handles the interruption from the Rf **
** Interface Tx bit **
********************************************************************
** In : - **
** Out : - **
*******************************************************************/
void Handle_Irq_RfifTx (void){
} //End Handle_Irq_RfifTx
/*******************************************************************
** Handle_Irq_CntA : Handles the interruption from the Counter A **
********************************************************************
** In : - **
** Out : - **
*******************************************************************/
void Handle_Irq_CntA (void){
RFState |= RF_TIMEOUT;
RFState &= ~RF_BUSY;
} //End Handle_Irq_CntA
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -