Line data    Source code

       1             : #include "SX1273.h"
       2             : #if !RADIOLIB_EXCLUDE_SX127X
       3             : 
       4           1 : SX1273::SX1273(Module* mod) : SX1272(mod) {
       5             : 
       6           1 : }
       7             : 
       8           0 : int16_t SX1273::begin(const ConfigLoRa_t& cfg) {
       9             :   // execute common part
      10           0 :   uint8_t version = RADIOLIB_SX1272_CHIP_VERSION;
      11           0 :   int16_t state = SX127x::begin(&version, 1, cfg.syncWord, cfg.preambleLength);
      12           0 :   RADIOLIB_ASSERT(state);
      13             : 
      14             :   // configure publicly accessible settings
      15           0 :   state = setBandwidth(cfg.bandwidth);
      16           0 :   RADIOLIB_ASSERT(state);
      17             : 
      18           0 :   state = setFrequency(cfg.frequency);
      19           0 :   RADIOLIB_ASSERT(state);
      20             : 
      21           0 :   state = setSpreadingFactor(cfg.spreadingFactor);
      22           0 :   RADIOLIB_ASSERT(state);
      23             : 
      24           0 :   state = setCodingRate(cfg.codingRate);
      25           0 :   RADIOLIB_ASSERT(state);
      26             : 
      27           0 :   state = setOutputPower(cfg.power);
      28           0 :   RADIOLIB_ASSERT(state);
      29             : 
      30           0 :   state = setGain(this->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 :   return(state);
      36             : }
      37             : 
      38           0 : int16_t SX1273::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power, uint16_t preambleLength, uint8_t gain) {
      39           0 :   ConfigLoRa_t cfg;
      40           0 :   cfg.frequency = freq;
      41           0 :   cfg.bandwidth = bw;
      42           0 :   cfg.spreadingFactor = sf;
      43           0 :   cfg.codingRate = cr;
      44           0 :   cfg.syncWord = syncWord;
      45           0 :   cfg.power = power;
      46           0 :   cfg.preambleLength = preambleLength;
      47           0 :   this->gain = gain;
      48           0 :   return(begin(cfg));
      49             : }
      50             : 
      51           1 : int16_t SX1273::setSpreadingFactor(uint8_t sf) {
      52             :   uint8_t newSpreadingFactor;
      53             : 
      54             :   // check allowed spreading factor values
      55           1 :   switch(sf) {
      56           0 :     case 6:
      57           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_6;
      58           0 :       break;
      59           0 :     case 7:
      60           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_7;
      61           0 :       break;
      62           0 :     case 8:
      63           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_8;
      64           0 :       break;
      65           0 :     case 9:
      66           0 :       newSpreadingFactor = RADIOLIB_SX127X_SF_9;
      67           0 :       break;
      68           1 :     default:
      69           1 :       return(RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
      70             :   }
      71             : 
      72             :   // set spreading factor and if successful, save the new setting
      73           0 :   int16_t state = setSpreadingFactorRaw(newSpreadingFactor);
      74           0 :   if(state == RADIOLIB_ERR_NONE) {
      75           0 :     SX127x::spreadingFactor = sf;
      76             :   }
      77             : 
      78           0 :   return(state);
      79             : }
      80             : 
      81           1 : int16_t SX1273::setDataRate(DataRate_t dr, ModemType_t modem) {
      82             :   // get the current modem
      83             :   ModemType_t currentModem;
      84           1 :   int16_t state = this->getModem(&currentModem);
      85           1 :   RADIOLIB_ASSERT(state);
      86             : 
      87             :   // switch over if the requested modem is different
      88           1 :   if(modem != RADIOLIB_MODEM_NONE && modem != currentModem) {
      89           0 :     state = this->standby();
      90           0 :     RADIOLIB_ASSERT(state);
      91           0 :     state = this->setModem(modem);
      92           0 :     RADIOLIB_ASSERT(state);
      93             :   }
      94             : 
      95           1 :   if(modem == RADIOLIB_MODEM_NONE) {
      96           1 :     modem = currentModem;
      97             :   }
      98             : 
      99             :   // select interpretation based on modem
     100           1 :   if(modem == RADIOLIB_MODEM_FSK) {
     101             :     // set the bit rate
     102           0 :     state = this->setBitRate(dr.fsk.bitRate);
     103           0 :     RADIOLIB_ASSERT(state);
     104             : 
     105             :     // set the frequency deviation
     106           0 :     state = this->setFrequencyDeviation(dr.fsk.freqDev);
     107             : 
     108           1 :   } else if(modem == RADIOLIB_MODEM_LORA) {
     109             :     // set the spreading factor
     110           1 :     state = this->setSpreadingFactor(dr.lora.spreadingFactor);
     111           1 :     RADIOLIB_ASSERT(state);
     112             : 
     113             :     // set the bandwidth
     114           0 :     state = this->setBandwidth(dr.lora.bandwidth);
     115             :   }
     116             : 
     117           0 :   return(state);
     118             : }
     119             : 
     120           1 : int16_t SX1273::checkDataRate(DataRate_t dr, ModemType_t modem) {
     121           1 :   int16_t state = RADIOLIB_ERR_UNKNOWN;
     122             : 
     123             :   // retrieve modem if not supplied
     124           1 :   if(modem == RADIOLIB_MODEM_NONE) {
     125           1 :     state = this->getModem(&modem);
     126           1 :     RADIOLIB_ASSERT(state);
     127             :   }
     128             : 
     129             :   // select interpretation based on modem
     130           1 :   if(modem == RADIOLIB_MODEM_FSK) {
     131           0 :     RADIOLIB_CHECK_RANGE(dr.fsk.bitRate, 0.5f, 300.0f, RADIOLIB_ERR_INVALID_BIT_RATE);
     132           0 :     if(!((dr.fsk.freqDev + dr.fsk.bitRate/2.0f <= 250.0f) && (dr.fsk.freqDev <= 200.0f))) {
     133           0 :       return(RADIOLIB_ERR_INVALID_FREQUENCY_DEVIATION);
     134             :     }
     135           0 :     return(RADIOLIB_ERR_NONE);
     136             : 
     137           1 :   } else if(modem == RADIOLIB_MODEM_LORA) {
     138           1 :     RADIOLIB_CHECK_RANGE(dr.lora.spreadingFactor, 6, 9, RADIOLIB_ERR_INVALID_SPREADING_FACTOR);
     139           0 :     RADIOLIB_CHECK_RANGE(dr.lora.bandwidth, 100.0f, 510.0f, RADIOLIB_ERR_INVALID_BANDWIDTH);
     140           0 :     RADIOLIB_CHECK_RANGE(dr.lora.codingRate, 4, 8, RADIOLIB_ERR_INVALID_CODING_RATE);
     141           0 :     return(RADIOLIB_ERR_NONE);
     142             :   
     143             :   }
     144             : 
     145           0 :   return(state);
     146             : }
     147             : 
     148           1 : int16_t SX1273::setModem(ModemType_t modem) {
     149           1 :   switch(modem) {
     150           0 :     case(ModemType_t::RADIOLIB_MODEM_LORA): {
     151           0 :       return(this->begin());
     152             :     } break;
     153           0 :     case(ModemType_t::RADIOLIB_MODEM_FSK): {
     154           0 :       return(this->beginFSK());
     155             :     } break;
     156           1 :     default:
     157           1 :       return(RADIOLIB_ERR_WRONG_MODEM);
     158             :   }
     159             : }
     160             : 
     161             : #endif