void start_continuous_mode(void)
{
//4、BitSyncOn
//5、continuous mode
//6、RX
u8 RegDioMapping[2];
u8 temp;
SX1276FskSetOpMode(RF_OPMODE_STANDBY);
hal_DIOx_ITConfig(all,DISABLE);
RegDioMapping[0] = RF_DIOMAPPING1_DIO0_11 | RF_DIOMAPPING1_DIO1_00 | RF_DIOMAPPING1_DIO2_11 | RF_DIOMAPPING1_DIO3_10;
RegDioMapping[1] = RF_DIOMAPPING2_DIO4_00 | RF_DIOMAPPING2_DIO5_11 | RF_DIOMAPPING2_MAP_PREAMBLEDETECT;
SX1276WriteBuffer( REG_DIOMAPPING1, RegDioMapping, 2 );
SX1276Read(REG_OOKPEAK, &temp);
temp |= (0x20);
SX1276Write(REG_OOKPEAK, temp);
SX1276Read(REG_PACKETCONFIG2, &temp);
temp &= (~0x40);
SX1276Write(REG_PACKETCONFIG2, temp);
SX1276FskSetOpMode(RF_OPMODE_RECEIVER);
}
void SX1276LoRaSetDefaults( void )
{
//See app note
if (LoRaSettings.SignalBw<9) //mensi nez 500
{
SX1276Read( 0x31, &SX1276LR.RegTestReserved31 );
// Sets IF frequency selection manual
SX1276LR.RegTestReserved31 &= 0x7F; // pro pasmo krome 5000 khz musime vycistiti bit 7
SX1276LR.RegTestReserved31 &=~ 0x80; //7 bit vznulovat
SX1276Write( 0x31, SX1276LR.RegTestReserved31 );
}else
{
SX1276Read( 0x31, &SX1276LR.RegTestReserved31 );
// Sets IF frequency selection manual
SX1276LR.RegTestReserved31 &= 0x7F; // pro pasmo krome 5000 khz musime vycistiti bit 7
SX1276LR.RegTestReserved31 |= 0x80; //7 bit set
SX1276Write( 0x31, SX1276LR.RegTestReserved31 );
SX1276Write( 0x36, 0x2); //See Erata
SX1276Write( 0x3a, 0x64); //See Erata
}
if(LoRaSettings.SignalBw==0) SX1276Write( 0x2F, 0x48 );
if((LoRaSettings.SignalBw>=0)&&(LoRaSettings.SignalBw<=5)) SX1276Write( 0x2F, 0x44 );
if((LoRaSettings.SignalBw>=6)&&(LoRaSettings.SignalBw<=8)) SX1276Write( 0x2F, 0x40 );
// SX1276Write( 0x2F, 0x40 );
SX1276Read( 0x30, &SX1276LR.RegTestReserved31 );
SX1276LR.RegTestReserved31&=0xFE;
SX1276Write( 0x30, SX1276LR.RegTestReserved31 );
}
void SX1276LoRaInit( void )
{
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LoRaSetDefaults( );
SX1276ReadBuffer( 0x1,&SX1276LR, 0x70 - 1 );
SX1276Read( REG_LR_VERSION, &SX1276LR.RegVersion );
// set the RF settings
SX1276LoRaSetRFFrequency( LoRaSettings.RFFrequency,&SX1276LR );
SX1276LoRaSetRFPower_2( LoRaSettings.Power,&SX1276LR );
SX1276LoRaSetSpreadingFactor( LoRaSettings.SpreadingFactor,&SX1276LR ); // SF6 only operates in implicit header mode.
SX1276LoRaSetErrorCoding( LoRaSettings.ErrorCoding,&SX1276LR );
SX1276LoRaSetPacketCrcOn( LoRaSettings.CrcOn,&SX1276LR );
SX1276LoRaSetSignalBandwidth( LoRaSettings.SignalBw,&SX1276LR );
SX1276LoRaSetImplicitHeaderOn( LoRaSettings.ImplicitHeaderOn,&SX1276LR );
SX1276LoRaSetSymbTimeout( 0x3FF,&SX1276LR ); //Maximum - casove okno pro hledani preamble v single rezimu
SX1276LoRaSetPayloadLength( LoRaSettings.PayloadLength,&SX1276LR ); //
// SX1276LoRaSetLowDatarateOptimize( true,&SX1276LR ); //dela problemy - u delsiho paketu je rozsypany caj
/*AGC AUTO*/
SX1276Read( REG_LR_MODEMCONFIG3,&SX1276LR.RegModemConfig3 );
SX1276LR.RegModemConfig3|=0x4;
SX1276Write( REG_LR_MODEMCONFIG3,SX1276LR.RegModemConfig3 );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
}
void SX1276LoRaSetOpMode( uint8_t opMode )
{
static uint8_t opModePrev = RFLR_OPMODE_STANDBY;
bool antennaSwitchTxOn = false;
opModePrev = SX1276LR.RegOpMode & ~RFLR_OPMODE_MASK;
if( opMode == RFLR_OPMODE_TRANSMITTER )
{
antennaSwitchTxOn = true;
}
else
{
antennaSwitchTxOn = false;
}
//RXTX( antennaSwitchTxOn ); // Antenna switch control
SX1276LR.RegOpMode = ( SX1276LR.RegOpMode & RFLR_OPMODE_MASK ) | opMode;
SX1276Read( REG_LR_OPMODE, SX1276LR.RegOpMode );
SX1276LR.RegOpMode = ( SX1276LR.RegOpMode & RFLR_OPMODE_MASK ) | opMode;
SX1276Write( REG_LR_OPMODE, SX1276LR.RegOpMode );
}
void SX1276Fsk_recrive_Packet(void)
{
SX1276FskSetOpMode( RF_OPMODE_STANDBY );
hal_DIOx_ITConfig(all,DISABLE);
SX1276->RegDioMapping1 = packet_DIO0_RxpayloadReady | packet_DIO1_fifoLevel | packet_DIO2_SyncAddress | packet_DIO3_fifoEmpty;
// LowBat, Data
SX1276->RegDioMapping2 = packet_DIO4_Rssi_PreambleDetect | packet_DIO5_Data | RF_DIOMAPPING2_MAP_PREAMBLEDETECT;
SX1276WriteBuffer( REG_DIOMAPPING1, &SX1276->RegDioMapping1, 2 );
SX1276->RegFifoThresh = RF_FIFOTHRESH_TXSTARTCONDITION_FIFONOTEMPTY | RX_FIFO_THRESHOLD; // 24 bytes of data
SX1276Write( REG_FIFOTHRESH, SX1276->RegFifoThresh );
EXTI_ClearITPendingBit(DIO4_IRQ);
hal_DIOx_ITConfig(0,ENABLE);
hal_DIOx_ITConfig(1,ENABLE);
hal_DIOx_ITConfig(2,ENABLE);
hal_DIOx_ITConfig(4,ENABLE);
g_fsk.states = RF_STATE_RX_INIT;
g_fsk.index = 0;
//process_post(&hal_RF_process, PROCESS_EVENT_MSG, (void *)(&g_fsk.states));
SX1276FskSetOpMode( RF_OPMODE_RECEIVER );
}
void SX1276FskSetOpMode( uint8_t opMode )
{
static uint8_t opModePrev = RF_OPMODE_STANDBY;
static bool antennaSwitchTxOnPrev = true;
bool antennaSwitchTxOn = false;
opModePrev = SX1276.RegOpMode & ~RF_OPMODE_MASK;
if( opMode != opModePrev )
{
if( opMode == RF_OPMODE_TRANSMITTER )
{
antennaSwitchTxOn = true;
}
else
{
antennaSwitchTxOn = false;
}
if( antennaSwitchTxOn != antennaSwitchTxOnPrev )
{
antennaSwitchTxOnPrev = antennaSwitchTxOn;
RXTX( antennaSwitchTxOn ); // Antenna switch control
}
SX1276.RegOpMode = ( SX1276.RegOpMode & RF_OPMODE_MASK ) | opMode;
SX1276Write( REG_OPMODE, SX1276.RegOpMode );
}
}
void SX1276LoRaSetOpMode( uint8_t opMode )
{
static uint8_t opModePrev = RFLR_OPMODE_STANDBY;
static BOOL antennaSwitchTxOnPrev = TRUE;
BOOL antennaSwitchTxOn = FALSE;
opModePrev = SX1276LR->RegOpMode & ~RFLR_OPMODE_MASK;
if( opMode != opModePrev )
{
if( opMode == RFLR_OPMODE_TRANSMITTER ) // Tx mode
{
antennaSwitchTxOn = TRUE;
}
else
{
antennaSwitchTxOn = FALSE;
}
if( antennaSwitchTxOn != antennaSwitchTxOnPrev )
{
antennaSwitchTxOnPrev = antennaSwitchTxOn;
RXTX( antennaSwitchTxOn ); // Antenna switch control
}
SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_MASK ) | opMode;
SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
}
}
/*****************************************************************************
Prototype : SX1276SetLoRaOn
Description : none
Input : bool enable
Output : None
Return Value :
Date : 2014/3/15
Author : Barry
*****************************************************************************/
void SX1276SetLoRaOn( bool enable )
{
/* if current state is the same of wanted state,return */
if( LoRaOnState == enable )
{
return;
}
LoRaOnState = enable;
LoRaOn = enable;
if( LoRaOn == true )
{
#if defined(SX1276_LORA)
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
/* set to lora mode */
SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
g_GDOx_map_conf.GDO0Config = DIO0_RxDone;
g_GDOx_map_conf.GDO1Config = DIO1_RxTimeout;
g_GDOx_map_conf.GDO2Config = DIO2_FhssCC;
g_GDOx_map_conf.GDO3Config = DIO3_CadDone;
g_GDOx_map_conf.GDO4Config = DIO4_CadDetected;
g_GDOx_map_conf.GDO5Config = DIO5_ModeReady;
config_GDOx_Map(g_GDOx_map_conf);
SX1276ReadBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );
#endif
}
else
{
#if defined(SX1276_FSK)
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_OFF;
SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
SX1276ReadBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
#endif
}
}
void SX1276SetLoRaOFF(void)
{
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LR.RegOpMode = ( SX1276LR.RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_OFF;
SX1276Write( REG_LR_OPMODE, SX1276LR.RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
// SX1276ReadBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
}
void SX1276SetLoRaOn( bool enable )
{
if( LoRaOnState == enable )
{
return;
}
LoRaOnState = enable;
LoRaOn = enable;
if( LoRaOn == true )
{
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
// 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 );
SX1276ReadBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );
}
else
{
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_OFF;
SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
SX1276ReadBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
}
}
void SX1276_FSK_init(void)
{
#if defined(SX1276_FSK)
SX1276 = ( tSX1276* )SX1276Regs;
SX1276Reset( );
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_OFF;
SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
SX1276ReadBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
#endif
}
void SX1276_lora_init(void)
{
SX1276LR = ( tSX1276LR* )SX1276Regs;
SX1276Reset( );
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
/* set to lora mode */
SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
g_GDOx_map_conf.GDO0Config = DIO0_RxDone;
g_GDOx_map_conf.GDO1Config = DIO1_RxTimeout;
g_GDOx_map_conf.GDO2Config = DIO2_FhssCC;
g_GDOx_map_conf.GDO3Config = DIO3_CadDone;
g_GDOx_map_conf.GDO4Config = DIO4_CadDetected;
g_GDOx_map_conf.GDO5Config = DIO5_ModeReady;
config_GDOx_Map(g_GDOx_map_conf);
SX1276ReadBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );
}
void SX1276SetLoRaOn(void)
{
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LR.RegOpMode = ( SX1276LR.RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
SX1276LR.RegOpMode&=~0x8;//-0x08 - HF
SX1276Write( REG_LR_OPMODE, SX1276LR.RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
// RxDone RxTimeout FhssChangeChannel CadDone
SX1276LR.RegDioMapping1 =
RFLR_DIOMAPPING1_DIO0_00 |
RFLR_DIOMAPPING1_DIO0_01|
RFLR_DIOMAPPING1_DIO2_00 |
RFLR_DIOMAPPING1_DIO3_00; //TX_Done
// CadDetected ModeReady
SX1276LR.RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR.RegDioMapping1, 2 );
// SX1276ReadBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );
}
void SX1276Fsk_Send_Packet(u8 *PBuffer,u8 length)
{
SX1276FskSetOpMode( RF_OPMODE_STANDBY );
// PacketSent, FifoLevel, FifoFull, TxReady
SX1276->RegDioMapping1 = packet_DIO0_packetSend | packet_DIO1_fifoLevel | packet_DIO2_fifoFull | packet_DIO3_TxReady;
// LowBat, Data
SX1276->RegDioMapping2 = packet_DIO4_TimeOut | packet_DIO5_Data ;
SX1276WriteBuffer( REG_DIOMAPPING1, &SX1276->RegDioMapping1, 2 );
SX1276->RegFifoThresh = RF_FIFOTHRESH_TXSTARTCONDITION_FIFONOTEMPTY | TX_FIFO_THRESHOLD; // 24 bytes of data
SX1276Write( REG_FIFOTHRESH, SX1276->RegFifoThresh );
packet_tx_data(PBuffer, length);
hal_DIOx_ITConfig(0,ENABLE);
hal_fsk_eit_failing(1,ENABLE);
fill_fifo();
g_fsk.states = RF_STATE_TX_RUNNING;
SX1276FskSetOpMode( RF_OPMODE_TRANSMITTER );
}
void SX1276SetLoRaOn(void)
{
SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
SX1276LR.RegOpMode = ( SX1276LR.RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
SX1276LR.RegOpMode&=~0x8; // vynuluju bit pro LF
SX1276Write( REG_LR_OPMODE, SX1276LR.RegOpMode );
SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
// RxDone RxTimeout FhssChangeChannel CadDone
SX1276LR.RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 |
RFLR_DIOMAPPING1_DIO1_00 ; //RXTimeout
// RFLR_DIOMAPPING1_DIO2_00 |
// RFLR_DIOMAPPING1_DIO3_10; //CRC error
// CadDetected ModeReady
SX1276LR.RegDioMapping2 =0;// RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
// CadDetected ModeReady
SX1276LR.RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR.RegDioMapping1, 2 );
}
void Continous_wave()
{
/*
/ _____) _ | |
( (____ _____ ____ _| |_ _____ ____| |__
\____ \| ___ | (_ _) ___ |/ ___) _ \
_____) ) ____| | | || |_| ____( (___| | | |
(______/|_____)_|_|_| \__)_____)\____)_| |_|
( C )2014 Semtech
Description: Tx Continuous Wave implementation
License: Revised BSD License, see LICENSE.TXT file include in the project
Maintainers: Miguel Luis, Gregory Cristian and Nicolas Huguenin
*/
//#include "sx1276-hal.h"
/* Set this flag to '1' to test the HF max output power or '0' to the the LF max output power */
/**
* Main application entry point.
*/
uint8_t TxOuputPower = 0;
/**********************************************/
/* WARNING */
/* The below settings can damage the chipset */
/* if wrongly used. DO NOT CHANGE THE VALUES! */
/* */
/**********************************************/
// SX1276MB1MAS
// debug("\r\n TEST_HF_OUTPUT on SX1276MB1MAS: 14 dBm at 868 MHz \r\n" );
SX1276LoRaSetRFFrequency( 869525000,&SX1276LR );
// TxOuputPower = 14;
SX1276Write( 0x01, 0x88 );
SX1276Write( 0x3D, 0xA1 );
SX1276Write( 0x36, 0x01 );
SX1276Write( 0x1e, 0x08 );
//LORA
SX1276SetLoRaOn();
SX1276LoRaInit();
SX1276LoRaSetOpMode(RFLR_OPMODE_TRANSMITTER);
// Radio.SetTxConfig( MODEM_LORA, TxOuputPower, 0, LORA_BANDWIDTH,
// LORA_SPREADING_FACTOR, LORA_CODINGRATE,
// LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
// LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP,
// LORA_IQ_INVERSION_ON, 3000000 );
// Sets the radio in Tx mode
// Radio.Send( NULL, 0 );
//
// debug( "Start main loop: \r\n" );
// // Blink LEDs just to show some activity
// while( 1 )
// {
// debug( "Continuous Wave activated... \r\n" );
// wait_ms( 200 );
// }
}
void SX1276FskInit( void )
{
SX1276FskSetOpMode( RF_OPMODE_STANDBY );
SX1276FskSetDefaults( );
SX1276ReadBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
// Set the device in FSK mode and Sleep Mode
SX1276.RegOpMode = RF_OPMODE_MODULATIONTYPE_FSK | RF_OPMODE_SLEEP;
SX1276Write( REG_OPMODE, SX1276.RegOpMode );
SX1276.RegPaRamp = RF_PARAMP_MODULATIONSHAPING_01;
SX1276Write( REG_PARAMP, SX1276.RegPaRamp );
SX1276.RegLna = RF_LNA_GAIN_G1;
SX1276Write( REG_LNA, SX1276.RegLna );
if( FskSettings.AfcOn == true )
{
SX1276.RegRxConfig = RF_RXCONFIG_RESTARTRXONCOLLISION_OFF | RF_RXCONFIG_AFCAUTO_ON |
RF_RXCONFIG_AGCAUTO_ON | RF_RXCONFIG_RXTRIGER_PREAMBLEDETECT;
}
else
{
SX1276.RegRxConfig = RF_RXCONFIG_RESTARTRXONCOLLISION_OFF | RF_RXCONFIG_AFCAUTO_OFF |
RF_RXCONFIG_AGCAUTO_ON | RF_RXCONFIG_RXTRIGER_PREAMBLEDETECT;
}
SX1276.RegPreambleLsb = 8;
SX1276.RegPreambleDetect = RF_PREAMBLEDETECT_DETECTOR_ON | RF_PREAMBLEDETECT_DETECTORSIZE_2 |
RF_PREAMBLEDETECT_DETECTORTOL_10;
SX1276.RegRssiThresh = 0xFF;
SX1276.RegSyncConfig = RF_SYNCCONFIG_AUTORESTARTRXMODE_WAITPLL_ON | RF_SYNCCONFIG_PREAMBLEPOLARITY_AA |
RF_SYNCCONFIG_SYNC_ON |
RF_SYNCCONFIG_SYNCSIZE_4;
SX1276.RegSyncValue1 = 0x69;
SX1276.RegSyncValue2 = 0x81;
SX1276.RegSyncValue3 = 0x7E;
SX1276.RegSyncValue4 = 0x96;
SX1276.RegPacketConfig1 = RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE | RF_PACKETCONFIG1_DCFREE_OFF |
( FskSettings.CrcOn << 4 ) | RF_PACKETCONFIG1_CRCAUTOCLEAR_ON |
RF_PACKETCONFIG1_ADDRSFILTERING_OFF | RF_PACKETCONFIG1_CRCWHITENINGTYPE_CCITT;
SX1276FskGetPacketCrcOn(&SX1276); // Update CrcOn on FskSettings
SX1276.RegPayloadLength = FskSettings.PayloadLength;
// we can now update the registers with our configuration
SX1276WriteBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
// then we need to set the RF settings
SX1276FskSetRFFrequency( FskSettings.RFFrequency,&SX1276);
SX1276FskSetBitrate( FskSettings.Bitrate,&SX1276 );
SX1276FskSetFdev( FskSettings.Fdev,&SX1276 );
SX1276FskSetDccBw( &SX1276.RegRxBw, 0, FskSettings.RxBw,&SX1276 );
SX1276FskSetDccBw( &SX1276.RegAfcBw, 0, FskSettings.RxBwAfc,&SX1276 );
SX1276FskSetRssiOffset( 0 ,&SX1276);
if( FskSettings.RFFrequency > 860000000 )
{
SX1276FskSetPAOutput( RF_PACONFIG_PASELECT_RFO,&SX1276 );
SX1276FskSetPa20dBm( false ,&SX1276);
FskSettings.Power = 14;
SX1276FskSetRFPower( FskSettings.Power ,&SX1276);
}
SX1276FskSetOpMode( RF_OPMODE_STANDBY );
// Calibrate the HF
SX1276FskRxCalibrate(&SX1276 );
}
/*!
* \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;
}
}
void contious_tx(void)
{
SX1276->RegFifoThresh = RF_FIFOTHRESH_TXSTARTCONDITION_FIFOTHRESH | TX_FIFO_THRESHOLD; // 24 bytes of data
SX1276Write( REG_FIFOTHRESH, SX1276->RegFifoThresh );
SX1276FskSetOpMode( RF_OPMODE_TRANSMITTER );
}
