void SX1272FskRxCalibrate( void )
{
uint32_t startTick;
SX1272Write( REG_IMAGECAL, RF_IMAGECAL_AUTOIMAGECAL_OFF |
RF_IMAGECAL_IMAGECAL_START |
RF_IMAGECAL_TEMPTHRESHOLD_10 |
RF_IMAGECAL_TEMPMONITOR_OFF );
// Wait 8ms
startTick = GET_TICK_COUNT( );
while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 8 ) );
}
void SX1276LoRaReset( void )
{
SX1276SetReset( RADIO_RESET_ON );
// Wait 1ms
uint32_t startTick = GET_TICK_COUNT( );
while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 1 ) );
SX1276SetReset( RADIO_RESET_OFF );
// Wait 6ms
startTick = GET_TICK_COUNT( );
while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 6 ) );
}
int8_t SX1272FskGetRawTemp( void )
{
int8_t temp = 0;
uint8_t previousOpMode;
uint32_t startTick;
// Enable Temperature reading
SX1272Read( REG_IMAGECAL, &SX1272->RegImageCal );
SX1272->RegImageCal = ( SX1272->RegImageCal & RF_IMAGECAL_TEMPMONITOR_MASK ) | RF_IMAGECAL_TEMPMONITOR_ON;
SX1272Write( REG_IMAGECAL, SX1272->RegImageCal );
// save current Op Mode
SX1272Read( REG_OPMODE, &SX1272->RegOpMode );
previousOpMode = SX1272->RegOpMode;
// put device in FSK RxSynth
SX1272->RegOpMode = RF_OPMODE_SYNTHESIZER_RX;
SX1272Write( REG_OPMODE, SX1272->RegOpMode );
// Wait 1ms
startTick = GET_TICK_COUNT( );
while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 2 ) );
// Disable Temperature reading
SX1272Read( REG_IMAGECAL, &SX1272->RegImageCal );
SX1272->RegImageCal = ( SX1272->RegImageCal & RF_IMAGECAL_TEMPMONITOR_MASK ) | RF_IMAGECAL_TEMPMONITOR_OFF;
SX1272Write( REG_IMAGECAL, SX1272->RegImageCal );
// Read temperature
SX1272Read( REG_TEMP, &SX1272->RegTemp );
temp = SX1272->RegTemp & 0x7F;
if( ( SX1272->RegTemp & 0x80 ) == 0x80 )
{
temp *= -1;
}
// Reload previous Op Mode
SX1272Write( REG_OPMODE, previousOpMode );
return temp;
}
/*!
* \brief Process the LoRa modem Rx and Tx state machines depending on the
* SX1276 operating mode.
*
* \retval rfState Current RF state [RF_IDLE, RF_BUSY,
* RF_RX_DONE, RF_RX_TIMEOUT,
* RF_TX_DONE, RF_TX_TIMEOUT]
*/
uint32_t SX1276LoRaProcess( void )
{
uint32_t result = RF_BUSY;
switch( RFLRState )
{
case RFLR_STATE_IDLE:
break;
case RFLR_STATE_RX_INIT:
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
//RFLR_IRQFLAGS_RXDONE |
//RFLR_IRQFLAGS_PAYLOADCRCERROR |
RFLR_IRQFLAGS_VALIDHEADER |
RFLR_IRQFLAGS_TXDONE |
RFLR_IRQFLAGS_CADDONE |
//RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |
RFLR_IRQFLAGS_CADDETECTED;
SX1276Write( REG_LR_IRQFLAGSMASK, SX1276LR->RegIrqFlagsMask );
if( LoRaSettings.FreqHopOn == true )
{
SX1276LR->RegHopPeriod = LoRaSettings.HopPeriod;
SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
}
else
{
SX1276LR->RegHopPeriod = 255;
}
SX1276Write( REG_LR_HOPPERIOD, SX1276LR->RegHopPeriod );
// RxDone RxTimeout FhssChangeChannel CadDone
SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_00;
// CadDetected ModeReady
SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );
if( LoRaSettings.RxSingleOn == true ) // Rx single mode
{
SX1276LoRaSetOpMode( RFLR_OPMODE_RECEIVER_SINGLE );
}
else // Rx continuous mode
{
SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxBaseAddr;
SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
SX1276LoRaSetOpMode( RFLR_OPMODE_RECEIVER );
}
memset( RFBuffer, 0, ( size_t )RF_BUFFER_SIZE );
PacketTimeout = LoRaSettings.RxPacketTimeout;
RxTimeoutTimer = GET_TICK_COUNT( );
RFLRState = RFLR_STATE_RX_RUNNING;
break;
case RFLR_STATE_RX_RUNNING:
if( DIO0 == 1 ) // RxDone
{
RxTimeoutTimer = GET_TICK_COUNT( );
if( LoRaSettings.FreqHopOn == true )
{
SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
}
// Clear Irq
SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE );
RFLRState = RFLR_STATE_RX_DONE;
}
if( DIO2 == 1 ) // FHSS Changed Channel
{
RxTimeoutTimer = GET_TICK_COUNT( );
if( LoRaSettings.FreqHopOn == true )
{
SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
}
// Clear Irq
SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL );
// Debug
RxGain = SX1276LoRaReadRxGain( );
}
if( LoRaSettings.RxSingleOn == true ) // Rx single mode
{
if( ( GET_TICK_COUNT( ) - RxTimeoutTimer ) > PacketTimeout )
{
RFLRState = RFLR_STATE_RX_TIMEOUT;
}
}
break;
case RFLR_STATE_RX_DONE:
SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
if( ( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_PAYLOADCRCERROR ) == RFLR_IRQFLAGS_PAYLOADCRCERROR )
{
// Clear Irq
SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_PAYLOADCRCERROR );
if( LoRaSettings.RxSingleOn == true ) // Rx single mode
{
RFLRState = RFLR_STATE_RX_INIT;
}
else
{
RFLRState = RFLR_STATE_RX_RUNNING;
}
break;
}
{
uint8_t rxSnrEstimate;
SX1276Read( REG_LR_PKTSNRVALUE, &rxSnrEstimate );
if( rxSnrEstimate & 0x80 ) // The SNR sign bit is 1
{
// Invert and divide by 4
RxPacketSnrEstimate = ( ( ~rxSnrEstimate + 1 ) & 0xFF ) >> 2;
RxPacketSnrEstimate = -RxPacketSnrEstimate;
}
else
{
// Divide by 4
RxPacketSnrEstimate = ( rxSnrEstimate & 0xFF ) >> 2;
}
}
wxThread::ExitCode MyThread::Entry()
{
unsigned int st_time = GET_TICK_COUNT();
DatabaseDlg *dd = (DatabaseDlg *)m_pParent;
wxTreeItemId rootitem = dd->m_searchResult->GetRootItem();
if (!m_results.empty()) m_results.clear();
if (m_cats)
{
int catnum = m_cats->size();
int schtxtnum = m_schtxts.size();
for (int i = m_cur_cat; i < catnum; i++)
{
int itemnum = (*m_cats)[i].items.size();
for (int j = m_cur_item; j < itemnum; j++)
{
bool found = false;
for (int k = 0; k < schtxtnum; k++)
{
if (!m_schtxts[k].IsEmpty() && (*m_cats)[i].items[j]->desc.Find(m_schtxts[k]) != -1) found = true;
}
//if(found) m_results.push_back((*m_cats)[i].items[j]);
if(found)
{
//dd->SetEvtHandlerEnabled(false);
wxTreeItemId item = dd->m_searchResult->AppendItem(rootitem, (*m_cats)[i].items[j]->name + wxT(" (") + (*m_cats)[i].items[j]->cat_name + wxT(")"), 0);
DBItemInfo* item_data = new DBItemInfo( *((*m_cats)[i].items[j]) );
dd->m_searchResult->SetItemData(item, item_data);
//dd->SetEvtHandlerEnabled(true);
}
//wxUsleep(10);
m_progress++;
unsigned int rn_time = GET_TICK_COUNT();
if (rn_time - st_time > m_time_limit || TestDestroy())
{
wxCommandEvent evt(TestDestroy() ? wxEVT_MYTHREAD_COMPLETED: wxEVT_MYTHREAD_PAUSED, GetId());
MyThreadData *data = new MyThreadData;
data->m_cur_cat = i;
data->m_cur_item = j + 1;
data->m_progress = m_progress;
data->m_results = m_results;
evt.SetClientData(data);
wxPostEvent(m_pParent, evt);
if (m_gauge) m_gauge->SetValue(m_progress);
return 0;
}
}
m_cur_item = 0;
}
}
wxCommandEvent evt(wxEVT_MYTHREAD_COMPLETED, GetId());
MyThreadData *data = new MyThreadData;
data->m_cur_cat = m_cur_cat;
data->m_cur_item = m_cur_item;
data->m_progress = m_progress;
data->m_results = m_results;
evt.SetClientData(data);
wxPostEvent(m_pParent, evt);
return 0;
}
