Line data    Source code

       1             : #include "LR2021.h"
       2             : 
       3             : #include "../LR11x0/LR_common.h"
       4             : 
       5             : #include <string.h>
       6             : #include <math.h>
       7             : 
       8             : #if !RADIOLIB_EXCLUDE_LR2021
       9             : 
      10           0 : int16_t LR2021::setLoRaModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro) {
      11             :   // calculate symbol length and enable low data rate optimization, if auto-configuration is enabled
      12           0 :   if(this->ldroAuto) {
      13           0 :     float symbolLength = (float)(uint32_t(1) << this->spreadingFactor) / (float)this->bandwidthKhz;
      14           0 :     if(symbolLength >= 16.0f) {
      15           0 :       this->ldrOptimize = RADIOLIB_LR2021_LORA_LDRO_ENABLED;
      16             :     } else {
      17           0 :       this->ldrOptimize = RADIOLIB_LR2021_LORA_LDRO_DISABLED;
      18             :     }
      19             :   } else {
      20           0 :     this->ldrOptimize = ldro;
      21             :   }
      22             : 
      23           0 :   uint8_t buff[] = { (uint8_t)(((sf & 0x0F) << 4) | (bw & 0x0F)), (uint8_t)(((cr & 0x0F) << 4) | this->ldrOptimize) };
      24           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_MODULATION_PARAMS, true, buff, sizeof(buff)));
      25             : }
      26             : 
      27           0 : int16_t LR2021::setLoRaPacketParams(uint16_t preambleLen, uint8_t hdrType, uint8_t payloadLen, uint8_t crcType, uint8_t invertIQ) {
      28             :   uint8_t buff[] = { 
      29           0 :     (uint8_t)((preambleLen >> 8) & 0xFF), (uint8_t)(preambleLen & 0xFF), payloadLen,
      30           0 :     (uint8_t)(((hdrType & 0x01) << 2) | ((crcType & 0x01) << 1) | (invertIQ & 0x01)),
      31           0 :   };
      32           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_PACKET_PARAMS, true, buff, sizeof(buff)));
      33             : }
      34             : 
      35           0 : int16_t LR2021::setLoRaSynchTimeout(uint8_t numSymbols, bool format) {
      36           0 :   uint8_t buff[] = { numSymbols, (uint8_t)format };
      37           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SYNCH_TIMEOUT, true, buff, sizeof(buff)));
      38             : }
      39             : 
      40           0 : int16_t LR2021::setLoRaSyncword(uint8_t syncword) {
      41           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SYNCWORD, true, &syncword, sizeof(syncword)));
      42             : }
      43             : 
      44           0 : int16_t LR2021::setLoRaSideDetConfig(uint8_t* configs, size_t numSideDets) {
      45           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SIDE_DET_CONFIG, true, configs, numSideDets));
      46             : }
      47             : 
      48           0 : int16_t LR2021::setLoRaSideDetSyncword(uint8_t* syncwords, size_t numSideDets) {
      49           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SIDE_DET_SYNCWORD, true, syncwords, numSideDets));
      50             : }
      51             : 
      52           0 : int16_t LR2021::setLoRaCadParams(uint8_t numSymbols, bool preambleOnly, uint8_t pnrDelta, uint8_t cadExitMode, uint32_t timeout, uint8_t detPeak) {
      53             :   uint8_t buff[] = {
      54           0 :     numSymbols, (uint8_t)(((uint8_t)preambleOnly << 4) | (pnrDelta & 0x0F)), cadExitMode, 
      55           0 :     (uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF),
      56           0 :     (uint8_t)(detPeak & 0x7F)
      57           0 :   };
      58           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_CAD_PARAMS, true, buff, sizeof(buff)));
      59             : }
      60             : 
      61           0 : int16_t LR2021::setLoRaCad(void) {
      62           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_CAD, true, NULL, 0));
      63             : }
      64             : 
      65           0 : int16_t LR2021::getLoRaRxStats(uint16_t* pktRxTotal, uint16_t* pktCrcError, uint16_t* headerCrcError, uint16_t* falseSynch) {
      66           0 :   uint8_t buff[8] = { 0 };
      67           0 :   int16_t state = this->SPIcommand(RADIOLIB_LR2021_CMD_GET_LORA_RX_STATS, false, buff, sizeof(buff));
      68           0 :   if(pktRxTotal) { *pktRxTotal = ((uint16_t)(buff[0]) << 8) | (uint16_t)buff[1]; }
      69           0 :   if(pktCrcError) { *pktCrcError = ((uint16_t)(buff[2]) << 8) | (uint16_t)buff[3]; }
      70           0 :   if(headerCrcError) { *headerCrcError = ((uint16_t)(buff[4]) << 8) | (uint16_t)buff[5]; }
      71           0 :   if(falseSynch) { *falseSynch = ((uint16_t)(buff[7]) << 8) | (uint16_t)buff[6]; }
      72           0 :   return(state);
      73             : }
      74             : 
      75           0 : int16_t LR2021::getLoRaPacketStatus(uint8_t* crc, uint8_t* cr, uint8_t* packetLen, float* snrPacket, float* rssiPacket, float* rssiSignalPacket) {
      76           0 :   uint8_t buff[6] = { 0 };
      77           0 :   int16_t state = this->SPIcommand(RADIOLIB_LR2021_CMD_GET_LORA_PACKET_STATUS, false, buff, sizeof(buff));
      78             :   uint16_t raw;
      79           0 :   if(crc) { *crc = (buff[0] & 0x10) >> 4; }
      80           0 :   if(cr) { *cr = buff[0] & 0x0F; }
      81           0 :   if(packetLen) { *packetLen = buff[1]; }
      82           0 :   if(snrPacket) { *snrPacket = (float)((int8_t)buff[2]) / 4.0f; }
      83           0 :   if(rssiPacket) {
      84           0 :     raw = (uint16_t)buff[3] << 1;
      85           0 :     raw |= (buff[5] & 0x02) >> 1;
      86           0 :     *rssiPacket = (float)raw / -2.0f;
      87             :   }
      88           0 :   if(rssiSignalPacket) {
      89           0 :     raw = (uint16_t)buff[4] << 1;
      90           0 :     raw |= buff[5] & 0x01;
      91           0 :     *rssiSignalPacket = (float)raw / -2.0f;
      92             :   }
      93           0 :   return(state);
      94             : }
      95             : 
      96           0 : int16_t LR2021::setLoRaAddress(uint8_t addrLen, uint8_t addrPos, const uint8_t* addr) {
      97           0 :   if(addrLen > 8) { return(RADIOLIB_ERR_UNKNOWN); }
      98           0 :   uint8_t buff[9] = { (uint8_t)(((addrLen & 0x0F) << 4) | (addrPos & 0x0F)) };
      99           0 :   memcpy(&buff[1], addr, addrLen);
     100           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_ADDRESS, true, buff, sizeof(buff)));
     101             : }
     102             : 
     103           0 : int16_t LR2021::setLoRaHopping(uint8_t hopCtrl, uint16_t hopPeriod, const uint32_t* freqHops, size_t numFreqHops) {
     104           0 :   if(numFreqHops > 40) { return(RADIOLIB_ERR_UNKNOWN); }
     105           0 :   uint8_t buff[2 + 160] = { (uint8_t)(hopCtrl | ((hopPeriod & 0xF00) >> 8)), (uint8_t)(hopPeriod & 0xFF) };
     106           0 :   for(uint8_t i = 0; i < numFreqHops; i++) {
     107           0 :     buff[i + 2] = (freqHops[i] >> 24) & 0xFF;
     108           0 :     buff[i + 3] = (freqHops[i] >> 16) & 0xFF;
     109           0 :     buff[i + 4] = (freqHops[i] >> 8) & 0xFF;
     110           0 :     buff[i + 5] = freqHops[i] & 0xFF;
     111             :   }
     112           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_HOPPING, true, buff, sizeof(buff)));
     113             : }
     114             : 
     115           0 : int16_t LR2021::setLoRaTxSync(uint8_t function, uint8_t dioNum) {
     116           0 :   uint8_t buff[] = { (uint8_t)(function | (dioNum & 0x3F)) };
     117           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_TX_SYNC, true, buff, sizeof(buff)));
     118             : }
     119             : 
     120           0 : int16_t LR2021::setLoRaSideDetCad(const uint8_t* pnrDelta, const uint8_t* detPeak, size_t numSideDets) {
     121           0 :   uint8_t buff[6] = { 0 };
     122           0 :   for(uint8_t i = 0; i < numSideDets; i++) {
     123           0 :     if(i >= 3) { return(RADIOLIB_ERR_UNKNOWN); }
     124           0 :     buff[2*i] = pnrDelta[i] & 0x0F;
     125           0 :     buff[2*i + 1] = detPeak[i] & 0x7F;
     126             :   }
     127           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SIDE_DET_CAD, true, buff, 2*numSideDets));
     128             : }
     129             : 
     130             : #endif