src/lib/SX127xDriver/SX127x.cpp

   1 #include "SX127x.h"
   2 #include "logging.h"
   3 #include "RFAMP_hal.h"
   4
   5 SX127xHal hal;
   6 SX127xDriver *SX127xDriver::instance = NULL;
   7
   8 RFAMP_hal RFAMP;
   9
  10 #ifdef USE_SX1276_RFO_HF
  11   #ifndef OPT_USE_SX1276_RFO_HF
  12     #define OPT_USE_SX1276_RFO_HF true
  13   #endif
  14 #else
  15   #define OPT_USE_SX1276_RFO_HF false
  16 #endif
  17
  18 const uint8_t SX127x_AllowedSyncwords[105] =
  19     {0, 5, 6, 7, 11, 12, 13, 15, 18,
  20      21, 23, 26, 29, 30, 31, 33, 34,
  21      37, 38, 39, 40, 42, 44, 50, 51,
  22      54, 55, 57, 58, 59, 61, 63, 65,
  23      67, 68, 71, 77, 78, 79, 80, 82,
  24      84, 86, 89, 92, 94, 96, 97, 99,
  25      101, 102, 105, 106, 109, 111, 113, 115,
  26      117, 118, 119, 121, 122, 124, 126, 127,
  27      129, 130, 138, 143, 161, 170, 172, 173,
  28      175, 180, 181, 182, 187, 190, 191, 192,
  29      193, 196, 199, 201, 204, 205, 208, 209,
  30      212, 213, 219, 220, 221, 223, 227, 229,
  31      235, 239, 240, 242, 243, 246, 247, 255};
  32
  33 //////////////////////////////////////////////
  34
  35 SX127xDriver::SX127xDriver(): SX12xxDriverCommon()
  36 {
  37   instance = this;
  38   // default values from datasheet
  39   currSyncWord = SX127X_SYNC_WORD;
  40   currBW =SX127x_BW_125_00_KHZ;
  41   currSF = SX127x_SF_7;
  42   currCR = SX127x_CR_4_5;
  43   currOpmode = SX127x_OPMODE_SLEEP;
  44   ModFSKorLoRa = SX127x_OPMODE_LORA;
  45   // Dummy default values which are overwritten during setup
  46   currPreambleLen = 0;
  47   PayloadLength = 8;
  48   currFreq = 0;
  49   headerExplMode = false;
  50   crcEnabled = false;
  51   lowFrequencyMode = SX1278_HIGH_FREQ;
  52   lastSuccessfulPacketRadio = SX12XX_Radio_1;
  53 }
  54
  55 bool SX127xDriver::Begin()
  56 {
  57   hal.init();
  58   hal.IsrCallback_1 = &SX127xDriver::IsrCallback_1;
  59   hal.IsrCallback_2 = &SX127xDriver::IsrCallback_2;
  60
  61   hal.reset();
  62   DBGLN("SX127x Begin");
  63
  64   RFAMP.init();
  65
  66   // currFreq must be set before calling Radio.Begin so that lowFrequencyMode can be set correctly.
  67   if (currFreq < (uint32_t)((double)525000000 / (double)FREQ_STEP))
  68   {
  69     lowFrequencyMode = SX1278_LOW_FREQ;
  70     DBGLN("Setting 'lowFrequencyMode' used for 433MHz.");
  71   }
  72
  73   SetMode(SX127x_OPMODE_STANDBY, SX12XX_Radio_All);
  74
  75   if (!DetectChip(SX12XX_Radio_1))
  76   {
  77     return false;
  78   }
  79
  80   if (GPIO_PIN_NSS_2 != UNDEF_PIN)
  81   {
  82     if (!DetectChip(SX12XX_Radio_2))
  83     {
  84       return false;
  85     }
  86   }
  87
  88   ConfigLoraDefaults();
  89   // Force the next power update
  90   pwrCurrent = PWRPENDING_NONE;
  91   SetOutputPower(0);
  92   CommitOutputPower();
  93
  94   return true;
  95 }
  96
  97 void SX127xDriver::End()
  98 {
  99   SetMode(SX127x_OPMODE_SLEEP, SX12XX_Radio_All);
 100   hal.end();
 101   RFAMP.TXRXdisable();
 102   RemoveCallbacks();
 103 }
 104
 105 void SX127xDriver::ConfigLoraDefaults()
 106 {
 107   hal.writeRegister(SX127X_REG_OP_MODE, SX127x_OPMODE_SLEEP, SX12XX_Radio_All);
 108   hal.writeRegister(SX127X_REG_OP_MODE, ModFSKorLoRa, SX12XX_Radio_All); //must be written in sleep mode
 109   SetMode(SX127x_OPMODE_STANDBY, SX12XX_Radio_All);
 110
 111   hal.writeRegister(SX127X_REG_PAYLOAD_LENGTH, PayloadLength, SX12XX_Radio_All);
 112   SetSyncWord(currSyncWord);
 113   hal.writeRegister(SX127X_REG_FIFO_TX_BASE_ADDR, SX127X_FIFO_TX_BASE_ADDR_MAX, SX12XX_Radio_All);
 114   hal.writeRegister(SX127X_REG_FIFO_RX_BASE_ADDR, SX127X_FIFO_RX_BASE_ADDR_MAX, SX12XX_Radio_All);
 115   hal.writeRegisterBits(SX127X_REG_DIO_MAPPING_1, SX127X_DIO0_RXTX_DONE, SX127X_DIO0_MASK, SX12XX_Radio_All); //undocumented "hack", looking at Table 18 from datasheet SX127X_REG_DIO_MAPPING_1 = 11 appears to be unspported by infact it generates an intterupt on both RXdone and TXdone, this saves switching modes.
 116   hal.writeRegister(SX127X_REG_LNA, SX127X_LNA_BOOST_ON, SX12XX_Radio_All);
 117   hal.writeRegister(SX1278_REG_MODEM_CONFIG_3, SX1278_AGC_AUTO_ON | SX1278_LOW_DATA_RATE_OPT_OFF, SX12XX_Radio_All);
 118   hal.writeRegisterBits(SX127X_REG_OCP, SX127X_OCP_ON | SX127X_OCP_150MA, SX127X_OCP_MASK, SX12XX_Radio_All); //150ma max current
 119   SetPreambleLength(SX127X_PREAMBLE_LENGTH_LSB);
 120 }
 121
 122 void SX127xDriver::SetBandwidthCodingRate(SX127x_Bandwidth bw, SX127x_CodingRate cr)
 123 {
 124   if ((currBW != bw) || (currCR != cr))
 125   {
 126     if (currSF == SX127x_SF_6) // set SF6 optimizations
 127     {
 128       hal.writeRegister(SX127X_REG_MODEM_CONFIG_1, bw | cr | SX127x_HEADER_IMPL_MODE, SX12XX_Radio_All);
 129       SetCRCMode(false);
 130     }
 131     else
 132     {
 133       if (headerExplMode)
 134       {
 135         hal.writeRegister(SX127X_REG_MODEM_CONFIG_1, bw | cr | SX127x_HEADER_EXPL_MODE, SX12XX_Radio_All);
 136       }
 137       else
 138       {
 139         hal.writeRegister(SX127X_REG_MODEM_CONFIG_1, bw | cr | SX127x_HEADER_IMPL_MODE, SX12XX_Radio_All);
 140       }
 141       SetCRCMode(crcEnabled);
 142     }
 143
 144     #if !defined(RADIO_SX1272) //does not apply to SX1272
 145       if (bw == SX127x_BW_500_00_KHZ)
 146       {
 147         //data-sheet errata recommendation http://caxapa.ru/thumbs/972894/SX1276_77_8_ErrataNote_1.1_STD.pdf
 148         hal.writeRegister(0x36, 0x02, SX12XX_Radio_All);
 149         hal.writeRegister(0x3a, lowFrequencyMode ? 0x7F : 0x64, SX12XX_Radio_All);
 150       }
 151       else
 152       {
 153         hal.writeRegister(0x36, 0x03, SX12XX_Radio_All);
 154       }
 155     #endif
 156
 157     currCR = cr;
 158     currBW = bw;
 159   }
 160 }
 161
 162 void SX127xDriver::SetCRCMode(bool on)
 163 {
 164   if(on)
 165   {
 166     #if defined(RADIO_SX1272)
 167       hal.writeRegisterBits(SX127X_REG_MODEM_CONFIG_1, SX1272_RX_CRC_MODE_ON, SX1272_RX_CRC_MODE_MASK, SX12XX_Radio_All);
 168     #else
 169       hal.writeRegisterBits(SX127X_REG_MODEM_CONFIG_2, SX1278_RX_CRC_MODE_ON, SX1278_RX_CRC_MODE_MASK, SX12XX_Radio_All);
 170     #endif
 171   }
 172   else
 173   {
 174     #if defined(RADIO_SX1272)
 175       hal.writeRegisterBits(SX127X_REG_MODEM_CONFIG_1, SX1272_RX_CRC_MODE_OFF, SX1272_RX_CRC_MODE_MASK, SX12XX_Radio_All);
 176     #else
 177       hal.writeRegisterBits(SX127X_REG_MODEM_CONFIG_2, SX1278_RX_CRC_MODE_OFF, SX1278_RX_CRC_MODE_MASK, SX12XX_Radio_All);
 178     #endif
 179   }
 180 }
 181
 182 bool SyncWordOk(uint8_t syncWord)
 183 {
 184   for (unsigned int i = 0; i < sizeof(SX127x_AllowedSyncwords); i++)
 185   {
 186     if (syncWord == SX127x_AllowedSyncwords[i])
 187     {
 188       return true;
 189     }
 190   }
 191   return false;
 192 }
 193
 194 void SX127xDriver::SetSyncWord(uint8_t syncWord)
 195 {
 196   uint8_t _syncWord = syncWord;
 197
 198   while (SyncWordOk(_syncWord) == false)
 199   {
 200     _syncWord++;
 201   }
 202
 203   if(syncWord != _syncWord){
 204     DBGLN("Using syncword: %d instead of: %d", _syncWord, syncWord);
 205   }
 206
 207   hal.writeRegister(SX127X_REG_SYNC_WORD, _syncWord, SX12XX_Radio_All);
 208   currSyncWord = _syncWord;
 209 }
 210
 211 /***
 212  * @brief: Schedule an output power change after the next transmit
 213  * The radio must be in SX127x_OPMODE_STANDBY to change the power
 214  ***/
 215 void SX127xDriver::SetOutputPower(uint8_t Power)
 216 {
 217   uint8_t pwrNew;
 218   if (OPT_USE_SX1276_RFO_HF)
 219   {
 220     pwrNew = SX127X_PA_SELECT_RFO | SX127X_MAX_OUTPUT_POWER_RFO_HF | Power;
 221   }
 222   else
 223   {
 224     pwrNew = SX127X_PA_SELECT_BOOST | SX127X_MAX_OUTPUT_POWER | Power;
 225   }
 226
 227   if ((pwrPending == PWRPENDING_NONE && pwrCurrent != pwrNew) || pwrPending != pwrNew)
 228   {
 229     pwrPending = pwrNew;
 230   }
 231 }
 232
 233 void ICACHE_RAM_ATTR SX127xDriver::CommitOutputPower()
 234 {
 235   if (pwrPending == PWRPENDING_NONE)
 236     return;
 237
 238   pwrCurrent = pwrPending;
 239   pwrPending = PWRPENDING_NONE;
 240   hal.writeRegister(SX127X_REG_PA_CONFIG, pwrCurrent, SX12XX_Radio_All);
 241 }
 242
 243 void SX127xDriver::SetPreambleLength(uint8_t PreambleLen)
 244 {
 245   if (currPreambleLen != PreambleLen)
 246   {
 247     hal.writeRegister(SX127X_REG_PREAMBLE_LSB, PreambleLen, SX12XX_Radio_All);
 248     currPreambleLen = PreambleLen;
 249   }
 250 }
 251
 252 void SX127xDriver::SetSpreadingFactor(SX127x_SpreadingFactor sf)
 253 {
 254   if (currSF != sf)
 255   {
 256     hal.writeRegisterBits(SX127X_REG_MODEM_CONFIG_2, sf | SX127X_TX_MODE_SINGLE,  SX127X_SPREADING_FACTOR_MASK | SX127X_TX_MODE_MASK, SX12XX_Radio_All);
 257     if (sf == SX127x_SF_6)
 258     {
 259       hal.writeRegisterBits(SX127X_REG_DETECT_OPTIMIZE, SX127X_DETECT_OPTIMIZE_SF_6, SX127X_DETECT_OPTIMIZE_SF_MASK, SX12XX_Radio_All);
 260       hal.writeRegister(SX127X_REG_DETECTION_THRESHOLD, SX127X_DETECTION_THRESHOLD_SF_6, SX12XX_Radio_All);
 261     }
 262     else
 263     {
 264       hal.writeRegisterBits(SX127X_REG_DETECT_OPTIMIZE, SX127X_DETECT_OPTIMIZE_SF_7_12, SX127X_DETECT_OPTIMIZE_SF_MASK, SX12XX_Radio_All);
 265       hal.writeRegister(SX127X_REG_DETECTION_THRESHOLD, SX127X_DETECTION_THRESHOLD_SF_7_12, SX12XX_Radio_All);
 266     }
 267     currSF = sf;
 268   }
 269 }
 270
 271 void ICACHE_RAM_ATTR SX127xDriver::SetFrequencyHz(uint32_t freq, SX12XX_Radio_Number_t radioNumber)
 272 {
 273   int32_t regfreq = ((uint32_t)((double)freq / (double)FREQ_STEP));
 274
 275   SetFrequencyReg(regfreq, radioNumber);
 276 }
 277
 278 void ICACHE_RAM_ATTR SX127xDriver::SetFrequencyReg(uint32_t regfreq, SX12XX_Radio_Number_t radioNumber)
 279 {
 280   currFreq = regfreq;
 281   SetMode(SX127x_OPMODE_STANDBY, radioNumber);
 282
 283   uint8_t FRQ_MSB = (uint8_t)((regfreq >> 16) & 0xFF);
 284   uint8_t FRQ_MID = (uint8_t)((regfreq >> 8) & 0xFF);
 285   uint8_t FRQ_LSB = (uint8_t)(regfreq & 0xFF);
 286
 287   WORD_ALIGNED_ATTR uint8_t outbuff[3] = {FRQ_MSB, FRQ_MID, FRQ_LSB}; //check speedup
 288
 289   hal.writeRegister(SX127X_REG_FRF_MSB, outbuff, sizeof(outbuff), radioNumber);
 290 }
 291
 292 void ICACHE_RAM_ATTR SX127xDriver::SetRxTimeoutUs(uint32_t interval)
 293 {
 294   timeoutSymbols = 0; // no timeout i.e. use continuous mode
 295   if (interval)
 296   {
 297     unsigned int spread = 0;
 298     switch (currSF)
 299     {
 300     case SX127x_SF_6:
 301       spread = 6;
 302       break;
 303     case SX127x_SF_7:
 304       spread = 7;
 305       break;
 306     case SX127x_SF_8:
 307       spread = 8;
 308       break;
 309     case SX127x_SF_9:
 310       spread = 9;
 311       break;
 312     case SX127x_SF_10:
 313       spread = 10;
 314       break;
 315     case SX127x_SF_11:
 316       spread = 11;
 317       break;
 318     case SX127x_SF_12:
 319       spread = 12;
 320       break;
 321     }
 322     uint32_t symbolTimeUs = ((uint32_t)(1 << spread)) * 1000000 / GetCurrBandwidth();
 323     timeoutSymbols = interval / symbolTimeUs;
 324     hal.writeRegisterBits(SX127X_REG_SYMB_TIMEOUT_MSB, timeoutSymbols >> 8, SX127X_REG_SYMB_TIMEOUT_MSB_MASK, SX12XX_Radio_All);  // set the timeout MSB
 325     hal.writeRegister(SX127X_REG_SYMB_TIMEOUT_LSB, timeoutSymbols & 0xFF, SX12XX_Radio_All);
 326     DBGLN("SetRxTimeout(%u), symbolTime=%uus symbols=%u", interval, (uint32_t)symbolTimeUs, timeoutSymbols)
 327   }
 328 }
 329
 330 bool SX127xDriver::DetectChip(SX12XX_Radio_Number_t radioNumber)
 331 {
 332   DBG("Detecting radio %x... ", radioNumber);
 333   uint8_t i = 0;
 334   bool flagFound = false;
 335   while ((i < 3) && !flagFound)
 336   {
 337     uint8_t version = hal.readRegister(SX127X_REG_VERSION, radioNumber);
 338     DBG("%x", version);
 339     if (version == SX127X_VERSION)
 340     {
 341       flagFound = true;
 342     }
 343     else
 344     {
 345       DBGLN(" not found! (%d of 3 tries) REG_VERSION == 0x%x", i+1, version);
 346       delay(200);
 347       i++;
 348     }
 349   }
 350
 351   if (!flagFound)
 352   {
 353     DBGLN(" not found!");
 354     return false;
 355   }
 356   else
 357   {
 358     DBGLN(" found! (match by REG_VERSION == 0x%x", SX127X_VERSION);
 359   }
 360   return true;
 361 }
 362
 363 /////////////////////////////////////TX functions/////////////////////////////////////////
 364
 365 void ICACHE_RAM_ATTR SX127xDriver::TXnbISR()
 366 {
 367   currOpmode = SX127x_OPMODE_STANDBY; //goes into standby after transmission
 368   //TXdoneMicros = micros();
 369   // The power level must be changed when in SX127x_OPMODE_STANDBY, so this lags power
 370   // changes by at most 1 packet, but does not interrupt any pending RX/TX
 371   CommitOutputPower();
 372   TXdoneCallback();
 373 }
 374
 375 void ICACHE_RAM_ATTR SX127xDriver::TXnb(uint8_t * data, uint8_t size, SX12XX_Radio_Number_t radioNumber)
 376 {
 377   // if (currOpmode == SX127x_OPMODE_TX)
 378   // {
 379   //   DBGLN("abort TX");
 380   //   return; // we were already TXing so abort. this should never happen!!!
 381   // }
 382   SetMode(SX127x_OPMODE_STANDBY, SX12XX_Radio_All);
 383
 384   if (radioNumber == SX12XX_Radio_Default)
 385   {
 386       radioNumber = lastSuccessfulPacketRadio;
 387   }
 388
 389   RFAMP.TXenable(radioNumber);
 390   hal.writeRegister(SX127X_REG_FIFO_ADDR_PTR, SX127X_FIFO_TX_BASE_ADDR_MAX, radioNumber);
 391   hal.writeRegister(SX127X_REG_FIFO, data, size, radioNumber);
 392
 393   SetMode(SX127x_OPMODE_TX, radioNumber);
 394 }
 395
 396 ///////////////////////////////////RX Functions Non-Blocking///////////////////////////////////////////
 397
 398 bool ICACHE_RAM_ATTR SX127xDriver::RXnbISR(SX12XX_Radio_Number_t radioNumber)
 399 {
 400   uint8_t const FIFOaddr = hal.readRegister(SX127X_REG_FIFO_RX_CURRENT_ADDR, radioNumber);
 401   hal.writeRegister(SX127X_REG_FIFO_ADDR_PTR, FIFOaddr, radioNumber);
 402   hal.readRegister(SX127X_REG_FIFO, RXdataBuffer, PayloadLength, radioNumber);
 403
 404   if (timeoutSymbols)
 405   {
 406     // From page 42 of the datasheet rev 7
 407     // In Rx Single mode, the device will return to Standby mode as soon as the interrupt occurs
 408     currOpmode = SX127x_OPMODE_STANDBY;
 409   }
 410
 411   return RXdoneCallback(SX12XX_RX_OK);
 412 }
 413
 414 void ICACHE_RAM_ATTR SX127xDriver::RXnb()
 415 {
 416   RFAMP.RXenable();
 417
 418   if (timeoutSymbols)
 419   {
 420     SetMode(SX127x_OPMODE_RXSINGLE, SX12XX_Radio_All);
 421   }
 422   else
 423   {
 424     SetMode(SX127x_OPMODE_RXCONTINUOUS, SX12XX_Radio_All);
 425   }
 426 }
 427
 428 void ICACHE_RAM_ATTR SX127xDriver::GetLastPacketStats()
 429 {
 430   LastPacketRSSI = GetLastPacketRSSI();
 431   LastPacketSNRRaw = GetLastPacketSNRRaw();
 432   // https://www.mouser.com/datasheet/2/761/sx1276-1278113.pdf
 433   // Section 3.5.5 (page 87)
 434   int8_t negOffset = (LastPacketSNRRaw < 0) ? (LastPacketSNRRaw / RADIO_SNR_SCALE) : 0;
 435   LastPacketRSSI += negOffset;
 436 }
 437
 438 void ICACHE_RAM_ATTR SX127xDriver::SetMode(SX127x_RadioOPmodes mode, SX12XX_Radio_Number_t radioNumber)
 439 {
 440   /*
 441   Comment out since it is difficult to keep track of dual radios.
 442   When checking SPI it is also useful to see every possible SPI transaction to make sure it fits when required.
 443   */
 444   // if (mode == currOpmode)
 445   // {
 446   //    return;
 447   // }
 448
 449   hal.writeRegister(SX127X_REG_OP_MODE, mode | lowFrequencyMode, radioNumber);
 450   currOpmode = mode;
 451 }
 452
 453 void SX127xDriver::Config(uint8_t bw, uint8_t sf, uint8_t cr, uint32_t freq, uint8_t preambleLen, bool InvertIQ, uint8_t _PayloadLength, uint32_t interval)
 454 {
 455   Config(bw, sf, cr, freq, preambleLen, currSyncWord, InvertIQ, _PayloadLength, interval);
 456 }
 457
 458 void SX127xDriver::Config(uint8_t bw, uint8_t sf, uint8_t cr, uint32_t freq, uint8_t preambleLen, uint8_t syncWord, bool InvertIQ, uint8_t _PayloadLength, uint32_t interval)
 459 {
 460   PayloadLength = _PayloadLength;
 461   ConfigLoraDefaults();
 462   SetPreambleLength(preambleLen);
 463   SetSpreadingFactor((SX127x_SpreadingFactor)sf);
 464   SetBandwidthCodingRate((SX127x_Bandwidth)bw, (SX127x_CodingRate)cr);
 465   SetFrequencyReg(freq);
 466   SetRxTimeoutUs(interval);
 467 }
 468
 469 uint32_t ICACHE_RAM_ATTR SX127xDriver::GetCurrBandwidth()
 470 {
 471   switch (currBW)
 472   {
 473   case SX127x_BW_7_80_KHZ:
 474     return 7.8E3;
 475   case SX127x_BW_10_40_KHZ:
 476     return 10.4E3;
 477   case SX127x_BW_15_60_KHZ:
 478     return 15.6E3;
 479   case SX127x_BW_20_80_KHZ:
 480     return 20.8E3;
 481   case SX127x_BW_31_25_KHZ:
 482     return 31.25E3;
 483   case SX127x_BW_41_70_KHZ:
 484     return 41.7E3;
 485   case SX127x_BW_62_50_KHZ:
 486     return 62.5E3;
 487   case SX127x_BW_125_00_KHZ:
 488     return 125E3;
 489   case SX127x_BW_250_00_KHZ:
 490     return 250E3;
 491   case SX127x_BW_500_00_KHZ:
 492     return 500E3;
 493   }
 494   return -1;
 495 }
 496
 497 uint32_t ICACHE_RAM_ATTR SX127xDriver::GetCurrBandwidthNormalisedShifted() // this is basically just used for speedier calc of the freq offset, pre compiled for 32mhz xtal
 498 {
 499
 500   switch (currBW)
 501   {
 502   case SX127x_BW_7_80_KHZ:
 503     return 1026;
 504   case SX127x_BW_10_40_KHZ:
 505     return 769;
 506   case SX127x_BW_15_60_KHZ:
 507     return 513;
 508   case SX127x_BW_20_80_KHZ:
 509     return 385;
 510   case SX127x_BW_31_25_KHZ:
 511     return 256;
 512   case SX127x_BW_41_70_KHZ:
 513     return 192;
 514   case SX127x_BW_62_50_KHZ:
 515     return 128;
 516   case SX127x_BW_125_00_KHZ:
 517     return 64;
 518   case SX127x_BW_250_00_KHZ:
 519     return 32;
 520   case SX127x_BW_500_00_KHZ:
 521     return 16;
 522   }
 523   return -1;
 524 }
 525
 526 /**
 527  * Set the PPMcorrection register to adjust data rate to frequency error
 528  * @param offset is in Hz or FREQ_STEP (FREQ_HZ_TO_REG_VAL) units, whichever
 529  *    was used to SetFrequencyHz/SetFrequencyReg
 530  */
 531 void ICACHE_RAM_ATTR SX127xDriver::SetPPMoffsetReg(int32_t offset)
 532 {
 533   int8_t offsetPPM = (offset * 1e6 / currFreq) * 95 / 100;
 534   hal.writeRegister(SX127x_PPMOFFSET, (uint8_t)offsetPPM, processingPacketRadio);
 535 }
 536
 537 bool ICACHE_RAM_ATTR SX127xDriver::GetFrequencyErrorbool()
 538 {
 539   return (hal.readRegister(SX127X_REG_FEI_MSB, processingPacketRadio) & 0b1000) >> 3; // returns true if pos freq error, neg if false
 540 }
 541
 542 int32_t ICACHE_RAM_ATTR SX127xDriver::GetFrequencyError()
 543 {
 544
 545   WORD_ALIGNED_ATTR uint8_t reg[3] = {0x0, 0x0, 0x0};
 546   hal.readRegister(SX127X_REG_FEI_MSB, reg, sizeof(reg), processingPacketRadio);
 547
 548   uint32_t RegFei = ((reg[0] & 0b0111) << 16) + (reg[1] << 8) + reg[2];
 549
 550   int32_t intFreqError = RegFei;
 551
 552   if ((reg[0] & 0b1000) >> 3)
 553   {
 554     intFreqError -= 524288; // Sign bit is on
 555   }
 556
 557   int32_t fErrorHZ = (intFreqError >> 3) * (SX127xDriver::GetCurrBandwidthNormalisedShifted()); // bit shift hackery so we don't have to use floaty bois; the >> 3 is intentional and is a simplification of the formula on page 114 of sx1276 datasheet
 558   fErrorHZ >>= 4;
 559
 560   return fErrorHZ;
 561 }
 562
 563 uint8_t ICACHE_RAM_ATTR SX127xDriver::UnsignedGetLastPacketRSSI(SX12XX_Radio_Number_t radioNumber)
 564 {
 565   return hal.readRegister(SX127X_REG_PKT_RSSI_VALUE, radioNumber);
 566 }
 567
 568 int8_t ICACHE_RAM_ATTR SX127xDriver::GetLastPacketRSSI()
 569 {
 570   return ((lowFrequencyMode ? -164 : -157) + hal.readRegister(SX127X_REG_PKT_RSSI_VALUE, processingPacketRadio));
 571 }
 572
 573 int8_t ICACHE_RAM_ATTR SX127xDriver::GetCurrRSSI(SX12XX_Radio_Number_t radioNumber)
 574 {
 575   return ((lowFrequencyMode ? -164 : -157) + hal.readRegister(SX127X_REG_RSSI_VALUE, radioNumber));
 576 }
 577
 578 int8_t ICACHE_RAM_ATTR SX127xDriver::GetLastPacketSNRRaw()
 579 {
 580   return (int8_t)hal.readRegister(SX127X_REG_PKT_SNR_VALUE, processingPacketRadio);
 581 }
 582
 583 uint8_t ICACHE_RAM_ATTR SX127xDriver::GetIrqFlags(SX12XX_Radio_Number_t radioNumber)
 584 {
 585   return hal.readRegister(SX127X_REG_IRQ_FLAGS, radioNumber);
 586 }
 587
 588 void ICACHE_RAM_ATTR SX127xDriver::ClearIrqFlags(SX12XX_Radio_Number_t radioNumber)
 589 {
 590   hal.writeRegister(SX127X_REG_IRQ_FLAGS, SX127X_CLEAR_IRQ_FLAG_ALL, radioNumber);
 591 }
 592
 593 void ICACHE_RAM_ATTR SX127xDriver::IsrCallback_1()
 594 {
 595     instance->IsrCallback(SX12XX_Radio_1);
 596 }
 597
 598 void ICACHE_RAM_ATTR SX127xDriver::IsrCallback_2()
 599 {
 600     instance->IsrCallback(SX12XX_Radio_2);
 601 }
 602
 603 void ICACHE_RAM_ATTR SX127xDriver::IsrCallback(SX12XX_Radio_Number_t radioNumber)
 604 {
 605     instance->processingPacketRadio = radioNumber;
 606     SX12XX_Radio_Number_t irqClearRadio = radioNumber;
 607
 608     uint8_t irqStatus = instance->GetIrqFlags(radioNumber);
 609     if (irqStatus & SX127X_CLEAR_IRQ_FLAG_TX_DONE)
 610     {
 611         RFAMP.TXRXdisable();
 612         instance->TXnbISR();
 613         irqClearRadio = SX12XX_Radio_All;
 614     }
 615     else if (irqStatus & SX127X_CLEAR_IRQ_FLAG_RX_DONE)
 616     {
 617         if (instance->RXnbISR(radioNumber))
 618         {
 619             instance->lastSuccessfulPacketRadio = radioNumber;
 620             irqClearRadio = SX12XX_Radio_All;
 621         }
 622
 623     }
 624     else if (irqStatus == SX127X_CLEAR_IRQ_FLAG_NONE)
 625     {
 626         return;
 627     }
 628
 629     instance->ClearIrqFlags(irqClearRadio);
 630 }
 631
 632 // int16_t MeasureNoiseFloor() TODO disabled for now
 633 // {
 634 //     int NUM_READS = RSSI_FLOOR_NUM_READS * FHSSgetChannelCount();
 635 //     float returnval = 0;
 636
 637 //     for (uint32_t freq = 0; freq < FHSSgetChannelCount(); freq++)
 638 //     {
 639 //         FHSSsetCurrIndex(freq);
 640 //         Radio.SetMode(SX127X_CAD);
 641
 642 //         for (int i = 0; i < RSSI_FLOOR_NUM_READS; i++)
 643 //         {
 644 //             returnval = returnval + Radio.GetCurrRSSI();
 645 //             delay(5);
 646 //         }
 647 //     }
 648 //     returnval = returnval / NUM_READS;
 649 //     return (returnval);
 650 // }
 651
 652 // uint8_t SX127xDriver::RunCAD() TODO
 653 // {
 654 //   SetMode(SX127X_STANDBY);
 655
 656 //   hal.writeRegisterBits(SX127X_REG_DIO_MAPPING_1, SX127X_DIO0_CAD_DONE | SX127X_DIO1_CAD_DETECTED, 7, 4);
 657
 658 //   SetMode(SX127X_CAD);
 659 //   ClearIrqFlags();
 660
 661 //   uint32_t startTime = millis();
 662
 663 //   while (!digitalRead(SX127x_dio0))
 664 //   {
 665 //     if (millis() > (startTime + 500))
 666 //     {
 667 //       return (CHANNEL_FREE);
 668 //     }
 669 //     else
 670 //     {
 671 //       //yield();
 672 //       if (digitalRead(SX127x_dio1))
 673 //       {
 674 //         ClearIrqFlags();
 675 //         return (PREAMBLE_DETECTED);
 676 //       }
 677 //     }
 678 //   }
 679
 680 //   ClearIrqFlags();
 681 //   return (CHANNEL_FREE);
 682 // }