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             :     // LDRO on SX128x seems to be working differently to sub-GHz LoRa, as it is always needed for SF > 10
      15             :     // if SX128x bandwidth is being used at 2.4 GHz, we use this approach instead of the symbol time to preserve compatibility
      16           0 :     bool sx128xLdro = this->highFreq && ((bw >= RADIOLIB_LR2021_LORA_BW_203) || (bw <= RADIOLIB_LR2021_LORA_BW_812)) && (sf > 10);
      17           0 :     if((symbolLength >= 16.0f) || sx128xLdro) {
      18           0 :       this->ldrOptimize = RADIOLIB_LR2021_LORA_LDRO_ENABLED;
      19             :     } else {
      20           0 :       this->ldrOptimize = RADIOLIB_LR2021_LORA_LDRO_DISABLED;
      21             :     }
      22             :   } else {
      23           0 :     this->ldrOptimize = ldro;
      24             :   }
      25             : 
      26           0 :   uint8_t buff[] = { (uint8_t)(((sf & 0x0F) << 4) | (bw & 0x0F)), (uint8_t)(((cr & 0x0F) << 4) | this->ldrOptimize) };
      27           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_MODULATION_PARAMS, true, buff, sizeof(buff)));
      28             : }
      29             : 
      30           0 : int16_t LR2021::setLoRaPacketParams(uint16_t preambleLen, uint8_t hdrType, uint8_t payloadLen, uint8_t crcType, uint8_t invertIQ) {
      31             :   uint8_t buff[] = { 
      32           0 :     (uint8_t)((preambleLen >> 8) & 0xFF), (uint8_t)(preambleLen & 0xFF), payloadLen,
      33           0 :     (uint8_t)(((hdrType & 0x01) << 2) | ((crcType & 0x01) << 1) | (invertIQ & 0x01)),
      34           0 :   };
      35           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_PACKET_PARAMS, true, buff, sizeof(buff)));
      36             : }
      37             : 
      38           0 : int16_t LR2021::setLoRaSynchTimeout(uint8_t numSymbols, bool format) {
      39           0 :   uint8_t buff[] = { numSymbols, (uint8_t)format };
      40           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SYNCH_TIMEOUT, true, buff, sizeof(buff)));
      41             : }
      42             : 
      43           0 : int16_t LR2021::setLoRaSyncword(uint8_t syncword) {
      44           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SYNCWORD, true, &syncword, sizeof(syncword)));
      45             : }
      46             : 
      47           0 : int16_t LR2021::setLoRaSideDetConfig(uint8_t* configs, size_t numSideDets) {
      48           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SIDE_DET_CONFIG, true, configs, numSideDets));
      49             : }
      50             : 
      51           0 : int16_t LR2021::setLoRaSideDetSyncword(uint8_t* syncwords, size_t numSideDets) {
      52           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SIDE_DET_SYNCWORD, true, syncwords, numSideDets));
      53             : }
      54             : 
      55           0 : int16_t LR2021::setLoRaCadParams(uint8_t numSymbols, bool preambleOnly, uint8_t pnrDelta, uint8_t cadExitMode, uint32_t timeout, uint8_t detPeak) {
      56             :   uint8_t buff[] = {
      57           0 :     numSymbols, (uint8_t)(((uint8_t)preambleOnly << 4) | (pnrDelta & 0x0F)), cadExitMode, 
      58           0 :     (uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF),
      59           0 :     (uint8_t)(detPeak & 0x7F)
      60           0 :   };
      61           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_CAD_PARAMS, true, buff, sizeof(buff)));
      62             : }
      63             : 
      64           0 : int16_t LR2021::setLoRaCad(void) {
      65           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_CAD, true, NULL, 0));
      66             : }
      67             : 
      68           0 : int16_t LR2021::getLoRaRxStats(uint16_t* pktRxTotal, uint16_t* pktCrcError, uint16_t* headerCrcError, uint16_t* falseSynch) {
      69           0 :   uint8_t buff[8] = { 0 };
      70           0 :   int16_t state = this->SPIcommand(RADIOLIB_LR2021_CMD_GET_LORA_RX_STATS, false, buff, sizeof(buff));
      71           0 :   if(pktRxTotal) { *pktRxTotal = ((uint16_t)(buff[0]) << 8) | (uint16_t)buff[1]; }
      72           0 :   if(pktCrcError) { *pktCrcError = ((uint16_t)(buff[2]) << 8) | (uint16_t)buff[3]; }
      73           0 :   if(headerCrcError) { *headerCrcError = ((uint16_t)(buff[4]) << 8) | (uint16_t)buff[5]; }
      74           0 :   if(falseSynch) { *falseSynch = ((uint16_t)(buff[7]) << 8) | (uint16_t)buff[6]; }
      75           0 :   return(state);
      76             : }
      77             : 
      78           0 : int16_t LR2021::getLoRaPacketStatus(uint8_t* cr, bool* crc, uint8_t* packetLen, float* snrPacket, float* rssiPacket, float* rssiSignalPacket, uint8_t* detector) {
      79           0 :   uint8_t buff[6] = { 0 };
      80           0 :   int16_t state = this->SPIcommand(RADIOLIB_LR2021_CMD_GET_LORA_PACKET_STATUS, false, buff, sizeof(buff));
      81             :   uint16_t raw;
      82           0 :   if(crc) { *crc = (buff[0] & 0x10) >> 4; }
      83           0 :   if(cr) { *cr = buff[0] & 0x0F; }
      84           0 :   if(packetLen) { *packetLen = buff[1]; }
      85           0 :   if(snrPacket) { *snrPacket = (float)((int8_t)buff[2]) / 4.0f; }
      86           0 :   if(rssiPacket) {
      87           0 :     raw = (uint16_t)buff[3] << 1;
      88           0 :     raw |= (buff[5] & 0x02) >> 1;
      89           0 :     *rssiPacket = (float)raw / -2.0f;
      90             :   }
      91           0 :   if(rssiSignalPacket) {
      92           0 :     raw = (uint16_t)buff[4] << 1;
      93           0 :     raw |= buff[5] & 0x01;
      94           0 :     *rssiSignalPacket = (float)raw / -2.0f;
      95             :   }
      96           0 :   if(detector) {
      97           0 :     uint8_t det = (buff[5] >> 2) & 0x0F;
      98           0 :     if(det == 0x01) { *detector = 0; }
      99           0 :     else if(det == 0x02) { *detector = 1; }
     100           0 :     else if(det == 0x04) { *detector = 2; }
     101           0 :     else if(det == 0x08) { *detector = 3; }
     102             :   }
     103           0 :   return(state);
     104             : }
     105             : 
     106           0 : int16_t LR2021::setLoRaAddress(uint8_t addrLen, uint8_t addrPos, const uint8_t* addr) {
     107           0 :   if(addrLen > 8) { return(RADIOLIB_ERR_UNKNOWN); }
     108           0 :   uint8_t buff[9] = { (uint8_t)(((addrLen & 0x0F) << 4) | (addrPos & 0x0F)) };
     109           0 :   memcpy(&buff[1], addr, addrLen);
     110           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_ADDRESS, true, buff, sizeof(buff)));
     111             : }
     112             : 
     113           0 : int16_t LR2021::setLoRaHopping(uint8_t hopCtrl, uint16_t hopPeriod, const uint32_t* freqHops, size_t numFreqHops) {
     114           0 :   if(numFreqHops > 40) { return(RADIOLIB_ERR_UNKNOWN); }
     115           0 :   uint8_t buff[2 + 160] = { (uint8_t)(hopCtrl | ((hopPeriod & 0xF00) >> 8)), (uint8_t)(hopPeriod & 0xFF) };
     116           0 :   for(uint8_t i = 0; i < numFreqHops; i++) {
     117           0 :     buff[i + 2] = (freqHops[i] >> 24) & 0xFF;
     118           0 :     buff[i + 3] = (freqHops[i] >> 16) & 0xFF;
     119           0 :     buff[i + 4] = (freqHops[i] >> 8) & 0xFF;
     120           0 :     buff[i + 5] = freqHops[i] & 0xFF;
     121             :   }
     122           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_HOPPING, true, buff, sizeof(buff)));
     123             : }
     124             : 
     125           0 : int16_t LR2021::setLoRaTxSync(uint8_t function, uint8_t dioNum) {
     126           0 :   uint8_t buff[] = { (uint8_t)(function | (dioNum & 0x3F)) };
     127           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_TX_SYNC, true, buff, sizeof(buff)));
     128             : }
     129             : 
     130           0 : int16_t LR2021::setLoRaSideDetCad(const uint8_t* pnrDelta, const uint8_t* detPeak, size_t numSideDets) {
     131           0 :   uint8_t buff[6] = { 0 };
     132           0 :   for(size_t i = 0; i < numSideDets; i++) {
     133           0 :     if(i >= 3) { return(RADIOLIB_ERR_UNKNOWN); }
     134           0 :     buff[2*i] = pnrDelta[i] & 0x0F;
     135           0 :     buff[2*i + 1] = detPeak[i] & 0x7F;
     136             :   }
     137           0 :   return(this->SPIcommand(RADIOLIB_LR2021_CMD_SET_LORA_SIDE_DET_CAD, true, buff, 2*numSideDets));
     138             : }
     139             : 
     140             : #endif