jmg
/
lora-irrigation
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Implement a secure ICS protocol targeting LoRa Node151 microcontroller for controlling irrigation.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
29 Commits
4 Branches
18 MiB
 
 
 
 
 
 
Tree: 3ea8b8cae6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3ea8b8cae6'
${ noResults }
lora-irrigation/SX1276Lib/sx1276/sx1276.cpp

1562 lines
58 KiB
Raw Blame History 

  1. /*

  2.  / _____)             _              | |

  3. ( (____  _____ ____ _| |_ _____  ____| |__

  4.  \____ \| ___ |    (_   _) ___ |/ ___)  _ \

  5.  _____) ) ____| | | || |_| ____( (___| | | |

  6. (______/|_____)_|_|_| \__)_____)\____)_| |_|

  7.     (C) 2014 Semtech

  8. 

  9. Description: Actual implementation of a SX1276 radio, inherits Radio

  10. 

  11. License: Revised BSD License, see LICENSE.TXT file include in the project

  12. 

  13. Maintainers: Miguel Luis, Gregory Cristian and Nicolas Huguenin

  14. */

  15. #include "sx1276.h"

  16. 

  17. const FskBandwidth_t SX1276::FskBandwidths[] =

  18. {

  19.     { 2600  , 0x17 },

  20.     { 3100  , 0x0F },

  21.     { 3900  , 0x07 },

  22.     { 5200  , 0x16 },

  23.     { 6300  , 0x0E },

  24.     { 7800  , 0x06 },

  25.     { 10400 , 0x15 },

  26.     { 12500 , 0x0D },

  27.     { 15600 , 0x05 },

  28.     { 20800 , 0x14 },

  29.     { 25000 , 0x0C },

  30.     { 31300 , 0x04 },

  31.     { 41700 , 0x13 },

  32.     { 50000 , 0x0B },

  33.     { 62500 , 0x03 },

  34.     { 83333 , 0x12 },

  35.     { 100000, 0x0A },

  36.     { 125000, 0x02 },

  37.     { 166700, 0x11 },

  38.     { 200000, 0x09 },

  39.     { 250000, 0x01 },

  40.     { 300000, 0x00 }, // Invalid Bandwidth

  41. };

  42. 

  43. 

  44. SX1276::SX1276( RadioEvents_t *events,

  45.                 PinName mosi, PinName miso, PinName sclk, PinName nss, PinName reset,

  46.                 PinName dio0, PinName dio1, PinName dio2, PinName dio3, PinName dio4, PinName dio5 )

  47.             :   Radio( events ),

  48.                 spi( mosi, miso, sclk ),

  49.                 nss( nss ),

  50.                 reset( reset ),

  51.                 dio0( dio0 ), dio1( dio1 ), dio2( dio2 ), dio3( dio3 ), dio4( dio4 ), dio5( dio5 ),

  52.                 isRadioActive( false )

  53. {

  54.     wait_ms( 10 );

  55.     this->rxtxBuffer = new uint8_t[RX_BUFFER_SIZE];

  56. 

  57.     this->RadioEvents = events;

  58. 

  59.     this->dioIrq = new DioIrqHandler[6];

  60. 

  61.     this->dioIrq[0] = &SX1276::OnDio0Irq;

  62.     this->dioIrq[1] = &SX1276::OnDio1Irq;

  63.     this->dioIrq[2] = &SX1276::OnDio2Irq;

  64.     this->dioIrq[3] = &SX1276::OnDio3Irq;

  65.     this->dioIrq[4] = &SX1276::OnDio4Irq;

  66.     this->dioIrq[5] = NULL;

  67. 

  68.     this->settings.State = RF_IDLE;

  69. }

  70. 

  71. SX1276::~SX1276( )

  72. {

  73.     delete this->rxtxBuffer;

  74.     delete this->dioIrq;

  75. }

  76. 

  77. void SX1276::Init( RadioEvents_t *events )

  78. {

  79.     this->RadioEvents = events;

  80. }

  81. 

  82. RadioState SX1276::GetStatus( void )

  83. {

  84.     return this->settings.State;

  85. }

  86. 

  87. void SX1276::SetChannel( uint32_t freq )

  88. {

  89.     this->settings.Channel = freq;

  90.     freq = ( uint32_t )( ( double )freq / ( double )FREQ_STEP );

  91.     Write( REG_FRFMSB, ( uint8_t )( ( freq >> 16 ) & 0xFF ) );

  92.     Write( REG_FRFMID, ( uint8_t )( ( freq >> 8 ) & 0xFF ) );

  93.     Write( REG_FRFLSB, ( uint8_t )( freq & 0xFF ) );

  94. }

  95. 

  96. bool SX1276::IsChannelFree( RadioModems_t modem, uint32_t freq, int16_t rssiThresh )

  97. {

  98.     int16_t rssi = 0;

  99. 

  100.     SetModem( modem );

  101. 

  102.     SetChannel( freq );

  103. 

  104.     SetOpMode( RF_OPMODE_RECEIVER );

  105. 

  106.     wait_ms( 1 );

  107. 

  108.     rssi = GetRssi( modem );

  109. 

  110.     Sleep( );

  111. 

  112.     if( rssi > rssiThresh )

  113.     {

  114.         return false;

  115.     }

  116.     return true;

  117. }

  118. 

  119. uint32_t SX1276::Random( void )

  120. {

  121.     uint8_t i;

  122.     uint32_t rnd = 0;

  123. 

  124.     /*

  125.      * Radio setup for random number generation

  126.      */

  127.     // Set LoRa modem ON

  128.     SetModem( MODEM_LORA );

  129. 

  130.     // Disable LoRa modem interrupts

  131.     Write( REG_LR_IRQFLAGSMASK, RFLR_IRQFLAGS_RXTIMEOUT |

  132.                   RFLR_IRQFLAGS_RXDONE |

  133.                   RFLR_IRQFLAGS_PAYLOADCRCERROR |

  134.                   RFLR_IRQFLAGS_VALIDHEADER |

  135.                   RFLR_IRQFLAGS_TXDONE |

  136.                   RFLR_IRQFLAGS_CADDONE |

  137.                   RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |

  138.                   RFLR_IRQFLAGS_CADDETECTED );

  139. 

  140.     // Set radio in continuous reception

  141.     SetOpMode( RF_OPMODE_RECEIVER );

  142. 

  143.     for( i = 0; i < 32; i++ )

  144.     {

  145.         wait_ms( 1 );

  146.         // Unfiltered RSSI value reading. Only takes the LSB value

  147.         rnd |= ( ( uint32_t )Read( REG_LR_RSSIWIDEBAND ) & 0x01 ) << i;

  148.     }

  149. 

  150.     Sleep( );

  151. 

  152.     return rnd;

  153. }

  154. 

  155. /*!

  156.  * Performs the Rx chain calibration for LF and HF bands

  157.  * \remark Must be called just after the reset so all registers are at their

  158.  *         default values

  159.  */

  160. void SX1276::RxChainCalibration( void )

  161. {

  162.     uint8_t regPaConfigInitVal;

  163.     uint32_t initialFreq;

  164. 

  165.     // Save context

  166.     regPaConfigInitVal = this->Read( REG_PACONFIG );

  167.     initialFreq = ( double )( ( ( uint32_t )this->Read( REG_FRFMSB ) << 16 ) |

  168.                               ( ( uint32_t )this->Read( REG_FRFMID ) << 8 ) |

  169.                               ( ( uint32_t )this->Read( REG_FRFLSB ) ) ) * ( double )FREQ_STEP;

  170. 

  171.     // Cut the PA just in case, RFO output, power = -1 dBm

  172.     this->Write( REG_PACONFIG, 0x00 );

  173. 

  174.     // Launch Rx chain calibration for LF band

  175.     Write ( REG_IMAGECAL, ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_MASK ) | RF_IMAGECAL_IMAGECAL_START );

  176.     while( ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_RUNNING ) == RF_IMAGECAL_IMAGECAL_RUNNING )

  177.     {

  178.     }

  179. 

  180.     // Sets a Frequency in HF band

  181.     SetChannel( 868000000 );

  182. 

  183.     // Launch Rx chain calibration for HF band

  184.     Write ( REG_IMAGECAL, ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_MASK ) | RF_IMAGECAL_IMAGECAL_START );

  185.     while( ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_RUNNING ) == RF_IMAGECAL_IMAGECAL_RUNNING )

  186.     {

  187.     }

  188. 

  189.     // Restore context

  190.     this->Write( REG_PACONFIG, regPaConfigInitVal );

  191.     SetChannel( initialFreq );

  192. }

  193. 

  194. /*!

  195.  * Returns the known FSK bandwidth registers value

  196.  *

  197.  * \param [IN] bandwidth Bandwidth value in Hz

  198.  * \retval regValue Bandwidth register value.

  199.  */

  200. uint8_t SX1276::GetFskBandwidthRegValue( uint32_t bandwidth )

  201. {

  202.     uint8_t i;

  203. 

  204.     for( i = 0; i < ( sizeof( FskBandwidths ) / sizeof( FskBandwidth_t ) ) - 1; i++ )

  205.     {

  206.         if( ( bandwidth >= FskBandwidths[i].bandwidth ) && ( bandwidth < FskBandwidths[i + 1].bandwidth ) )

  207.         {

  208.             return FskBandwidths[i].RegValue;

  209.         }

  210.     }

  211.     // ERROR: Value not found

  212.     while( 1 );

  213. }

  214. 

  215. void SX1276::SetRxConfig( RadioModems_t modem, uint32_t bandwidth,

  216.                          uint32_t datarate, uint8_t coderate,

  217.                          uint32_t bandwidthAfc, uint16_t preambleLen,

  218.                          uint16_t symbTimeout, bool fixLen,

  219.                          uint8_t payloadLen,

  220.                          bool crcOn, bool freqHopOn, uint8_t hopPeriod,

  221.                          bool iqInverted, bool rxContinuous )

  222. {

  223.     SetModem( modem );

  224. 

  225.     switch( modem )

  226.     {

  227.     case MODEM_FSK:

  228.         {

  229.             this->settings.Fsk.Bandwidth = bandwidth;

  230.             this->settings.Fsk.Datarate = datarate;

  231.             this->settings.Fsk.BandwidthAfc = bandwidthAfc;

  232.             this->settings.Fsk.FixLen = fixLen;

  233.             this->settings.Fsk.PayloadLen = payloadLen;

  234.             this->settings.Fsk.CrcOn = crcOn;

  235.             this->settings.Fsk.IqInverted = iqInverted;

  236.             this->settings.Fsk.RxContinuous = rxContinuous;

  237.             this->settings.Fsk.PreambleLen = preambleLen;

  238.             this->settings.Fsk.RxSingleTimeout = symbTimeout * ( ( 1.0 / ( double )datarate ) * 8.0 ) * 1e3;

  239. 

  240.             datarate = ( uint16_t )( ( double )XTAL_FREQ / ( double )datarate );

  241.             Write( REG_BITRATEMSB, ( uint8_t )( datarate >> 8 ) );

  242.             Write( REG_BITRATELSB, ( uint8_t )( datarate & 0xFF ) );

  243. 

  244.             Write( REG_RXBW, GetFskBandwidthRegValue( bandwidth ) );

  245.             Write( REG_AFCBW, GetFskBandwidthRegValue( bandwidthAfc ) );

  246. 

  247.             Write( REG_PREAMBLEMSB, ( uint8_t )( ( preambleLen >> 8 ) & 0xFF ) );

  248.             Write( REG_PREAMBLELSB, ( uint8_t )( preambleLen & 0xFF ) );

  249. 

  250.             if( fixLen == 1 )

  251.             {

  252.                 Write( REG_PAYLOADLENGTH, payloadLen );

  253.             }

  254.             else

  255.             {

  256.                 Write( REG_PAYLOADLENGTH, 0xFF ); // Set payload length to the maximum

  257.             }

  258.             

  259.             Write( REG_PACKETCONFIG1,

  260.                          ( Read( REG_PACKETCONFIG1 ) &

  261.                            RF_PACKETCONFIG1_CRC_MASK &

  262.                            RF_PACKETCONFIG1_PACKETFORMAT_MASK ) |

  263.                            ( ( fixLen == 1 ) ? RF_PACKETCONFIG1_PACKETFORMAT_FIXED : RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE ) |

  264.                            ( crcOn << 4 ) );

  265.             Write( REG_PACKETCONFIG2, ( Read( REG_PACKETCONFIG2 ) | RF_PACKETCONFIG2_DATAMODE_PACKET ) );

  266.         }

  267.         break;

  268.     case MODEM_LORA:

  269.         {

  270.             if( bandwidth > 2 )

  271.             {

  272.                 // Fatal error: When using LoRa modem only bandwidths 125, 250 and 500 kHz are supported

  273.                 while( 1 );

  274.             }

  275.             bandwidth += 7;

  276.             this->settings.LoRa.Bandwidth = bandwidth;

  277.             this->settings.LoRa.Datarate = datarate;

  278.             this->settings.LoRa.Coderate = coderate;

  279.             this->settings.LoRa.PreambleLen = preambleLen;

  280.             this->settings.LoRa.FixLen = fixLen;

  281.             this->settings.LoRa.PayloadLen = payloadLen;

  282.             this->settings.LoRa.CrcOn = crcOn;

  283.             this->settings.LoRa.FreqHopOn = freqHopOn;

  284.             this->settings.LoRa.HopPeriod = hopPeriod;

  285.             this->settings.LoRa.IqInverted = iqInverted;

  286.             this->settings.LoRa.RxContinuous = rxContinuous;

  287. 

  288.             if( datarate > 12 )

  289.             {

  290.                 datarate = 12;

  291.             }

  292.             else if( datarate < 6 )

  293.             {

  294.                 datarate = 6;

  295.             }

  296. 

  297.             if( ( ( bandwidth == 7 ) && ( ( datarate == 11 ) || ( datarate == 12 ) ) ) ||

  298.                 ( ( bandwidth == 8 ) && ( datarate == 12 ) ) )

  299.             {

  300.                 this->settings.LoRa.LowDatarateOptimize = 0x01;

  301.             }

  302.             else

  303.             {

  304.                 this->settings.LoRa.LowDatarateOptimize = 0x00;

  305.             }

  306. 

  307.             Write( REG_LR_MODEMCONFIG1,

  308.                          ( Read( REG_LR_MODEMCONFIG1 ) &

  309.                            RFLR_MODEMCONFIG1_BW_MASK &

  310.                            RFLR_MODEMCONFIG1_CODINGRATE_MASK &

  311.                            RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK ) |

  312.                            ( bandwidth << 4 ) | ( coderate << 1 ) |

  313.                            fixLen );

  314. 

  315.             Write( REG_LR_MODEMCONFIG2,

  316.                          ( Read( REG_LR_MODEMCONFIG2 ) &

  317.                            RFLR_MODEMCONFIG2_SF_MASK &

  318.                            RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK &

  319.                            RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK ) |

  320.                            ( datarate << 4 ) | ( crcOn << 2 ) |

  321.                            ( ( symbTimeout >> 8 ) & ~RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK ) );

  322. 

  323.             Write( REG_LR_MODEMCONFIG3,

  324.                          ( Read( REG_LR_MODEMCONFIG3 ) &

  325.                            RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK ) |

  326.                            ( this->settings.LoRa.LowDatarateOptimize << 3 ) );

  327. 

  328.             Write( REG_LR_SYMBTIMEOUTLSB, ( uint8_t )( symbTimeout & 0xFF ) );

  329. 

  330.             Write( REG_LR_PREAMBLEMSB, ( uint8_t )( ( preambleLen >> 8 ) & 0xFF ) );

  331.             Write( REG_LR_PREAMBLELSB, ( uint8_t )( preambleLen & 0xFF ) );

  332. 

  333.             if( fixLen == 1 )

  334.             {

  335.                 Write( REG_LR_PAYLOADLENGTH, payloadLen );

  336.             }

  337. 

  338.             if( this->settings.LoRa.FreqHopOn == true )

  339.             {

  340.                 Write( REG_LR_PLLHOP, ( Read( REG_LR_PLLHOP ) & RFLR_PLLHOP_FASTHOP_MASK ) | RFLR_PLLHOP_FASTHOP_ON );

  341.                 Write( REG_LR_HOPPERIOD, this->settings.LoRa.HopPeriod );

  342.             }

  343. 

  344.             if( ( bandwidth == 9 ) && ( this->settings.Channel > RF_MID_BAND_THRESH ) )

  345.             {

  346.                 // ERRATA 2.1 - Sensitivity Optimization with a 500 kHz Bandwidth

  347.                 Write( REG_LR_TEST36, 0x02 );

  348.                 Write( REG_LR_TEST3A, 0x64 );

  349.             }

  350.             else if( bandwidth == 9 )

  351.             {

  352.                 // ERRATA 2.1 - Sensitivity Optimization with a 500 kHz Bandwidth

  353.                 Write( REG_LR_TEST36, 0x02 );

  354.                 Write( REG_LR_TEST3A, 0x7F );

  355.             }

  356.             else

  357.             {

  358.                 // ERRATA 2.1 - Sensitivity Optimization with a 500 kHz Bandwidth

  359.                 Write( REG_LR_TEST36, 0x03 );

  360.             }

  361. 

  362.             if( datarate == 6 )

  363.             {

  364.                 Write( REG_LR_DETECTOPTIMIZE,

  365.                              ( Read( REG_LR_DETECTOPTIMIZE ) &

  366.                                RFLR_DETECTIONOPTIMIZE_MASK ) |

  367.                                RFLR_DETECTIONOPTIMIZE_SF6 );

  368.                 Write( REG_LR_DETECTIONTHRESHOLD,

  369.                              RFLR_DETECTIONTHRESH_SF6 );

  370.             }

  371.             else

  372.             {

  373.                 Write( REG_LR_DETECTOPTIMIZE,

  374.                              ( Read( REG_LR_DETECTOPTIMIZE ) &

  375.                              RFLR_DETECTIONOPTIMIZE_MASK ) |

  376.                              RFLR_DETECTIONOPTIMIZE_SF7_TO_SF12 );

  377.                 Write( REG_LR_DETECTIONTHRESHOLD,

  378.                              RFLR_DETECTIONTHRESH_SF7_TO_SF12 );

  379.             }

  380.         }

  381.         break;

  382.     }

  383. }

  384. 

  385. void SX1276::SetTxConfig( RadioModems_t modem, int8_t power, uint32_t fdev,

  386.                         uint32_t bandwidth, uint32_t datarate,

  387.                         uint8_t coderate, uint16_t preambleLen,

  388.                         bool fixLen, bool crcOn, bool freqHopOn,

  389.                         uint8_t hopPeriod, bool iqInverted, uint32_t timeout )

  390. {

  391.     SetModem( modem );

  392. 

  393.     SetRfTxPower( power );

  394. 

  395.     switch( modem )

  396.     {

  397.     case MODEM_FSK:

  398.         {

  399.             this->settings.Fsk.Power = power;

  400.             this->settings.Fsk.Fdev = fdev;

  401.             this->settings.Fsk.Bandwidth = bandwidth;

  402.             this->settings.Fsk.Datarate = datarate;

  403.             this->settings.Fsk.PreambleLen = preambleLen;

  404.             this->settings.Fsk.FixLen = fixLen;

  405.             this->settings.Fsk.CrcOn = crcOn;

  406.             this->settings.Fsk.IqInverted = iqInverted;

  407.             this->settings.Fsk.TxTimeout = timeout;

  408. 

  409.             fdev = ( uint16_t )( ( double )fdev / ( double )FREQ_STEP );

  410.             Write( REG_FDEVMSB, ( uint8_t )( fdev >> 8 ) );

  411.             Write( REG_FDEVLSB, ( uint8_t )( fdev & 0xFF ) );

  412. 

  413.             datarate = ( uint16_t )( ( double )XTAL_FREQ / ( double )datarate );

  414.             Write( REG_BITRATEMSB, ( uint8_t )( datarate >> 8 ) );

  415.             Write( REG_BITRATELSB, ( uint8_t )( datarate & 0xFF ) );

  416. 

  417.             Write( REG_PREAMBLEMSB, ( preambleLen >> 8 ) & 0x00FF );

  418.             Write( REG_PREAMBLELSB, preambleLen & 0xFF );

  419. 

  420.             Write( REG_PACKETCONFIG1,

  421.                          ( Read( REG_PACKETCONFIG1 ) &

  422.                            RF_PACKETCONFIG1_CRC_MASK &

  423.                            RF_PACKETCONFIG1_PACKETFORMAT_MASK ) |

  424.                            ( ( fixLen == 1 ) ? RF_PACKETCONFIG1_PACKETFORMAT_FIXED : RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE ) |

  425.                            ( crcOn << 4 ) );

  426.             Write( REG_PACKETCONFIG2, ( Read( REG_PACKETCONFIG2 ) | RF_PACKETCONFIG2_DATAMODE_PACKET ) );

  427.         }

  428.         break;

  429.     case MODEM_LORA:

  430.         {

  431.             this->settings.LoRa.Power = power;

  432.             if( bandwidth > 2 )

  433.             {

  434.                 // Fatal error: When using LoRa modem only bandwidths 125, 250 and 500 kHz are supported

  435.                 while( 1 );

  436.             }

  437.             bandwidth += 7;

  438.             this->settings.LoRa.Bandwidth = bandwidth;

  439.             this->settings.LoRa.Datarate = datarate;

  440.             this->settings.LoRa.Coderate = coderate;

  441.             this->settings.LoRa.PreambleLen = preambleLen;

  442.             this->settings.LoRa.FixLen = fixLen;

  443.             this->settings.LoRa.FreqHopOn = freqHopOn;

  444.             this->settings.LoRa.HopPeriod = hopPeriod;

  445.             this->settings.LoRa.CrcOn = crcOn;

  446.             this->settings.LoRa.IqInverted = iqInverted;

  447.             this->settings.LoRa.TxTimeout = timeout;

  448. 

  449.             if( datarate > 12 )

  450.             {

  451.                 datarate = 12;

  452.             }

  453.             else if( datarate < 6 )

  454.             {

  455.                 datarate = 6;

  456.             }

  457.             if( ( ( bandwidth == 7 ) && ( ( datarate == 11 ) || ( datarate == 12 ) ) ) ||

  458.                 ( ( bandwidth == 8 ) && ( datarate == 12 ) ) )

  459.             {

  460.                 this->settings.LoRa.LowDatarateOptimize = 0x01;

  461.             }

  462.             else

  463.             {

  464.                 this->settings.LoRa.LowDatarateOptimize = 0x00;

  465.             }

  466. 

  467.             if( this->settings.LoRa.FreqHopOn == true )

  468.             {

  469.                 Write( REG_LR_PLLHOP, ( Read( REG_LR_PLLHOP ) & RFLR_PLLHOP_FASTHOP_MASK ) | RFLR_PLLHOP_FASTHOP_ON );

  470.                 Write( REG_LR_HOPPERIOD, this->settings.LoRa.HopPeriod );

  471.             }

  472. 

  473.             Write( REG_LR_MODEMCONFIG1,

  474.                          ( Read( REG_LR_MODEMCONFIG1 ) &

  475.                            RFLR_MODEMCONFIG1_BW_MASK &

  476.                            RFLR_MODEMCONFIG1_CODINGRATE_MASK &

  477.                            RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK ) |

  478.                            ( bandwidth << 4 ) | ( coderate << 1 ) |

  479.                            fixLen );

  480. 

  481.             Write( REG_LR_MODEMCONFIG2,

  482.                          ( Read( REG_LR_MODEMCONFIG2 ) &

  483.                            RFLR_MODEMCONFIG2_SF_MASK &

  484.                            RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK ) |

  485.                            ( datarate << 4 ) | ( crcOn << 2 ) );

  486. 

  487.             Write( REG_LR_MODEMCONFIG3,

  488.                          ( Read( REG_LR_MODEMCONFIG3 ) &

  489.                            RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK ) |

  490.                            ( this->settings.LoRa.LowDatarateOptimize << 3 ) );

  491. 

  492.             Write( REG_LR_PREAMBLEMSB, ( preambleLen >> 8 ) & 0x00FF );

  493.             Write( REG_LR_PREAMBLELSB, preambleLen & 0xFF );

  494. 

  495.             if( datarate == 6 )

  496.             {

  497.                 Write( REG_LR_DETECTOPTIMIZE,

  498.                              ( Read( REG_LR_DETECTOPTIMIZE ) &

  499.                                RFLR_DETECTIONOPTIMIZE_MASK ) |

  500.                                RFLR_DETECTIONOPTIMIZE_SF6 );

  501.                 Write( REG_LR_DETECTIONTHRESHOLD,

  502.                              RFLR_DETECTIONTHRESH_SF6 );

  503.             }

  504.             else

  505.             {

  506.                 Write( REG_LR_DETECTOPTIMIZE,

  507.                              ( Read( REG_LR_DETECTOPTIMIZE ) &

  508.                              RFLR_DETECTIONOPTIMIZE_MASK ) |

  509.                              RFLR_DETECTIONOPTIMIZE_SF7_TO_SF12 );

  510.                 Write( REG_LR_DETECTIONTHRESHOLD,

  511.                              RFLR_DETECTIONTHRESH_SF7_TO_SF12 );

  512.             }

  513.         }

  514.         break;

  515.     }

  516. }

  517. 

  518. uint32_t SX1276::TimeOnAir( RadioModems_t modem, uint8_t pktLen )

  519. {

  520.     uint32_t airTime = 0;

  521. 

  522.     switch( modem )

  523.     {

  524.     case MODEM_FSK:

  525.         {

  526.             airTime = rint( ( 8 * ( this->settings.Fsk.PreambleLen +

  527.                                      ( ( Read( REG_SYNCCONFIG ) & ~RF_SYNCCONFIG_SYNCSIZE_MASK ) + 1 ) +

  528.                                      ( ( this->settings.Fsk.FixLen == 0x01 ) ? 0.0 : 1.0 ) +

  529.                                      ( ( ( Read( REG_PACKETCONFIG1 ) & ~RF_PACKETCONFIG1_ADDRSFILTERING_MASK ) != 0x00 ) ? 1.0 : 0 ) +

  530.                                      pktLen +

  531.                                      ( ( this->settings.Fsk.CrcOn == 0x01 ) ? 2.0 : 0 ) ) /

  532.                                      this->settings.Fsk.Datarate ) * 1e3 );

  533.         }

  534.         break;

  535.     case MODEM_LORA:

  536.         {

  537.             double bw = 0.0;

  538.             // REMARK: When using LoRa modem only bandwidths 125, 250 and 500 kHz are supported

  539.             switch( this->settings.LoRa.Bandwidth )

  540.             {

  541.             //case 0: // 7.8 kHz

  542.             //    bw = 78e2;

  543.             //    break;

  544.             //case 1: // 10.4 kHz

  545.             //    bw = 104e2;

  546.             //    break;

  547.             //case 2: // 15.6 kHz

  548.             //    bw = 156e2;

  549.             //    break;

  550.             //case 3: // 20.8 kHz

  551.             //    bw = 208e2;

  552.             //    break;

  553.             //case 4: // 31.2 kHz

  554.             //    bw = 312e2;

  555.             //    break;

  556.             //case 5: // 41.4 kHz

  557.             //    bw = 414e2;

  558.             //    break;

  559.             //case 6: // 62.5 kHz

  560.             //    bw = 625e2;

  561.             //    break;

  562.             case 7: // 125 kHz

  563.                 bw = 125e3;

  564.                 break;

  565.             case 8: // 250 kHz

  566.                 bw = 250e3;

  567.                 break;

  568.             case 9: // 500 kHz

  569.                 bw = 500e3;

  570.                 break;

  571.             }

  572. 

  573.             // Symbol rate : time for one symbol (secs)

  574.             double rs = bw / ( 1 << this->settings.LoRa.Datarate );

  575.             double ts = 1 / rs;

  576.             // time of preamble

  577.             double tPreamble = ( this->settings.LoRa.PreambleLen + 4.25 ) * ts;

  578.             // Symbol length of payload and time

  579.             double tmp = ceil( ( 8 * pktLen - 4 * this->settings.LoRa.Datarate +

  580.                                  28 + 16 * this->settings.LoRa.CrcOn -

  581.                                  ( this->settings.LoRa.FixLen ? 20 : 0 ) ) /

  582.                                  ( double )( 4 * ( this->settings.LoRa.Datarate -

  583.                                  ( ( this->settings.LoRa.LowDatarateOptimize > 0 ) ? 2 : 0 ) ) ) ) *

  584.                                  ( this->settings.LoRa.Coderate + 4 );

  585.             double nPayload = 8 + ( ( tmp > 0 ) ? tmp : 0 );

  586.             double tPayload = nPayload * ts;

  587.             // Time on air

  588.             double tOnAir = tPreamble + tPayload;

  589.             // return ms secs

  590.             airTime = floor( tOnAir * 1e3 + 0.999 );

  591.         }

  592.         break;

  593.     }

  594.     return airTime;

  595. }

  596. 

  597. void SX1276::Send( uint8_t *buffer, uint8_t size )

  598. {

  599.     uint32_t txTimeout = 0;

  600. 

  601.     switch( this->settings.Modem )

  602.     {

  603.     case MODEM_FSK:

  604.         {

  605.             this->settings.FskPacketHandler.NbBytes = 0;

  606.             this->settings.FskPacketHandler.Size = size;

  607. 

  608.             if( this->settings.Fsk.FixLen == false )

  609.             {

  610.                 WriteFifo( ( uint8_t* )&size, 1 );

  611.             }

  612.             else

  613.             {

  614.                 Write( REG_PAYLOADLENGTH, size );

  615.             }

  616. 

  617.             if( ( size > 0 ) && ( size <= 64 ) )

  618.             {

  619.                 this->settings.FskPacketHandler.ChunkSize = size;

  620.             }

  621.             else

  622.             {

  623.                 memcpy( rxtxBuffer, buffer, size );

  624.                 this->settings.FskPacketHandler.ChunkSize = 32;

  625.             }

  626. 

  627.             // Write payload buffer

  628.             WriteFifo( buffer, this->settings.FskPacketHandler.ChunkSize );

  629.             this->settings.FskPacketHandler.NbBytes += this->settings.FskPacketHandler.ChunkSize;

  630.             txTimeout = this->settings.Fsk.TxTimeout;

  631.         }

  632.         break;

  633.     case MODEM_LORA:

  634.         {

  635.             if( this->settings.LoRa.IqInverted == true )

  636.             {

  637.                 Write( REG_LR_INVERTIQ, ( ( Read( REG_LR_INVERTIQ ) & RFLR_INVERTIQ_TX_MASK & RFLR_INVERTIQ_RX_MASK ) | RFLR_INVERTIQ_RX_OFF | RFLR_INVERTIQ_TX_ON ) );

  638.                 Write( REG_LR_INVERTIQ2, RFLR_INVERTIQ2_ON );

  639.             }

  640.             else

  641.             {

  642.                 Write( REG_LR_INVERTIQ, ( ( Read( REG_LR_INVERTIQ ) & RFLR_INVERTIQ_TX_MASK & RFLR_INVERTIQ_RX_MASK ) | RFLR_INVERTIQ_RX_OFF | RFLR_INVERTIQ_TX_OFF ) );

  643.                 Write( REG_LR_INVERTIQ2, RFLR_INVERTIQ2_OFF );

  644.             }

  645. 

  646.             this->settings.LoRaPacketHandler.Size = size;

  647. 

  648.             // Initializes the payload size

  649.             Write( REG_LR_PAYLOADLENGTH, size );

  650. 

  651.             // Full buffer used for Tx

  652.             Write( REG_LR_FIFOTXBASEADDR, 0 );

  653.             Write( REG_LR_FIFOADDRPTR, 0 );

  654. 

  655.             // FIFO operations can not take place in Sleep mode

  656.             if( ( Read( REG_OPMODE ) & ~RF_OPMODE_MASK ) == RF_OPMODE_SLEEP )

  657.             {

  658.                 Standby( );

  659.                 wait_ms( 1 );

  660.             }

  661.             // Write payload buffer

  662.             WriteFifo( buffer, size );

  663.             txTimeout = this->settings.LoRa.TxTimeout;

  664.         }

  665.         break;

  666.     }

  667. 

  668.     Tx( txTimeout );

  669. }

  670. 

  671. void SX1276::Sleep( void )

  672. {

  673.     txTimeoutTimer.detach( );

  674.     rxTimeoutTimer.detach( );

  675. 

  676.     SetOpMode( RF_OPMODE_SLEEP );

  677.     this->settings.State = RF_IDLE;

  678. }

  679. 

  680. void SX1276::Standby( void )

  681. {

  682.     txTimeoutTimer.detach( );

  683.     rxTimeoutTimer.detach( );

  684. 

  685.     SetOpMode( RF_OPMODE_STANDBY );

  686.     this->settings.State = RF_IDLE;

  687. }

  688. 

  689. void SX1276::Rx( uint32_t timeout )

  690. {

  691.     bool rxContinuous = false;

  692. 

  693.     switch( this->settings.Modem )

  694.     {

  695.     case MODEM_FSK:

  696.         {

  697.             rxContinuous = this->settings.Fsk.RxContinuous;

  698. 

  699.             // DIO0=PayloadReady

  700.             // DIO1=FifoLevel

  701.             // DIO2=SyncAddr

  702.             // DIO3=FifoEmpty

  703.             // DIO4=Preamble

  704.             // DIO5=ModeReady

  705.             Write( REG_DIOMAPPING1, ( Read( REG_DIOMAPPING1 ) & RF_DIOMAPPING1_DIO0_MASK &

  706.                                                                             RF_DIOMAPPING1_DIO1_MASK &

  707.                                                                             RF_DIOMAPPING1_DIO2_MASK ) |

  708.                                                                             RF_DIOMAPPING1_DIO0_00 |

  709.                                                                             RF_DIOMAPPING1_DIO1_00 |

  710.                                                                             RF_DIOMAPPING1_DIO2_11 );

  711. 

  712.             Write( REG_DIOMAPPING2, ( Read( REG_DIOMAPPING2 ) & RF_DIOMAPPING2_DIO4_MASK &

  713.                                                                             RF_DIOMAPPING2_MAP_MASK ) |

  714.                                                                             RF_DIOMAPPING2_DIO4_11 |

  715.                                                                             RF_DIOMAPPING2_MAP_PREAMBLEDETECT );

  716. 

  717.             this->settings.FskPacketHandler.FifoThresh = Read( REG_FIFOTHRESH ) & 0x3F;

  718. 

  719.             Write( REG_RXCONFIG, RF_RXCONFIG_AFCAUTO_ON | RF_RXCONFIG_AGCAUTO_ON | RF_RXCONFIG_RXTRIGER_PREAMBLEDETECT );

  720. 

  721.             this->settings.FskPacketHandler.PreambleDetected = false;

  722.             this->settings.FskPacketHandler.SyncWordDetected = false;

  723.             this->settings.FskPacketHandler.NbBytes = 0;

  724.             this->settings.FskPacketHandler.Size = 0;

  725.         }

  726.         break;

  727.     case MODEM_LORA:

  728.         {

  729.             if( this->settings.LoRa.IqInverted == true )

  730.             {

  731.                 Write( REG_LR_INVERTIQ, ( ( Read( REG_LR_INVERTIQ ) & RFLR_INVERTIQ_TX_MASK & RFLR_INVERTIQ_RX_MASK ) | RFLR_INVERTIQ_RX_ON | RFLR_INVERTIQ_TX_OFF ) );

  732.                 Write( REG_LR_INVERTIQ2, RFLR_INVERTIQ2_ON );

  733.             }

  734.             else

  735.             {

  736.                 Write( REG_LR_INVERTIQ, ( ( Read( REG_LR_INVERTIQ ) & RFLR_INVERTIQ_TX_MASK & RFLR_INVERTIQ_RX_MASK ) | RFLR_INVERTIQ_RX_OFF | RFLR_INVERTIQ_TX_OFF ) );

  737.                 Write( REG_LR_INVERTIQ2, RFLR_INVERTIQ2_OFF );

  738.             }

  739. 

  740.             // ERRATA 2.3 - Receiver Spurious Reception of a LoRa Signal

  741.             if( this->settings.LoRa.Bandwidth < 9 )

  742.             {

  743.                 Write( REG_LR_DETECTOPTIMIZE, Read( REG_LR_DETECTOPTIMIZE ) & 0x7F );

  744.                 Write( REG_LR_TEST30, 0x00 );

  745.                 switch( this->settings.LoRa.Bandwidth )

  746.                 {

  747.                 case 0: // 7.8 kHz

  748.                     Write( REG_LR_TEST2F, 0x48 );

  749.                     SetChannel(this->settings.Channel + 7.81e3 );

  750.                     break;

  751.                 case 1: // 10.4 kHz

  752.                     Write( REG_LR_TEST2F, 0x44 );

  753.                     SetChannel(this->settings.Channel + 10.42e3 );

  754.                     break;

  755.                 case 2: // 15.6 kHz

  756.                     Write( REG_LR_TEST2F, 0x44 );

  757.                     SetChannel(this->settings.Channel + 15.62e3 );

  758.                     break;

  759.                 case 3: // 20.8 kHz

  760.                     Write( REG_LR_TEST2F, 0x44 );

  761.                     SetChannel(this->settings.Channel + 20.83e3 );

  762.                     break;

  763.                 case 4: // 31.2 kHz

  764.                     Write( REG_LR_TEST2F, 0x44 );

  765.                     SetChannel(this->settings.Channel + 31.25e3 );

  766.                     break;

  767.                 case 5: // 41.4 kHz

  768.                     Write( REG_LR_TEST2F, 0x44 );

  769.                     SetChannel(this->settings.Channel + 41.67e3 );

  770.                     break;

  771.                 case 6: // 62.5 kHz

  772.                     Write( REG_LR_TEST2F, 0x40 );

  773.                     break;

  774.                 case 7: // 125 kHz

  775.                     Write( REG_LR_TEST2F, 0x40 );

  776.                     break;

  777.                 case 8: // 250 kHz

  778.                     Write( REG_LR_TEST2F, 0x40 );

  779.                     break;

  780.                 }

  781.             }

  782.             else

  783.             {

  784.                 Write( REG_LR_DETECTOPTIMIZE, Read( REG_LR_DETECTOPTIMIZE ) | 0x80 );

  785.             }

  786. 

  787.             rxContinuous = this->settings.LoRa.RxContinuous;

  788. 

  789.             if( this->settings.LoRa.FreqHopOn == true )

  790.             {

  791.                 Write( REG_LR_IRQFLAGSMASK, //RFLR_IRQFLAGS_RXTIMEOUT |

  792.                                                   //RFLR_IRQFLAGS_RXDONE |

  793.                                                   //RFLR_IRQFLAGS_PAYLOADCRCERROR |

  794.                                                   RFLR_IRQFLAGS_VALIDHEADER |

  795.                                                   RFLR_IRQFLAGS_TXDONE |

  796.                                                   RFLR_IRQFLAGS_CADDONE |

  797.                                                   //RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |

  798.                                                   RFLR_IRQFLAGS_CADDETECTED );

  799. 

  800.                 // DIO0=RxDone, DIO2=FhssChangeChannel

  801.                 Write( REG_DIOMAPPING1, ( Read( REG_DIOMAPPING1 ) & RFLR_DIOMAPPING1_DIO0_MASK & RFLR_DIOMAPPING1_DIO2_MASK  ) | RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO2_00 );

  802.             }

  803.             else

  804.             {

  805.                 Write( REG_LR_IRQFLAGSMASK, //RFLR_IRQFLAGS_RXTIMEOUT |

  806.                                                   //RFLR_IRQFLAGS_RXDONE |

  807.                                                   //RFLR_IRQFLAGS_PAYLOADCRCERROR |

  808.                                                   RFLR_IRQFLAGS_VALIDHEADER |

  809.                                                   RFLR_IRQFLAGS_TXDONE |

  810.                                                   RFLR_IRQFLAGS_CADDONE |

  811.                                                   RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |

  812.                                                   RFLR_IRQFLAGS_CADDETECTED );

  813. 

  814.                 // DIO0=RxDone

  815.                 Write( REG_DIOMAPPING1, ( Read( REG_DIOMAPPING1 ) & RFLR_DIOMAPPING1_DIO0_MASK ) | RFLR_DIOMAPPING1_DIO0_00 );

  816.             }

  817.             Write( REG_LR_FIFORXBASEADDR, 0 );

  818.             Write( REG_LR_FIFOADDRPTR, 0 );

  819.         }

  820.         break;

  821.     }

  822. 

  823.     memset( rxtxBuffer, 0, ( size_t )RX_BUFFER_SIZE );

  824. 

  825.     this->settings.State = RF_RX_RUNNING;

  826.     if( timeout != 0 )

  827.     {

  828.         rxTimeoutTimer.attach_us( mbed::callback( this, &SX1276::OnTimeoutIrq ), timeout * 1e3 );

  829.     }

  830. 

  831.     if( this->settings.Modem == MODEM_FSK )

  832.     {

  833.         SetOpMode( RF_OPMODE_RECEIVER );

  834. 

  835.         if( rxContinuous == false )

  836.         {

  837.             rxTimeoutSyncWord.attach_us( mbed::callback( this, &SX1276::OnTimeoutIrq ),

  838.                                          this->settings.Fsk.RxSingleTimeout * 1e3 );

  839.         }

  840.     }

  841.     else

  842.     {

  843.         if( rxContinuous == true )

  844.         {

  845.             SetOpMode( RFLR_OPMODE_RECEIVER );

  846.         }

  847.         else

  848.         {

  849.             SetOpMode( RFLR_OPMODE_RECEIVER_SINGLE );

  850.         }

  851.     }

  852. }

  853. 

  854. void SX1276::Tx( uint32_t timeout )

  855. {

  856. 

  857.     switch( this->settings.Modem )

  858.     {

  859.     case MODEM_FSK:

  860.         {

  861.             // DIO0=PacketSent

  862.             // DIO1=FifoEmpty

  863.             // DIO2=FifoFull

  864.             // DIO3=FifoEmpty

  865.             // DIO4=LowBat

  866.             // DIO5=ModeReady

  867.             Write( REG_DIOMAPPING1, ( Read( REG_DIOMAPPING1 ) & RF_DIOMAPPING1_DIO0_MASK &

  868.                                                                             RF_DIOMAPPING1_DIO1_MASK &

  869.                                                                             RF_DIOMAPPING1_DIO2_MASK ) |

  870.                                                                             RF_DIOMAPPING1_DIO1_01 );

  871. 

  872.             Write( REG_DIOMAPPING2, ( Read( REG_DIOMAPPING2 ) & RF_DIOMAPPING2_DIO4_MASK &

  873.                                                                             RF_DIOMAPPING2_MAP_MASK ) );

  874.             this->settings.FskPacketHandler.FifoThresh = Read( REG_FIFOTHRESH ) & 0x3F;

  875.         }

  876.         break;

  877.     case MODEM_LORA:

  878.         {

  879.             if( this->settings.LoRa.FreqHopOn == true )

  880.             {

  881.                 Write( REG_LR_IRQFLAGSMASK, RFLR_IRQFLAGS_RXTIMEOUT |

  882.                                                   RFLR_IRQFLAGS_RXDONE |

  883.                                                   RFLR_IRQFLAGS_PAYLOADCRCERROR |

  884.                                                   RFLR_IRQFLAGS_VALIDHEADER |

  885.                                                   //RFLR_IRQFLAGS_TXDONE |

  886.                                                   RFLR_IRQFLAGS_CADDONE |

  887.                                                   //RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |

  888.                                                   RFLR_IRQFLAGS_CADDETECTED );

  889. 

  890.                 // DIO0=TxDone, DIO2=FhssChangeChannel

  891.                 Write( REG_DIOMAPPING1, ( Read( REG_DIOMAPPING1 ) & RFLR_DIOMAPPING1_DIO0_MASK & RFLR_DIOMAPPING1_DIO2_MASK ) | RFLR_DIOMAPPING1_DIO0_01 | RFLR_DIOMAPPING1_DIO2_00 );

  892.             }

  893.             else

  894.             {

  895.                 Write( REG_LR_IRQFLAGSMASK, RFLR_IRQFLAGS_RXTIMEOUT |

  896.                                                   RFLR_IRQFLAGS_RXDONE |

  897.                                                   RFLR_IRQFLAGS_PAYLOADCRCERROR |

  898.                                                   RFLR_IRQFLAGS_VALIDHEADER |

  899.                                                   //RFLR_IRQFLAGS_TXDONE |

  900.                                                   RFLR_IRQFLAGS_CADDONE |

  901.                                                   RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |

  902.                                                   RFLR_IRQFLAGS_CADDETECTED );

  903. 

  904.                 // DIO0=TxDone

  905.                 Write( REG_DIOMAPPING1, ( Read( REG_DIOMAPPING1 ) & RFLR_DIOMAPPING1_DIO0_MASK ) | RFLR_DIOMAPPING1_DIO0_01 );

  906.             }

  907.         }

  908.         break;

  909.     }

  910. 

  911.     this->settings.State = RF_TX_RUNNING;

  912.     txTimeoutTimer.attach_us( mbed::callback( this, &SX1276::OnTimeoutIrq ), timeout * 1e3 );

  913.     SetOpMode( RF_OPMODE_TRANSMITTER );

  914. }

  915. 

  916. void SX1276::StartCad( void )

  917. {

  918.     switch( this->settings.Modem )

  919.     {

  920.     case MODEM_FSK:

  921.         {

  922. 

  923.         }

  924.         break;

  925.     case MODEM_LORA:

  926.         {

  927.             Write( REG_LR_IRQFLAGSMASK, RFLR_IRQFLAGS_RXTIMEOUT |

  928.                                         RFLR_IRQFLAGS_RXDONE |

  929.                                         RFLR_IRQFLAGS_PAYLOADCRCERROR |

  930.                                         RFLR_IRQFLAGS_VALIDHEADER |

  931.                                         RFLR_IRQFLAGS_TXDONE |

  932.                                         //RFLR_IRQFLAGS_CADDONE |

  933.                                         RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL // |

  934.                                         //RFLR_IRQFLAGS_CADDETECTED

  935.                                         );

  936. 

  937.             // DIO3=CADDone

  938.             Write( REG_DIOMAPPING1, ( Read( REG_DIOMAPPING1 ) & RFLR_DIOMAPPING1_DIO3_MASK ) | RFLR_DIOMAPPING1_DIO3_00 );

  939. 

  940.             this->settings.State = RF_CAD;

  941.             SetOpMode( RFLR_OPMODE_CAD );

  942.         }

  943.         break;

  944.     default:

  945.         break;

  946.     }

  947. }

  948. 

  949. void SX1276::SetTxContinuousWave( uint32_t freq, int8_t power, uint16_t time )

  950. {

  951.     uint32_t timeout = ( uint32_t )( time * 1e6 );

  952. 

  953.     SetChannel( freq );

  954. 

  955.     SetTxConfig( MODEM_FSK, power, 0, 0, 4800, 0, 5, false, false, 0, 0, 0, timeout );

  956. 

  957.     Write( REG_PACKETCONFIG2, ( Read( REG_PACKETCONFIG2 ) & RF_PACKETCONFIG2_DATAMODE_MASK ) );

  958.     // Disable radio interrupts

  959.     Write( REG_DIOMAPPING1, RF_DIOMAPPING1_DIO0_11 | RF_DIOMAPPING1_DIO1_11 );

  960.     Write( REG_DIOMAPPING2, RF_DIOMAPPING2_DIO4_10 | RF_DIOMAPPING2_DIO5_10 );

  961. 

  962.     this->settings.State = RF_TX_RUNNING;

  963.     txTimeoutTimer.attach_us( mbed::callback( this, &SX1276::OnTimeoutIrq ), timeout );

  964.     SetOpMode( RF_OPMODE_TRANSMITTER );

  965. }

  966. 

  967. int16_t SX1276::GetRssi( RadioModems_t modem )

  968. {

  969.     int16_t rssi = 0;

  970. 

  971.     switch( modem )

  972.     {

  973.     case MODEM_FSK:

  974.         rssi = -( Read( REG_RSSIVALUE ) >> 1 );

  975.         break;

  976.     case MODEM_LORA:

  977.         if( this->settings.Channel > RF_MID_BAND_THRESH )

  978.         {

  979.             rssi = RSSI_OFFSET_HF + Read( REG_LR_RSSIVALUE );

  980.         }

  981.         else

  982.         {

  983.             rssi = RSSI_OFFSET_LF + Read( REG_LR_RSSIVALUE );

  984.         }

  985.         break;

  986.     default:

  987.         rssi = -1;

  988.         break;

  989.     }

  990.     return rssi;

  991. }

  992. 

  993. void SX1276::SetOpMode( uint8_t opMode )

  994. {

  995.     if( opMode == RF_OPMODE_SLEEP )

  996.     {

  997.         SetAntSwLowPower( true );

  998.     }

  999.     else

  1000.     {

  1001.         SetAntSwLowPower( false );

  1002.         SetAntSw( opMode );

  1003.     }

  1004.     Write( REG_OPMODE, ( Read( REG_OPMODE ) & RF_OPMODE_MASK ) | opMode );

  1005. }

  1006. 

  1007. void SX1276::SetModem( RadioModems_t modem )

  1008. {

  1009.     if( ( Read( REG_OPMODE ) & RFLR_OPMODE_LONGRANGEMODE_ON ) != 0 )

  1010.     {

  1011.         this->settings.Modem = MODEM_LORA;

  1012.     }

  1013.     else

  1014.     {

  1015.         this->settings.Modem = MODEM_FSK;

  1016.     }

  1017. 

  1018.     if( this->settings.Modem == modem )

  1019.     {

  1020.         return;

  1021.     }

  1022. 

  1023.     this->settings.Modem = modem;

  1024.     switch( this->settings.Modem )

  1025.     {

  1026.     default:

  1027.     case MODEM_FSK:

  1028.         Sleep( );

  1029.         Write( REG_OPMODE, ( Read( REG_OPMODE ) & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_OFF );

  1030. 

  1031.         Write( REG_DIOMAPPING1, 0x00 );

  1032.         Write( REG_DIOMAPPING2, 0x30 ); // DIO5=ModeReady

  1033.         break;

  1034.     case MODEM_LORA:

  1035.         Sleep( );

  1036.         Write( REG_OPMODE, ( Read( REG_OPMODE ) & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON );

  1037. 

  1038.         Write( REG_DIOMAPPING1, 0x00 );

  1039.         Write( REG_DIOMAPPING2, 0x00 );

  1040.         break;

  1041.     }

  1042. }

  1043. 

  1044. void SX1276::SetMaxPayloadLength( RadioModems_t modem, uint8_t max )

  1045. {

  1046.     this->SetModem( modem );

  1047. 

  1048.     switch( modem )

  1049.     {

  1050.     case MODEM_FSK:

  1051.         if( this->settings.Fsk.FixLen == false )

  1052.         {

  1053.             this->Write( REG_PAYLOADLENGTH, max );

  1054.         }

  1055.         break;

  1056.     case MODEM_LORA:

  1057.         this->Write( REG_LR_PAYLOADMAXLENGTH, max );

  1058.         break;

  1059.     }

  1060. }

  1061. 

  1062. void SX1276::SetPublicNetwork( bool enable )

  1063. {

  1064.     SetModem( MODEM_LORA );

  1065.     this->settings.LoRa.PublicNetwork = enable;

  1066.     if( enable == true )

  1067.     {

  1068.         // Change LoRa modem SyncWord

  1069.         Write( REG_LR_SYNCWORD, LORA_MAC_PUBLIC_SYNCWORD );

  1070.     }

  1071.     else

  1072.     {

  1073.         // Change LoRa modem SyncWord

  1074.         Write( REG_LR_SYNCWORD, LORA_MAC_PRIVATE_SYNCWORD );

  1075.     }

  1076. }

  1077. 

  1078. void SX1276::OnTimeoutIrq( void )

  1079. {

  1080.     switch( this->settings.State )

  1081.     {

  1082.     case RF_RX_RUNNING:

  1083.         if( this->settings.Modem == MODEM_FSK )

  1084.         {

  1085.             this->settings.FskPacketHandler.PreambleDetected = false;

  1086.             this->settings.FskPacketHandler.SyncWordDetected = false;

  1087.             this->settings.FskPacketHandler.NbBytes = 0;

  1088.             this->settings.FskPacketHandler.Size = 0;

  1089. 

  1090.             // Clear Irqs

  1091.             Write( REG_IRQFLAGS1, RF_IRQFLAGS1_RSSI |

  1092.                                         RF_IRQFLAGS1_PREAMBLEDETECT |

  1093.                                         RF_IRQFLAGS1_SYNCADDRESSMATCH );

  1094.             Write( REG_IRQFLAGS2, RF_IRQFLAGS2_FIFOOVERRUN );

  1095. 

  1096.             if( this->settings.Fsk.RxContinuous == true )

  1097.             {

  1098.                 // Continuous mode restart Rx chain

  1099.                 Write( REG_RXCONFIG, Read( REG_RXCONFIG ) | RF_RXCONFIG_RESTARTRXWITHOUTPLLLOCK );

  1100.                 rxTimeoutSyncWord.attach_us( mbed::callback( this, &SX1276::OnTimeoutIrq ),

  1101.                                              this->settings.Fsk.RxSingleTimeout * 1e3 );

  1102.             }

  1103.             else

  1104.             {

  1105.                 this->settings.State = RF_IDLE;

  1106.                 rxTimeoutSyncWord.detach( );

  1107.             }

  1108.         }

  1109.         if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->RxTimeout != NULL ) )

  1110.         {

  1111.             this->RadioEvents->RxTimeout( );

  1112.         }

  1113.         break;

  1114.     case RF_TX_RUNNING:

  1115.         // Tx timeout shouldn't happen.

  1116.         // But it has been observed that when it happens it is a result of a corrupted SPI transfer

  1117.         // it depends on the platform design.

  1118.         // 

  1119.         // The workaround is to put the radio in a known state. Thus, we re-initialize it.

  1120. 

  1121.         // BEGIN WORKAROUND

  1122. 

  1123.         // Reset the radio

  1124.         Reset( );

  1125. 

  1126.         // Calibrate Rx chain

  1127.         RxChainCalibration( );

  1128. 

  1129.         // Initialize radio default values

  1130.         SetOpMode( RF_OPMODE_SLEEP );

  1131. 

  1132.         RadioRegistersInit( );

  1133. 

  1134.         SetModem( MODEM_FSK );

  1135. 

  1136.         // Restore previous network type setting.

  1137.         SetPublicNetwork( this->settings.LoRa.PublicNetwork );

  1138.         // END WORKAROUND

  1139. 

  1140.         this->settings.State = RF_IDLE;

  1141.         if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->TxTimeout != NULL ) )

  1142.         {

  1143.             this->RadioEvents->TxTimeout( );

  1144.         }

  1145.         break;

  1146.     default:

  1147.         break;

  1148.     }

  1149. }

  1150. 

  1151. void SX1276::OnDio0Irq( void )

  1152. {

  1153.     volatile uint8_t irqFlags = 0;

  1154. 

  1155.     switch( this->settings.State )

  1156.     {

  1157.         case RF_RX_RUNNING:

  1158.             //TimerStop( &RxTimeoutTimer );

  1159.             // RxDone interrupt

  1160.             switch( this->settings.Modem )

  1161.             {

  1162.             case MODEM_FSK:

  1163.                 if( this->settings.Fsk.CrcOn == true )

  1164.                 {

  1165.                     irqFlags = Read( REG_IRQFLAGS2 );

  1166.                     if( ( irqFlags & RF_IRQFLAGS2_CRCOK ) != RF_IRQFLAGS2_CRCOK )

  1167.                     {

  1168.                         // Clear Irqs

  1169.                         Write( REG_IRQFLAGS1, RF_IRQFLAGS1_RSSI |

  1170.                                                     RF_IRQFLAGS1_PREAMBLEDETECT |

  1171.                                                     RF_IRQFLAGS1_SYNCADDRESSMATCH );

  1172.                         Write( REG_IRQFLAGS2, RF_IRQFLAGS2_FIFOOVERRUN );

  1173. 

  1174.                         rxTimeoutTimer.detach( );

  1175. 

  1176.                         if( this->settings.Fsk.RxContinuous == false )

  1177.                         {

  1178.                             rxTimeoutSyncWord.detach( );

  1179.                             this->settings.State = RF_IDLE;

  1180.                         }

  1181.                         else

  1182.                         {

  1183.                             // Continuous mode restart Rx chain

  1184.                             Write( REG_RXCONFIG, Read( REG_RXCONFIG ) | RF_RXCONFIG_RESTARTRXWITHOUTPLLLOCK );

  1185.                             rxTimeoutSyncWord.attach_us( mbed::callback( this, &SX1276::OnTimeoutIrq ),

  1186.                                                          this->settings.Fsk.RxSingleTimeout * 1e3 );

  1187.                         }

  1188. 

  1189.                         if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->RxError != NULL ) )

  1190.                         {

  1191.                             this->RadioEvents->RxError( );

  1192.                         }

  1193.                         this->settings.FskPacketHandler.PreambleDetected = false;

  1194.                         this->settings.FskPacketHandler.SyncWordDetected = false;

  1195.                         this->settings.FskPacketHandler.NbBytes = 0;

  1196.                         this->settings.FskPacketHandler.Size = 0;

  1197.                         break;

  1198.                     }

  1199.                 }

  1200. 

  1201.                 // Read received packet size

  1202.                 if( ( this->settings.FskPacketHandler.Size == 0 ) && ( this->settings.FskPacketHandler.NbBytes == 0 ) )

  1203.                 {

  1204.                     if( this->settings.Fsk.FixLen == false )

  1205.                     {

  1206.                         ReadFifo( ( uint8_t* )&this->settings.FskPacketHandler.Size, 1 );

  1207.                     }

  1208.                     else

  1209.                     {

  1210.                         this->settings.FskPacketHandler.Size = Read( REG_PAYLOADLENGTH );

  1211.                     }

  1212.                     ReadFifo( rxtxBuffer + this->settings.FskPacketHandler.NbBytes, this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes );

  1213.                     this->settings.FskPacketHandler.NbBytes += ( this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes );

  1214.                 }

  1215.                 else

  1216.                 {

  1217.                     ReadFifo( rxtxBuffer + this->settings.FskPacketHandler.NbBytes, this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes );

  1218.                     this->settings.FskPacketHandler.NbBytes += ( this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes );

  1219.                 }

  1220. 

  1221.                 rxTimeoutTimer.detach( );

  1222. 

  1223.                 if( this->settings.Fsk.RxContinuous == false )

  1224.                 {

  1225.                     this->settings.State = RF_IDLE;

  1226.                     rxTimeoutSyncWord.detach( );

  1227.                 }

  1228.                 else

  1229.                 {

  1230.                     // Continuous mode restart Rx chain

  1231.                     Write( REG_RXCONFIG, Read( REG_RXCONFIG ) | RF_RXCONFIG_RESTARTRXWITHOUTPLLLOCK );

  1232.                     rxTimeoutSyncWord.attach_us( mbed::callback( this, &SX1276::OnTimeoutIrq ),

  1233.                                                  this->settings.Fsk.RxSingleTimeout * 1e3 );

  1234.                 }

  1235. 

  1236.                 if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->RxDone != NULL ) )

  1237.                 {

  1238.                     this->RadioEvents->RxDone( rxtxBuffer, this->settings.FskPacketHandler.Size, this->settings.FskPacketHandler.RssiValue, 0 );

  1239.                 }

  1240.                 this->settings.FskPacketHandler.PreambleDetected = false;

  1241.                 this->settings.FskPacketHandler.SyncWordDetected = false;

  1242.                 this->settings.FskPacketHandler.NbBytes = 0;

  1243.                 this->settings.FskPacketHandler.Size = 0;

  1244.                 break;

  1245.             case MODEM_LORA:

  1246.                 {

  1247.                     int8_t snr = 0;

  1248. 

  1249.                     // Clear Irq

  1250.                     Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE );

  1251. 

  1252.                     irqFlags = Read( REG_LR_IRQFLAGS );

  1253.                     if( ( irqFlags & RFLR_IRQFLAGS_PAYLOADCRCERROR_MASK ) == RFLR_IRQFLAGS_PAYLOADCRCERROR )

  1254.                     {

  1255.                         // Clear Irq

  1256.                         Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_PAYLOADCRCERROR );

  1257. 

  1258.                         if( this->settings.LoRa.RxContinuous == false )

  1259.                         {

  1260.                             this->settings.State = RF_IDLE;

  1261.                         }

  1262.                         rxTimeoutTimer.detach( );

  1263. 

  1264.                         if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->RxError != NULL ) )

  1265.                         {

  1266.                             this->RadioEvents->RxError( );

  1267.                         }

  1268.                         break;

  1269.                     }

  1270. 

  1271.                     this->settings.LoRaPacketHandler.SnrValue = Read( REG_LR_PKTSNRVALUE );

  1272.                     if( this->settings.LoRaPacketHandler.SnrValue & 0x80 ) // The SNR sign bit is 1

  1273.                     {

  1274.                         // Invert and divide by 4

  1275.                         snr = ( ( ~this->settings.LoRaPacketHandler.SnrValue + 1 ) & 0xFF ) >> 2;

  1276.                         snr = -snr;

  1277.                     }

  1278.                     else

  1279.                     {

  1280.                         // Divide by 4

  1281.                         snr = ( this->settings.LoRaPacketHandler.SnrValue & 0xFF ) >> 2;

  1282.                     }

  1283. 

  1284.                     int16_t rssi = Read( REG_LR_PKTRSSIVALUE );

  1285.                     if( snr < 0 )

  1286.                     {

  1287.                         if( this->settings.Channel > RF_MID_BAND_THRESH )

  1288.                         {

  1289.                             this->settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_HF + rssi + ( rssi >> 4 ) +

  1290.                                                                           snr;

  1291.                         }

  1292.                         else

  1293.                         {

  1294.                             this->settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_LF + rssi + ( rssi >> 4 ) +

  1295.                                                                           snr;

  1296.                         }

  1297.                     }

  1298.                     else

  1299.                     {

  1300.                         if( this->settings.Channel > RF_MID_BAND_THRESH )

  1301.                         {

  1302.                             this->settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_HF + rssi + ( rssi >> 4 );

  1303.                         }

  1304.                         else

  1305.                         {

  1306.                             this->settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_LF + rssi + ( rssi >> 4 );

  1307.                         }

  1308.                     }

  1309. 

  1310.                     this->settings.LoRaPacketHandler.Size = Read( REG_LR_RXNBBYTES );

  1311.                     ReadFifo( rxtxBuffer, this->settings.LoRaPacketHandler.Size );

  1312. 

  1313.                     if( this->settings.LoRa.RxContinuous == false )

  1314.                     {

  1315.                         this->settings.State = RF_IDLE;

  1316.                     }

  1317.                     rxTimeoutTimer.detach( );

  1318. 

  1319.                     if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->RxDone != NULL ) )

  1320.                     {

  1321.                         this->RadioEvents->RxDone( rxtxBuffer, this->settings.LoRaPacketHandler.Size, this->settings.LoRaPacketHandler.RssiValue, this->settings.LoRaPacketHandler.SnrValue );

  1322.                     }

  1323.                 }

  1324.                 break;

  1325.             default:

  1326.                 break;

  1327.             }

  1328.             break;

  1329.         case RF_TX_RUNNING:

  1330.             txTimeoutTimer.detach( );

  1331.             // TxDone interrupt

  1332.             switch( this->settings.Modem )

  1333.             {

  1334.             case MODEM_LORA:

  1335.                 // Clear Irq

  1336.                 Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE );

  1337.                 // Intentional fall through

  1338.             case MODEM_FSK:

  1339.             default:

  1340.                 this->settings.State = RF_IDLE;

  1341.                 if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->TxDone != NULL ) )

  1342.                 {

  1343.                     this->RadioEvents->TxDone( );

  1344.                 }

  1345.                 break;

  1346.             }

  1347.             break;

  1348.         default:

  1349.             break;

  1350.     }

  1351. }

  1352. 

  1353. void SX1276::OnDio1Irq( void )

  1354. {

  1355.     switch( this->settings.State )

  1356.     {

  1357.         case RF_RX_RUNNING:

  1358.             switch( this->settings.Modem )

  1359.             {

  1360.             case MODEM_FSK:

  1361.                 // FifoLevel interrupt

  1362.                 // Read received packet size

  1363.                 if( ( this->settings.FskPacketHandler.Size == 0 ) && ( this->settings.FskPacketHandler.NbBytes == 0 ) )

  1364.                 {

  1365.                     if( this->settings.Fsk.FixLen == false )

  1366.                     {

  1367.                         ReadFifo( ( uint8_t* )&this->settings.FskPacketHandler.Size, 1 );

  1368.                     }

  1369.                     else

  1370.                     {

  1371.                         this->settings.FskPacketHandler.Size = Read( REG_PAYLOADLENGTH );

  1372.                     }

  1373.                 }

  1374. 

  1375.                 if( ( this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes ) > this->settings.FskPacketHandler.FifoThresh )

  1376.                 {

  1377.                     ReadFifo( ( rxtxBuffer + this->settings.FskPacketHandler.NbBytes ), this->settings.FskPacketHandler.FifoThresh );

  1378.                     this->settings.FskPacketHandler.NbBytes += this->settings.FskPacketHandler.FifoThresh;

  1379.                 }

  1380.                 else

  1381.                 {

  1382.                     ReadFifo( ( rxtxBuffer + this->settings.FskPacketHandler.NbBytes ), this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes );

  1383.                     this->settings.FskPacketHandler.NbBytes += ( this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes );

  1384.                 }

  1385.                 break;

  1386.             case MODEM_LORA:

  1387.                 // Sync time out

  1388.                 rxTimeoutTimer.detach( );

  1389.                 // Clear Irq

  1390.                 Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXTIMEOUT );

  1391. 

  1392.                 this->settings.State = RF_IDLE;

  1393.                 if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->RxTimeout != NULL ) )

  1394.                 {

  1395.                     this->RadioEvents->RxTimeout( );

  1396.                 }

  1397.                 break;

  1398.             default:

  1399.                 break;

  1400.             }

  1401.             break;

  1402.         case RF_TX_RUNNING:

  1403.             switch( this->settings.Modem )

  1404.             {

  1405.             case MODEM_FSK:

  1406.                 // FifoEmpty interrupt

  1407.                 if( ( this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes ) > this->settings.FskPacketHandler.ChunkSize )

  1408.                 {

  1409.                     WriteFifo( ( rxtxBuffer + this->settings.FskPacketHandler.NbBytes ), this->settings.FskPacketHandler.ChunkSize );

  1410.                     this->settings.FskPacketHandler.NbBytes += this->settings.FskPacketHandler.ChunkSize;

  1411.                 }

  1412.                 else

  1413.                 {

  1414.                     // Write the last chunk of data

  1415.                     WriteFifo( rxtxBuffer + this->settings.FskPacketHandler.NbBytes, this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes );

  1416.                     this->settings.FskPacketHandler.NbBytes += this->settings.FskPacketHandler.Size - this->settings.FskPacketHandler.NbBytes;

  1417.                 }

  1418.                 break;

  1419.             case MODEM_LORA:

  1420.                 break;

  1421.             default:

  1422.                 break;

  1423.             }

  1424.             break;

  1425.         default:

  1426.             break;

  1427.     }

  1428. }

  1429. 

  1430. void SX1276::OnDio2Irq( void )

  1431. {

  1432.     switch( this->settings.State )

  1433.     {

  1434.         case RF_RX_RUNNING:

  1435.             switch( this->settings.Modem )

  1436.             {

  1437.             case MODEM_FSK:

  1438.                 // Checks if DIO4 is connected. If it is not PreambleDtected is set to true.

  1439.                 if( this->dioIrq[4] == NULL )

  1440.                 {

  1441.                     this->settings.FskPacketHandler.PreambleDetected = true;

  1442.                 }

  1443. 

  1444.                 if( ( this->settings.FskPacketHandler.PreambleDetected == true ) && ( this->settings.FskPacketHandler.SyncWordDetected == false ) )

  1445.                 {

  1446.                     rxTimeoutSyncWord.detach( );

  1447. 

  1448.                     this->settings.FskPacketHandler.SyncWordDetected = true;

  1449. 

  1450.                     this->settings.FskPacketHandler.RssiValue = -( Read( REG_RSSIVALUE ) >> 1 );

  1451. 

  1452.                     this->settings.FskPacketHandler.AfcValue = ( int32_t )( double )( ( ( uint16_t )Read( REG_AFCMSB ) << 8 ) |

  1453.                                                                            ( uint16_t )Read( REG_AFCLSB ) ) *

  1454.                                                                            ( double )FREQ_STEP;

  1455.                     this->settings.FskPacketHandler.RxGain = ( Read( REG_LNA ) >> 5 ) & 0x07;

  1456.                 }

  1457.                 break;

  1458.             case MODEM_LORA:

  1459.                 if( this->settings.LoRa.FreqHopOn == true )

  1460.                 {

  1461.                     // Clear Irq

  1462.                     Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL );

  1463. 

  1464.                     if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->FhssChangeChannel != NULL ) )

  1465.                     {

  1466.                         this->RadioEvents->FhssChangeChannel( ( Read( REG_LR_HOPCHANNEL ) & RFLR_HOPCHANNEL_CHANNEL_MASK ) );

  1467.                     }

  1468.                 }

  1469.                 break;

  1470.             default:

  1471.                 break;

  1472.             }

  1473.             break;

  1474.         case RF_TX_RUNNING:

  1475.             switch( this->settings.Modem )

  1476.             {

  1477.             case MODEM_FSK:

  1478.                 break;

  1479.             case MODEM_LORA:

  1480.                 if( this->settings.LoRa.FreqHopOn == true )

  1481.                 {

  1482.                     // Clear Irq

  1483.                     Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL );

  1484. 

  1485.                     if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->FhssChangeChannel != NULL ) )

  1486.                     {

  1487.                         this->RadioEvents->FhssChangeChannel( ( Read( REG_LR_HOPCHANNEL ) & RFLR_HOPCHANNEL_CHANNEL_MASK ) );

  1488.                     }

  1489.                 }

  1490.                 break;

  1491.             default:

  1492.                 break;

  1493.             }

  1494.             break;

  1495.         default:

  1496.             break;

  1497.     }

  1498. }

  1499. 

  1500. void SX1276::OnDio3Irq( void )

  1501. {

  1502.     switch( this->settings.Modem )

  1503.     {

  1504.     case MODEM_FSK:

  1505.         break;

  1506.     case MODEM_LORA:

  1507.         if( ( Read( REG_LR_IRQFLAGS ) & RFLR_IRQFLAGS_CADDETECTED ) == RFLR_IRQFLAGS_CADDETECTED )

  1508.         {

  1509.             // Clear Irq

  1510.             Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_CADDETECTED | RFLR_IRQFLAGS_CADDONE );

  1511.             if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->CadDone != NULL ) )

  1512.             {

  1513.                 this->RadioEvents->CadDone( true );

  1514.             }

  1515.         }

  1516.         else

  1517.         {

  1518.             // Clear Irq

  1519.             Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_CADDONE );

  1520.             if( ( this->RadioEvents != NULL ) && ( this->RadioEvents->CadDone != NULL ) )

  1521.             {

  1522.                 this->RadioEvents->CadDone( false );

  1523.             }

  1524.         }

  1525.         break;

  1526.     default:

  1527.         break;

  1528.     }

  1529. }

  1530. 

  1531. void SX1276::OnDio4Irq( void )

  1532. {

  1533.     switch( this->settings.Modem )

  1534.     {

  1535.     case MODEM_FSK:

  1536.         {

  1537.             if( this->settings.FskPacketHandler.PreambleDetected == false )

  1538.             {

  1539.                 this->settings.FskPacketHandler.PreambleDetected = true;

  1540.             }

  1541.         }

  1542.         break;

  1543.     case MODEM_LORA:

  1544.         break;

  1545.     default:

  1546.         break;

  1547.     }

  1548. }

  1549. 

  1550. void SX1276::OnDio5Irq( void )

  1551. {

  1552.     switch( this->settings.Modem )

  1553.     {

  1554.     case MODEM_FSK:

  1555.         break;

  1556.     case MODEM_LORA:

  1557.         break;

  1558.     default:

  1559.         break;

  1560.     }

  1561. }