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