LCOV - code coverage report
Current view: top level - src/modules/SX127x - SX1277.cpp (source / functions) Hit Total Coverage
Test: lcov.info Lines: 30 108 27.8 %
Date: 2026-02-22 10:42:45 Functions: 6 8 75.0 %

          Line data    Source code
       1             : #include "SX1277.h"
       2             : #if !RADIOLIB_EXCLUDE_SX127X
       3             : 
       4           1 : SX1277::SX1277(Module* mod) : SX1278(mod) {
       5             : 
       6           1 : }
       7             : 
       8           0 : int16_t SX1277::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power, uint16_t preambleLength, uint8_t gain) {
       9             :   // execute common part
      10           0 :   const uint8_t versions[] = { RADIOLIB_SX1278_CHIP_VERSION, RADIOLIB_SX1278_CHIP_VERSION_ALT, RADIOLIB_SX1278_CHIP_VERSION_RFM9X };
      11           0 :   int16_t state = SX127x::begin(versions, 3, syncWord, preambleLength);
      12           0 :   RADIOLIB_ASSERT(state);
      13             : 
      14             :   // configure publicly accessible settings
      15           0 :   state = setBandwidth(bw);
      16           0 :   RADIOLIB_ASSERT(state);
      17             : 
      18           0 :   state = setFrequency(freq);
      19           0 :   RADIOLIB_ASSERT(state);
      20             : 
      21           0 :   state = setSpreadingFactor(sf);
      22           0 :   RADIOLIB_ASSERT(state);
      23             : 
      24           0 :   state = setCodingRate(cr);
      25           0 :   RADIOLIB_ASSERT(state);
      26             : 
      27           0 :   state = setOutputPower(power);
      28           0 :   RADIOLIB_ASSERT(state);
      29             : 
      30           0 :   state = setGain(gain);
      31           0 :   RADIOLIB_ASSERT(state);
      32             : 
      33             :   // set publicly accessible settings that are not a part of begin method
      34           0 :   state = setCRC(true);
      35           0 :   RADIOLIB_ASSERT(state);
      36             : 
      37           0 :   return(state);
      38             : }
      39             : 
      40           0 : int16_t SX1277::beginFSK(float freq, float br, float freqDev, float rxBw, int8_t power, uint16_t preambleLength, bool enableOOK) {
      41             :   // execute common part
      42           0 :   const uint8_t versions[] = { RADIOLIB_SX1278_CHIP_VERSION, RADIOLIB_SX1278_CHIP_VERSION_ALT, RADIOLIB_SX1278_CHIP_VERSION_RFM9X };
      43           0 :   int16_t state = SX127x::beginFSK(versions, 3, freqDev, rxBw, preambleLength, enableOOK);
      44           0 :   RADIOLIB_ASSERT(state);
      45             : 
      46             :   // configure settings not accessible by API
      47           0 :   state = configFSK();
      48           0 :   RADIOLIB_ASSERT(state);
      49             : 
      50             :   // configure publicly accessible settings
      51           0 :   state = setFrequency(freq);
      52           0 :   RADIOLIB_ASSERT(state);
      53             : 
      54           0 :   state = setBitRate(br);
      55           0 :   RADIOLIB_ASSERT(state);
      56             : 
      57           0 :   state = setOutputPower(power);
      58           0 :   RADIOLIB_ASSERT(state);
      59             : 
      60           0 :   if(enableOOK) {
      61           0 :     state = setDataShapingOOK(RADIOLIB_SHAPING_NONE);
      62           0 :     RADIOLIB_ASSERT(state);
      63             :   } else {
      64           0 :     state = setDataShaping(RADIOLIB_SHAPING_NONE);
      65           0 :     RADIOLIB_ASSERT(state);
      66             :   }
      67             : 
      68           0 :   return(state);
      69             : }
      70             : 
      71           1 : int16_t SX1277::setFrequency(float freq) {
      72           1 :   RADIOLIB_CHECK_RANGE(freq, 137.0f, 1020.0f, RADIOLIB_ERR_INVALID_FREQUENCY);
      73             : 
      74             :   // set frequency and if successful, save the new setting
      75           0 :   int16_t state = SX127x::setFrequencyRaw(freq);
      76           0 :   if(state == RADIOLIB_ERR_NONE) {
      77           0 :     SX127x::frequency = freq;
      78             :   }
      79           0 :   return(state);
      80             : }
      81             : 
      82           1 : int16_t SX1277::setSpreadingFactor(uint8_t sf) {
      83             :   uint8_t newSpreadingFactor;
      84             : 
      85             :   // check allowed spreading factor values
      86           1 :   switch(sf) {
      87           0 :     case 6:
      88           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_6;
      89           0 :       break;
      90           0 :     case 7:
      91           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_7;
      92           0 :       break;
      93           0 :     case 8:
      94           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_8;
      95           0 :       break;
      96           0 :     case 9:
      97           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_9;
      98           0 :       break;
      99           1 :     default:
     100           1 :       return(RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
     101             :   }
     102             : 
     103             :   // set spreading factor and if successful, save the new setting
     104           0 :   int16_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
     105           0 :   if(state == RADIOLIB_ERR_NONE) {
     106           0 :     SX127x::spreadingFactor = sf;
     107             :   }
     108             : 
     109           0 :   return(state);
     110             : }
     111             : 
     112           1 : int16_t SX1277::setDataRate(DataRate_t dr, ModemType_t modem) {
     113             :   // get the current modem
     114             :   ModemType_t currentModem;
     115           1 :   int16_t state = this->getModem(&currentModem);
     116           1 :   RADIOLIB_ASSERT(state);
     117             : 
     118             :   // switch over if the requested modem is different
     119           1 :   if(modem != RADIOLIB_MODEM_NONE && modem != currentModem) {
     120           0 :     state = this->standby();
     121           0 :     RADIOLIB_ASSERT(state);
     122           0 :     state = this->setModem(modem);
     123           0 :     RADIOLIB_ASSERT(state);
     124             :   }
     125             :   
     126           1 :   if(modem == RADIOLIB_MODEM_NONE) {
     127           1 :     modem = currentModem;
     128             :   }
     129             : 
     130             :   // select interpretation based on modem
     131           1 :   if(modem == RADIOLIB_MODEM_FSK) {
     132             :     // set the bit rate
     133           0 :     state = this->setBitRate(dr.fsk.bitRate);
     134           0 :     RADIOLIB_ASSERT(state);
     135             : 
     136             :     // set the frequency deviation
     137           0 :     state = this->setFrequencyDeviation(dr.fsk.freqDev);
     138             : 
     139           1 :   } else if(modem == RADIOLIB_MODEM_LORA) {
     140             :     // set the spreading factor
     141           1 :     state = this->setSpreadingFactor(dr.lora.spreadingFactor);
     142           1 :     RADIOLIB_ASSERT(state);
     143             : 
     144             :     // set the bandwidth
     145           0 :     state = this->setBandwidth(dr.lora.bandwidth);
     146             :   }
     147             : 
     148           0 :   return(state);
     149             : }
     150             : 
     151           1 : int16_t SX1277::checkDataRate(DataRate_t dr, ModemType_t modem) {
     152           1 :   int16_t state = RADIOLIB_ERR_UNKNOWN;
     153             : 
     154             :   // retrieve modem if not supplied
     155           1 :   if(modem == RADIOLIB_MODEM_NONE) {
     156           1 :     state = this->getModem(&modem);
     157           1 :     RADIOLIB_ASSERT(state);
     158             :   }
     159             :   
     160             :   // select interpretation based on modem
     161           1 :   if(modem == RADIOLIB_MODEM_FSK) {
     162           0 :     RADIOLIB_CHECK_RANGE(dr.fsk.bitRate, 0.5f, 300.0f, RADIOLIB_ERR_INVALID_BIT_RATE);
     163           0 :     if(!((dr.fsk.freqDev + dr.fsk.bitRate/2.0f <= 250.0f) && (dr.fsk.freqDev <= 200.0f))) {
     164           0 :       return(RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION);
     165             :     }
     166           0 :     return(RADIOLIB_ERR_NONE);
     167             : 
     168           1 :   } else if(modem == RADIOLIB_MODEM_LORA) {
     169           1 :     RADIOLIB_CHECK_RANGE(dr.lora.spreadingFactor, 6, 9, RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
     170           0 :     RADIOLIB_CHECK_RANGE(dr.lora.bandwidth, 0.0f, 510.0f, RADIOLIB_ERR_INVALID_BANDWIDTH);
     171           0 :     RADIOLIB_CHECK_RANGE(dr.lora.codingRate, 4, 8, RADIOLIB_ERR_INVALID_CODING_RATE);
     172           0 :     return(RADIOLIB_ERR_NONE);
     173             :   
     174             :   }
     175             : 
     176           0 :   return(state);
     177             : }
     178             : 
     179           1 : int16_t SX1277::setModem(ModemType_t modem) {
     180           1 :   switch(modem) {
     181           0 :     case(ModemType_t::RADIOLIB_MODEM_LORA): {
     182           0 :       return(this->begin());
     183             :     } break;
     184           0 :     case(ModemType_t::RADIOLIB_MODEM_FSK): {
     185           0 :       return(this->beginFSK());
     186             :     } break;
     187           1 :     default:
     188           1 :       return(RADIOLIB_ERR_WRONG_MODEM);
     189             :   }
     190             : }
     191             : 
     192             : #endif

Generated by: LCOV version 1.14