forks/RadioLibSmol
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[SX126x] Added status check for SPI transactions

Browse source
This commit is contained in:
jgromes 2019-05-21 13:20:49 +02:00
parent 9d34a7aede
commit 943f591e92
2 changed files with 309 additions and 188 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

454
src/modules/SX126x.cpp
View file

@ -20,18 +20,20 @@ int16_t SX126x::begin(float bw, uint8_t sf, uint8_t cr, uint16_t syncWord, uint1
_crcType = SX126X_LORA_CRC_ON; _crcType = SX126X_LORA_CRC_ON;
_preambleLength = preambleLength; _preambleLength = preambleLength;
// get status and errors
getStatus();
getDeviceErrors();
// set mode to standby // set mode to standby
standby(); int16_t state = standby();
if(state != ERR_NONE) {
return(state);
}
// configure settings not accessible by API // configure settings not accessible by API
config(); state = config();
if(state != ERR_NONE) {
return(state);
}
// configure publicly accessible settings // configure publicly accessible settings
int16_t state = setSpreadingFactor(sf); state = setSpreadingFactor(sf);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
@ -52,9 +54,6 @@ int16_t SX126x::begin(float bw, uint8_t sf, uint8_t cr, uint16_t syncWord, uint1
} }
state = setPreambleLength(preambleLength); state = setPreambleLength(preambleLength);
if(state != ERR_NONE) {
return(state);
}
return(state); return(state);
} }
@ -74,18 +73,20 @@ int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleL
_preambleLengthFSK = preambleLength; _preambleLengthFSK = preambleLength;
_addrComp = SX126X_GFSK_ADDRESS_FILT_OFF; _addrComp = SX126X_GFSK_ADDRESS_FILT_OFF;
// get status and errors
getStatus();
getDeviceErrors();
// set mode to standby // set mode to standby
standby(); int16_t state = standby();
if(state != ERR_NONE) {
return(state);
}
// configure settings not accessible by API // configure settings not accessible by API
configFSK(); state = configFSK();
if(state != ERR_NONE) {
return(state);
}
// configure publicly accessible settings // configure publicly accessible settings
int16_t state = setBitRate(br); state = setBitRate(br);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
@ -113,16 +114,16 @@ int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleL
// set default sync word 0x2D01 - not a beginFSK attribute // set default sync word 0x2D01 - not a beginFSK attribute
uint8_t sync[] = {0x2D, 0x01}; uint8_t sync[] = {0x2D, 0x01};
state = setSyncWord(sync, 2); state = setSyncWord(sync, 2);
if(state != ERR_NONE) {
return(state);
}
return(state); return(state);
} }
int16_t SX126x::transmit(uint8_t* data, size_t len, uint8_t addr) { int16_t SX126x::transmit(uint8_t* data, size_t len, uint8_t addr) {
// set mode to standby // set mode to standby
standby(); int16_t state = standby();
if(state != ERR_NONE) {
return(state);
}
// check packet length // check packet length
if(len >= 256) { if(len >= 256) {
@ -164,7 +165,7 @@ int16_t SX126x::transmit(uint8_t* data, size_t len, uint8_t addr) {
DEBUG_PRINTLN(F(" us")); DEBUG_PRINTLN(F(" us"));
// start transmission // start transmission
int16_t state = startTransmit(data, len, addr); state = startTransmit(data, len, addr);
if(state != ERR_NONE) { if(state != ERR_NONE) {
return(state); return(state);
} }
@ -183,17 +184,23 @@ int16_t SX126x::transmit(uint8_t* data, size_t len, uint8_t addr) {
_dataRate = (len*8.0)/((float)elapsed/1000000.0); _dataRate = (len*8.0)/((float)elapsed/1000000.0);
// clear interrupt flags // clear interrupt flags
clearIrqStatus(); state = clearIrqStatus();
if(state != ERR_NONE) {
return(state);
}
// set mode to standby to disable transmitter // set mode to standby to disable transmitter
standby(); state = standby();
return(ERR_NONE); return(state);
} }
int16_t SX126x::receive(uint8_t* data, size_t len) { int16_t SX126x::receive(uint8_t* data, size_t len) {
// set mode to standby // set mode to standby
standby(); int16_t state = standby();
if(state != ERR_NONE) {
return(state);
}
uint32_t timeout = 0; uint32_t timeout = 0;
@ -223,7 +230,10 @@ int16_t SX126x::receive(uint8_t* data, size_t len) {
// start reception // start reception
uint32_t timeoutValue = (uint32_t)((float)timeout / 15.625); uint32_t timeoutValue = (uint32_t)((float)timeout / 15.625);
startReceive(timeoutValue); state = startReceive(timeoutValue);
if(state != ERR_NONE) {
return(state);
}
// wait for packet reception or timeout // wait for packet reception or timeout
uint32_t start = micros(); uint32_t start = micros();
@ -240,14 +250,17 @@ int16_t SX126x::receive(uint8_t* data, size_t len) {
int16_t SX126x::transmitDirect(uint32_t frf) { int16_t SX126x::transmitDirect(uint32_t frf) {
// user requested to start transmitting immediately (required for RTTY) // user requested to start transmitting immediately (required for RTTY)
int16_t state = ERR_NONE;
if(frf != 0) { if(frf != 0) {
setRfFrequency(frf); state = setRfFrequency(frf);
}
if(state != ERR_NONE) {
return(state);
} }
// start transmitting // start transmitting
uint8_t data[] = {SX126X_CMD_NOP}; uint8_t data[] = {SX126X_CMD_NOP};
SPIwriteCommand(SX126X_CMD_SET_TX_CONTINUOUS_WAVE, data, 1); return(SPIwriteCommand(SX126X_CMD_SET_TX_CONTINUOUS_WAVE, data, 1));
return(ERR_NONE);
} }
int16_t SX126x::receiveDirect() { int16_t SX126x::receiveDirect() {
@ -262,16 +275,28 @@ int16_t SX126x::scanChannel() {
} }
// set mode to standby // set mode to standby
standby(); int16_t state = standby();
if(state != ERR_NONE) {
return(state);
}
// set DIO pin mapping // set DIO pin mapping
setDioIrqParams(SX126X_IRQ_CAD_DETECTED | SX126X_IRQ_CAD_DONE, SX126X_IRQ_CAD_DONE, SX126X_IRQ_CAD_DETECTED); state = setDioIrqParams(SX126X_IRQ_CAD_DETECTED | SX126X_IRQ_CAD_DONE, SX126X_IRQ_CAD_DONE, SX126X_IRQ_CAD_DETECTED);
if(state != ERR_NONE) {
return(state);
}
// clear interrupt flags // clear interrupt flags
clearIrqStatus(); state = clearIrqStatus();
if(state != ERR_NONE) {
return(state);
}
// set mode to CAD // set mode to CAD
setCad(); state = setCad();
if(state != ERR_NONE) {
return(state);
}
// wait for channel activity detected or timeout // wait for channel activity detected or timeout
while(!digitalRead(_mod->getInt0())) { while(!digitalRead(_mod->getInt0())) {
@ -289,18 +314,17 @@ int16_t SX126x::scanChannel() {
int16_t SX126x::sleep() { int16_t SX126x::sleep() {
uint8_t data[] = {SX126X_SLEEP_START_COLD | SX126X_SLEEP_RTC_OFF}; uint8_t data[] = {SX126X_SLEEP_START_COLD | SX126X_SLEEP_RTC_OFF};
SPIwriteCommand(SX126X_CMD_SET_SLEEP, data, 1); int16_t state = SPIwriteCommand(SX126X_CMD_SET_SLEEP, data, 1);
// wait for SX126x to safely enter sleep mode // wait for SX126x to safely enter sleep mode
delayMicroseconds(500); delayMicroseconds(500);
return(ERR_NONE); return(state);
} }
int16_t SX126x::standby(uint8_t mode) { int16_t SX126x::standby(uint8_t mode) {
uint8_t data[] = {mode}; uint8_t data[] = {mode};
SPIwriteCommand(SX126X_CMD_SET_STANDBY, data, 1); return(SPIwriteCommand(SX126X_CMD_SET_STANDBY, data, 1));
return(ERR_NONE);
} }
void SX126x::setDio1Action(void (*func)(void)) { void SX126x::setDio1Action(void (*func)(void)) {
@ -316,50 +340,78 @@ int16_t SX126x::startTransmit(uint8_t* data, size_t len, uint8_t addr) {
(void)addr; (void)addr;
// set packet Length // set packet Length
int16_t state = ERR_NONE;
uint8_t modem = getPacketType(); uint8_t modem = getPacketType();
if(modem == SX126X_PACKET_TYPE_LORA) { if(modem == SX126X_PACKET_TYPE_LORA) {
setPacketParams(_preambleLength, _crcType, len); state = setPacketParams(_preambleLength, _crcType, len);
} else if(modem == SX126X_PACKET_TYPE_GFSK) { } else if(modem == SX126X_PACKET_TYPE_GFSK) {
setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, len); state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp, len);
} else { } else {
return(ERR_UNKNOWN); return(ERR_UNKNOWN);
} }
if(state != ERR_NONE) {
return(state);
}
// set DIO mapping // set DIO mapping
setDioIrqParams(SX126X_IRQ_TX_DONE | SX126X_IRQ_TIMEOUT, SX126X_IRQ_TX_DONE); state = setDioIrqParams(SX126X_IRQ_TX_DONE | SX126X_IRQ_TIMEOUT, SX126X_IRQ_TX_DONE);
if(state != ERR_NONE) {
return(state);
}
// set buffer pointers // set buffer pointers
setBufferBaseAddress(); state = setBufferBaseAddress();
if(state != ERR_NONE) {
return(state);
}
// write packet to buffer // write packet to buffer
writeBuffer(data, len); state = writeBuffer(data, len);
if(state != ERR_NONE) {
return(state);
}
// clear interrupt flags // clear interrupt flags
clearIrqStatus(); state = clearIrqStatus();
if(state != ERR_NONE) {
return(state);
}
// start transmission // start transmission
setTx(0x000000); state = setTx(SX126X_TX_TIMEOUT_NONE);
if(state != ERR_NONE) {
return(state);
}
// wait for BUSY to go low (= PA ramp up done) // wait for BUSY to go low (= PA ramp up done)
while(digitalRead(_mod->getRx())); while(digitalRead(_mod->getRx()));
return(ERR_NONE); return(state);
} }
int16_t SX126x::startReceive(uint32_t timeout) { int16_t SX126x::startReceive(uint32_t timeout) {
// set DIO mapping // set DIO mapping
setDioIrqParams(SX126X_IRQ_RX_DONE | SX126X_IRQ_TIMEOUT, SX126X_IRQ_RX_DONE); int16_t state = setDioIrqParams(SX126X_IRQ_RX_DONE | SX126X_IRQ_TIMEOUT, SX126X_IRQ_RX_DONE);
if(state != ERR_NONE) {
return(state);
}
// set buffer pointers // set buffer pointers
setBufferBaseAddress(); state = setBufferBaseAddress();
if(state != ERR_NONE) {
return(state);
}
// clear interrupt flags // clear interrupt flags
clearIrqStatus(); state = clearIrqStatus();
if(state != ERR_NONE) {
return(state);
}
// set mode to receive // set mode to receive
setRx(timeout); state = setRx(timeout);
return(ERR_NONE); return(state);
} }
int16_t SX126x::readData(uint8_t* data, size_t len) { int16_t SX126x::readData(uint8_t* data, size_t len) {
@ -372,7 +424,11 @@ int16_t SX126x::readData(uint8_t* data, size_t len) {
// get packet length // get packet length
uint8_t rxBufStatus[2]; uint8_t rxBufStatus[2];
SPIreadCommand(SX126X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2); int16_t state = SPIreadCommand(SX126X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2);
if(state != ERR_NONE) {
return(state);
}
size_t length = rxBufStatus[0]; size_t length = rxBufStatus[0];
// read packet data // read packet data
@ -382,15 +438,18 @@ int16_t SX126x::readData(uint8_t* data, size_t len) {
delete[] data; delete[] data;
data = new uint8_t[length + 1]; data = new uint8_t[length + 1];
} }
readBuffer(data, length); state = readBuffer(data, length);
if(state != ERR_NONE) {
return(state);
}
// add terminating null // add terminating null
data[length] = 0; data[length] = 0;
// clear interrupt flags // clear interrupt flags
clearIrqStatus(); state = clearIrqStatus();
return(ERR_NONE); return(state);
} }
int16_t SX126x::setBandwidth(float bw) { int16_t SX126x::setBandwidth(float bw) {
@ -426,8 +485,7 @@ int16_t SX126x::setBandwidth(float bw) {
// update modulation parameters // update modulation parameters
_bwKhz = bw; _bwKhz = bw;
setModulationParams(_sf, _bw, _cr); return(setModulationParams(_sf, _bw, _cr));
return(ERR_NONE);
} }
int16_t SX126x::setSpreadingFactor(uint8_t sf) { int16_t SX126x::setSpreadingFactor(uint8_t sf) {
@ -443,8 +501,7 @@ int16_t SX126x::setSpreadingFactor(uint8_t sf) {
// update modulation parameters // update modulation parameters
_sf = sf; _sf = sf;
setModulationParams(_sf, _bw, _cr); return(setModulationParams(_sf, _bw, _cr));
return(ERR_NONE);
} }
int16_t SX126x::setCodingRate(uint8_t cr) { int16_t SX126x::setCodingRate(uint8_t cr) {
@ -460,8 +517,7 @@ int16_t SX126x::setCodingRate(uint8_t cr) {
// update modulation parameters // update modulation parameters
_cr = cr - 4; _cr = cr - 4;
setModulationParams(_sf, _bw, _cr); return(setModulationParams(_sf, _bw, _cr));
return(ERR_NONE);
} }
int16_t SX126x::setSyncWord(uint16_t syncWord) { int16_t SX126x::setSyncWord(uint16_t syncWord) {
@ -472,8 +528,7 @@ int16_t SX126x::setSyncWord(uint16_t syncWord) {
// update register // update register
uint8_t data[2] = {(uint8_t)((syncWord >> 8) & 0xFF), (uint8_t)(syncWord & 0xFF)}; uint8_t data[2] = {(uint8_t)((syncWord >> 8) & 0xFF), (uint8_t)(syncWord & 0xFF)};
writeRegister(SX126X_REG_LORA_SYNC_WORD_MSB, data, 2); return(writeRegister(SX126X_REG_LORA_SYNC_WORD_MSB, data, 2));
return(ERR_NONE);
} }
int16_t SX126x::setCurrentLimit(float currentLimit) { int16_t SX126x::setCurrentLimit(float currentLimit) {
@ -481,20 +536,17 @@ int16_t SX126x::setCurrentLimit(float currentLimit) {
uint8_t rawLimit = (uint8_t)(currentLimit / 2.5); uint8_t rawLimit = (uint8_t)(currentLimit / 2.5);
// update register // update register
writeRegister(SX126X_REG_OCP_CONFIGURATION, &rawLimit, 1); return(writeRegister(SX126X_REG_OCP_CONFIGURATION, &rawLimit, 1));
return(ERR_NONE);
} }
int16_t SX126x::setPreambleLength(uint16_t preambleLength) { int16_t SX126x::setPreambleLength(uint16_t preambleLength) {
uint8_t modem = getPacketType(); uint8_t modem = getPacketType();
if(modem == SX126X_PACKET_TYPE_LORA) { if(modem == SX126X_PACKET_TYPE_LORA) {
_preambleLength = preambleLength; _preambleLength = preambleLength;
setPacketParams(_preambleLength, _crcType); return(setPacketParams(_preambleLength, _crcType));
return(ERR_NONE);
} else if(modem == SX126X_PACKET_TYPE_GFSK) { } else if(modem == SX126X_PACKET_TYPE_GFSK) {
_preambleLengthFSK = preambleLength; _preambleLengthFSK = preambleLength;
setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp); return(setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp));
return(ERR_NONE);
} }
return(ERR_UNKNOWN); return(ERR_UNKNOWN);
@ -521,9 +573,7 @@ int16_t SX126x::setFrequencyDeviation(float freqDev) {
_freqDev = freqDevRaw; _freqDev = freqDevRaw;
// update modulation parameters // update modulation parameters
setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev); return(setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev));
return(ERR_NONE);
} }
int16_t SX126x::setBitRate(float br) { int16_t SX126x::setBitRate(float br) {
@ -547,9 +597,7 @@ int16_t SX126x::setBitRate(float br) {
_br = brRaw; _br = brRaw;
// update modulation parameters // update modulation parameters
setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev); return(setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev));
return(ERR_NONE);
} }
int16_t SX126x::setRxBandwidth(float rxBw) { int16_t SX126x::setRxBandwidth(float rxBw) {
@ -612,9 +660,7 @@ int16_t SX126x::setRxBandwidth(float rxBw) {
} }
// update modulation parameters // update modulation parameters
setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev); return(setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev));
return(ERR_NONE);
} }
int16_t SX126x::setDataShaping(float sh) { int16_t SX126x::setDataShaping(float sh) {
@ -640,9 +686,7 @@ int16_t SX126x::setDataShaping(float sh) {
} }
// update modulation parameters // update modulation parameters
setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev); return(setModulationParamsFSK(_br, _pulseShape, _rxBw, _freqDev));
return(ERR_NONE);
} }
int16_t SX126x::setSyncWord(uint8_t* syncWord, uint8_t len) { int16_t SX126x::setSyncWord(uint8_t* syncWord, uint8_t len) {
@ -657,13 +701,16 @@ int16_t SX126x::setSyncWord(uint8_t* syncWord, uint8_t len) {
} }
// write sync word // write sync word
writeRegister(SX126X_REG_SYNC_WORD_0, syncWord, len); int16_t state = writeRegister(SX126X_REG_SYNC_WORD_0, syncWord, len);
if(state != ERR_NONE) {
return(state);
}
// update packet parameters // update packet parameters
_syncWordLength = len * 8; _syncWordLength = len * 8;
setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp); state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp);
return(ERR_NONE); return(state);
} }
int16_t SX126x::setNodeAddress(uint8_t nodeAddr) { int16_t SX126x::setNodeAddress(uint8_t nodeAddr) {
@ -674,12 +721,15 @@ int16_t SX126x::setNodeAddress(uint8_t nodeAddr) {
// enable address filtering (node only) // enable address filtering (node only)
_addrComp = SX126X_GFSK_ADDRESS_FILT_NODE; _addrComp = SX126X_GFSK_ADDRESS_FILT_NODE;
setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp); int16_t state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp);
if(state != ERR_NONE) {
return(state);
}
// set node address // set node address
writeRegister(SX126X_REG_NODE_ADDRESS, &nodeAddr, 1); state = writeRegister(SX126X_REG_NODE_ADDRESS, &nodeAddr, 1);
return(ERR_NONE); return(state);
} }
int16_t SX126x::setBroadcastAddress(uint8_t broadAddr) { int16_t SX126x::setBroadcastAddress(uint8_t broadAddr) {
@ -690,12 +740,15 @@ int16_t SX126x::setBroadcastAddress(uint8_t broadAddr) {
// enable address filtering (node and broadcast) // enable address filtering (node and broadcast)
_addrComp = SX126X_GFSK_ADDRESS_FILT_NODE_BROADCAST; _addrComp = SX126X_GFSK_ADDRESS_FILT_NODE_BROADCAST;
setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp); int16_t state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp);
if(state != ERR_NONE) {
return(state);
}
// set broadcast address // set broadcast address
writeRegister(SX126X_REG_BROADCAST_ADDRESS, &broadAddr, 1); state = writeRegister(SX126X_REG_BROADCAST_ADDRESS, &broadAddr, 1);
return(ERR_NONE); return(state);
} }
int16_t SX126x::disableAddressFiltering() { int16_t SX126x::disableAddressFiltering() {
@ -706,9 +759,7 @@ int16_t SX126x::disableAddressFiltering() {
// disable address filtering // disable address filtering
_addrComp = SX126X_GFSK_ADDRESS_FILT_OFF; _addrComp = SX126X_GFSK_ADDRESS_FILT_OFF;
setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp); return(setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp));
return(ERR_NONE);
} }
int16_t SX126x::setCRC(bool enableCRC) { int16_t SX126x::setCRC(bool enableCRC) {
@ -723,9 +774,7 @@ int16_t SX126x::setCRC(bool enableCRC) {
} else { } else {
_crcType = SX126X_LORA_CRC_OFF; _crcType = SX126X_LORA_CRC_OFF;
} }
setPacketParams(_preambleLength, _crcType); return(setPacketParams(_preambleLength, _crcType));
return(ERR_NONE);
} }
int16_t SX126x::setCRC(uint8_t len, uint16_t initial, uint16_t polynomial, bool inverted) { int16_t SX126x::setCRC(uint8_t len, uint16_t initial, uint16_t polynomial, bool inverted) {
@ -756,18 +805,24 @@ int16_t SX126x::setCRC(uint8_t len, uint16_t initial, uint16_t polynomial, bool
default: default:
return(ERR_INVALID_CRC_CONFIGURATION); return(ERR_INVALID_CRC_CONFIGURATION);
} }
setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp); int16_t state = setPacketParamsFSK(_preambleLengthFSK, _crcTypeFSK, _syncWordLength, _addrComp);
if(state != ERR_NONE) {
return(state);
}
// write initial CRC value // write initial CRC value
uint8_t data[2] = {(uint8_t)((initial >> 8) & 0xFF), (uint8_t)(initial & 0xFF)}; uint8_t data[2] = {(uint8_t)((initial >> 8) & 0xFF), (uint8_t)(initial & 0xFF)};
writeRegister(SX126X_REG_CRC_INITIAL_MSB, data, 2); state = writeRegister(SX126X_REG_CRC_INITIAL_MSB, data, 2);
if(state != ERR_NONE) {
return(state);
}
// write CRC polynomial value // write CRC polynomial value
data[0] = (uint8_t)((polynomial >> 8) & 0xFF); data[0] = (uint8_t)((polynomial >> 8) & 0xFF);
data[1] = (uint8_t)(polynomial & 0xFF); data[1] = (uint8_t)(polynomial & 0xFF);
writeRegister(SX126X_REG_CRC_POLYNOMIAL_MSB, data, 2); state = writeRegister(SX126X_REG_CRC_POLYNOMIAL_MSB, data, 2);
return(ERR_NONE); return(state);
} }
float SX126x::getDataRate() { float SX126x::getDataRate() {
@ -831,58 +886,61 @@ int16_t SX126x::setTCXO(float voltage, uint32_t timeout) {
return(ERR_NONE); return(ERR_NONE);
} }
void SX126x::setTx(uint32_t timeout) { int16_t SX126x::setTx(uint32_t timeout) {
uint8_t data[3] = {(uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF)}; uint8_t data[3] = {(uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF)};
SPIwriteCommand(SX126X_CMD_SET_TX, data, 3); return(SPIwriteCommand(SX126X_CMD_SET_TX, data, 3));
} }
void SX126x::setRx(uint32_t timeout) { int16_t SX126x::setRx(uint32_t timeout) {
uint8_t data[3] = {(uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF)}; uint8_t data[3] = {(uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF)};
SPIwriteCommand(SX126X_CMD_SET_RX, data, 3); return(SPIwriteCommand(SX126X_CMD_SET_RX, data, 3));
} }
void SX126x::setCad() { int16_t SX126x::setCad() {
SPIwriteCommand(SX126X_CMD_SET_CAD, NULL, 0); return(SPIwriteCommand(SX126X_CMD_SET_CAD, NULL, 0));
} }
void SX126x::setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax, uint8_t paLut) { int16_t SX126x::setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax, uint8_t paLut) {
uint8_t data[4] = {paDutyCycle, hpMax, deviceSel, paLut}; uint8_t data[4] = {paDutyCycle, hpMax, deviceSel, paLut};
SPIwriteCommand(SX126X_CMD_SET_PA_CONFIG, data, 4); return(SPIwriteCommand(SX126X_CMD_SET_PA_CONFIG, data, 4));
} }
void SX126x::writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) { int16_t SX126x::writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) {
uint8_t* dat = new uint8_t[2 + numBytes]; uint8_t* dat = new uint8_t[2 + numBytes];
dat[0] = (uint8_t)((addr >> 8) & 0xFF); dat[0] = (uint8_t)((addr >> 8) & 0xFF);
dat[1] = (uint8_t)(addr & 0xFF); dat[1] = (uint8_t)(addr & 0xFF);
memcpy(dat + 2, data, numBytes); memcpy(dat + 2, data, numBytes);
SPIwriteCommand(SX126X_CMD_WRITE_REGISTER, dat, 2 + numBytes); int16_t state = SPIwriteCommand(SX126X_CMD_WRITE_REGISTER, dat, 2 + numBytes);
delete[] dat; delete[] dat;
return(state);
} }
void SX126x::writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset) { int16_t SX126x::writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset) {
uint8_t* dat = new uint8_t[1 + numBytes]; uint8_t* dat = new uint8_t[1 + numBytes];
dat[0] = offset; dat[0] = offset;
memcpy(dat + 1, data, numBytes); memcpy(dat + 1, data, numBytes);
SPIwriteCommand(SX126X_CMD_WRITE_BUFFER, dat, 1 + numBytes); int16_t state = SPIwriteCommand(SX126X_CMD_WRITE_BUFFER, dat, 1 + numBytes);
delete[] dat; delete[] dat;
return(state);
} }
void SX126x::readBuffer(uint8_t* data, uint8_t numBytes) { int16_t SX126x::readBuffer(uint8_t* data, uint8_t numBytes) {
// offset will be always set to 0 (one extra NOP is sent) // offset will be always set to 0 (one extra NOP is sent)
uint8_t* dat = new uint8_t[1 + numBytes]; uint8_t* dat = new uint8_t[1 + numBytes];
dat[0] = SX126X_CMD_NOP; dat[0] = SX126X_CMD_NOP;
memcpy(dat + 1, data, numBytes); memcpy(dat + 1, data, numBytes);
SPIreadCommand(SX126X_CMD_READ_BUFFER, dat, 1 + numBytes); int16_t state = SPIreadCommand(SX126X_CMD_READ_BUFFER, dat, 1 + numBytes);
memcpy(data, dat + 1, numBytes); memcpy(data, dat + 1, numBytes);
delete[] dat; delete[] dat;
return(state);
} }
void SX126x::setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask) { int16_t SX126x::setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask) {
uint8_t data[8] = {(uint8_t)((irqMask >> 8) & 0xFF), (uint8_t)(irqMask & 0xFF), uint8_t data[8] = {(uint8_t)((irqMask >> 8) & 0xFF), (uint8_t)(irqMask & 0xFF),
(uint8_t)((dio1Mask >> 8) & 0xFF), (uint8_t)(dio1Mask & 0xFF), (uint8_t)((dio1Mask >> 8) & 0xFF), (uint8_t)(dio1Mask & 0xFF),
(uint8_t)((dio2Mask >> 8) & 0xFF), (uint8_t)(dio2Mask & 0xFF), (uint8_t)((dio2Mask >> 8) & 0xFF), (uint8_t)(dio2Mask & 0xFF),
(uint8_t)((dio3Mask >> 8) & 0xFF), (uint8_t)(dio3Mask & 0xFF)}; (uint8_t)((dio3Mask >> 8) & 0xFF), (uint8_t)(dio3Mask & 0xFF)};
SPIwriteCommand(SX126X_CMD_SET_DIO_IRQ_PARAMS, data, 8); return(SPIwriteCommand(SX126X_CMD_SET_DIO_IRQ_PARAMS, data, 8));
} }
uint16_t SX126x::getIrqStatus() { uint16_t SX126x::getIrqStatus() {
@ -891,28 +949,28 @@ uint16_t SX126x::getIrqStatus() {
return(((uint16_t)(data[1]) << 8) | data[0]); return(((uint16_t)(data[1]) << 8) | data[0]);
} }
void SX126x::clearIrqStatus(uint16_t clearIrqParams) { int16_t SX126x::clearIrqStatus(uint16_t clearIrqParams) {
uint8_t data[2] = {(uint8_t)((clearIrqParams >> 8) & 0xFF), (uint8_t)(clearIrqParams & 0xFF)}; uint8_t data[2] = {(uint8_t)((clearIrqParams >> 8) & 0xFF), (uint8_t)(clearIrqParams & 0xFF)};
SPIwriteCommand(SX126X_CMD_CLEAR_IRQ_STATUS, data, 2); return(SPIwriteCommand(SX126X_CMD_CLEAR_IRQ_STATUS, data, 2));
} }
void SX126x::setRfFrequency(uint32_t frf) { int16_t SX126x::setRfFrequency(uint32_t frf) {
uint8_t data[4] = {(uint8_t)((frf >> 24) & 0xFF), (uint8_t)((frf >> 16) & 0xFF), (uint8_t)((frf >> 8) & 0xFF), (uint8_t)(frf & 0xFF)}; uint8_t data[4] = {(uint8_t)((frf >> 24) & 0xFF), (uint8_t)((frf >> 16) & 0xFF), (uint8_t)((frf >> 8) & 0xFF), (uint8_t)(frf & 0xFF)};
SPIwriteCommand(SX126X_CMD_SET_RF_FREQUENCY, data, 4); return(SPIwriteCommand(SX126X_CMD_SET_RF_FREQUENCY, data, 4));
} }
uint8_t SX126x::getPacketType() { uint8_t SX126x::getPacketType() {
uint8_t data[1]; uint8_t data = 0xFF;
SPIreadCommand(SX126X_CMD_GET_PACKET_TYPE, data, 1); SPIreadCommand(SX126X_CMD_GET_PACKET_TYPE, &data, 1);
return(data[0]); return(data);
} }
void SX126x::setTxParams(uint8_t power, uint8_t rampTime) { int16_t SX126x::setTxParams(uint8_t power, uint8_t rampTime) {
uint8_t data[2] = {power, rampTime}; uint8_t data[2] = {power, rampTime};
SPIwriteCommand(SX126X_CMD_SET_TX_PARAMS, data, 2); return(SPIwriteCommand(SX126X_CMD_SET_TX_PARAMS, data, 2));
} }
void SX126x::setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro) { int16_t SX126x::setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro) {
// calculate symbol length and enable low data rate optimization, if needed // calculate symbol length and enable low data rate optimization, if needed
if(ldro == 0xFF) { if(ldro == 0xFF) {
float symbolLength = (float)(uint32_t(1) << _sf) / (float)_bwKhz; float symbolLength = (float)(uint32_t(1) << _sf) / (float)_bwKhz;
@ -926,31 +984,31 @@ void SX126x::setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldr
} }
uint8_t data[4] = {sf, bw, cr, _ldro}; uint8_t data[4] = {sf, bw, cr, _ldro};
SPIwriteCommand(SX126X_CMD_SET_MODULATION_PARAMS, data, 4); return(SPIwriteCommand(SX126X_CMD_SET_MODULATION_PARAMS, data, 4));
} }
void SX126x::setModulationParamsFSK(uint32_t br, uint8_t pulseShape, uint8_t rxBw, uint32_t freqDev) { int16_t SX126x::setModulationParamsFSK(uint32_t br, uint8_t pulseShape, uint8_t rxBw, uint32_t freqDev) {
uint8_t data[8] = {(uint8_t)((br >> 16) & 0xFF), (uint8_t)((br >> 8) & 0xFF), (uint8_t)(br & 0xFF), uint8_t data[8] = {(uint8_t)((br >> 16) & 0xFF), (uint8_t)((br >> 8) & 0xFF), (uint8_t)(br & 0xFF),
pulseShape, rxBw, pulseShape, rxBw,
(uint8_t)((freqDev >> 16) & 0xFF), (uint8_t)((freqDev >> 8) & 0xFF), (uint8_t)(freqDev & 0xFF)}; (uint8_t)((freqDev >> 16) & 0xFF), (uint8_t)((freqDev >> 8) & 0xFF), (uint8_t)(freqDev & 0xFF)};
SPIwriteCommand(SX126X_CMD_SET_MODULATION_PARAMS, data, 8); return(SPIwriteCommand(SX126X_CMD_SET_MODULATION_PARAMS, data, 8));
} }
void SX126x::setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength, uint8_t headerType, uint8_t invertIQ) { int16_t SX126x::setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength, uint8_t headerType, uint8_t invertIQ) {
uint8_t data[6] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF), headerType, payloadLength, crcType, invertIQ}; uint8_t data[6] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF), headerType, payloadLength, crcType, invertIQ};
SPIwriteCommand(SX126X_CMD_SET_PACKET_PARAMS, data, 6); return(SPIwriteCommand(SX126X_CMD_SET_PACKET_PARAMS, data, 6));
} }
void SX126x::setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t payloadLength, uint8_t packetType, uint8_t preambleDetectorLength, uint8_t whitening) { int16_t SX126x::setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t payloadLength, uint8_t packetType, uint8_t preambleDetectorLength, uint8_t whitening) {
uint8_t data[9] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF), uint8_t data[9] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF),
preambleDetectorLength, syncWordLength, addrComp, preambleDetectorLength, syncWordLength, addrComp,
packetType, payloadLength, crcType, whitening}; packetType, payloadLength, crcType, whitening};
SPIwriteCommand(SX126X_CMD_SET_PACKET_PARAMS, data, 9); return(SPIwriteCommand(SX126X_CMD_SET_PACKET_PARAMS, data, 9));
} }
void SX126x::setBufferBaseAddress(uint8_t txBaseAddress, uint8_t rxBaseAddress) { int16_t SX126x::setBufferBaseAddress(uint8_t txBaseAddress, uint8_t rxBaseAddress) {
uint8_t data[2] = {txBaseAddress, rxBaseAddress}; uint8_t data[2] = {txBaseAddress, rxBaseAddress};
SPIwriteCommand(SX126X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2); return(SPIwriteCommand(SX126X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2));
} }
uint8_t SX126x::getStatus() { uint8_t SX126x::getStatus() {
@ -962,7 +1020,7 @@ uint8_t SX126x::getStatus() {
uint32_t SX126x::getPacketStatus() { uint32_t SX126x::getPacketStatus() {
uint8_t data[3]; uint8_t data[3];
SPIreadCommand(SX126X_CMD_GET_PACKET_STATUS, data, 3); SPIreadCommand(SX126X_CMD_GET_PACKET_STATUS, data, 3);
return((((uint32_t)data[2]) << 16) | (((uint32_t)data[1]) << 8) | (uint32_t)data[0]); return((((uint32_t)data[0]) << 16) | (((uint32_t)data[1]) << 8) | (uint32_t)data[2]);
} }
uint16_t SX126x::getDeviceErrors() { uint16_t SX126x::getDeviceErrors() {
@ -972,12 +1030,14 @@ uint16_t SX126x::getDeviceErrors() {
return(opError); return(opError);
} }
void SX126x::clearDeviceErrors() { int16_t SX126x::clearDeviceErrors() {
uint8_t data[1] = {SX126X_CMD_NOP}; uint8_t data[1] = {SX126X_CMD_NOP};
SPIwriteCommand(SX126X_CMD_CLEAR_DEVICE_ERRORS, data, 1); return(SPIwriteCommand(SX126X_CMD_CLEAR_DEVICE_ERRORS, data, 1));
} }
int16_t SX126x::setFrequencyRaw(float freq, bool calibrate) { int16_t SX126x::setFrequencyRaw(float freq, bool calibrate) {
int16_t state = ERR_NONE;
// calibrate image // calibrate image
if(calibrate) { if(calibrate) {
uint8_t data[2]; uint8_t data[2];
@ -997,7 +1057,10 @@ int16_t SX126x::setFrequencyRaw(float freq, bool calibrate) {
data[0] = SX126X_CAL_IMG_430_MHZ_1; data[0] = SX126X_CAL_IMG_430_MHZ_1;
data[1] = SX126X_CAL_IMG_430_MHZ_2; data[1] = SX126X_CAL_IMG_430_MHZ_2;
} }
SPIwriteCommand(SX126X_CMD_CALIBRATE_IMAGE, data, 2); state = SPIwriteCommand(SX126X_CMD_CALIBRATE_IMAGE, data, 2);
if(state != ERR_NONE) {
return(state);
}
} }
// calculate raw value // calculate raw value
@ -1010,22 +1073,37 @@ int16_t SX126x::config() {
// set DIO2 as IRQ // set DIO2 as IRQ
uint8_t* data = new uint8_t[1]; uint8_t* data = new uint8_t[1];
data[0] = SX126X_DIO2_AS_IRQ; data[0] = SX126X_DIO2_AS_IRQ;
SPIwriteCommand(SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, data, 1); int16_t state = SPIwriteCommand(SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, data, 1);
if(state != ERR_NONE) {
return(state);
}
// set regulator mode // set regulator mode
data[0] = SX126X_REGULATOR_DC_DC; data[0] = SX126X_REGULATOR_DC_DC;
SPIwriteCommand(SX126X_CMD_SET_REGULATOR_MODE, data, 1); state = SPIwriteCommand(SX126X_CMD_SET_REGULATOR_MODE, data, 1);
if(state != ERR_NONE) {
return(state);
}
// reset buffer base address // reset buffer base address
setBufferBaseAddress(); state = setBufferBaseAddress();
if(state != ERR_NONE) {
return(state);
}
// set LoRa mode // set LoRa mode
data[0] = SX126X_PACKET_TYPE_LORA; data[0] = SX126X_PACKET_TYPE_LORA;
SPIwriteCommand(SX126X_CMD_SET_PACKET_TYPE, data, 1); state = SPIwriteCommand(SX126X_CMD_SET_PACKET_TYPE, data, 1);
if(state != ERR_NONE) {
return(state);
}
// set Rx/Tx fallback mode to STDBY_RC // set Rx/Tx fallback mode to STDBY_RC
data[0] = SX126X_RX_TX_FALLBACK_MODE_STDBY_RC; data[0] = SX126X_RX_TX_FALLBACK_MODE_STDBY_RC;
SPIwriteCommand(SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1); state = SPIwriteCommand(SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1);
if(state != ERR_NONE) {
return(state);
}
// set CAD parameters // set CAD parameters
delete[] data; delete[] data;
@ -1037,11 +1115,14 @@ int16_t SX126x::config() {
data[4] = 0x00; data[4] = 0x00;
data[5] = 0x00; data[5] = 0x00;
data[6] = 0x00; data[6] = 0x00;
SPIwriteCommand(SX126X_CMD_SET_CAD_PARAMS, data, 7); state = SPIwriteCommand(SX126X_CMD_SET_CAD_PARAMS, data, 7);
if(state != ERR_NONE) {
return(state);
}
// clear IRQ // clear IRQ
clearIrqStatus(); state = clearIrqStatus();
setDioIrqParams(SX126X_IRQ_NONE, SX126X_IRQ_NONE); state |= setDioIrqParams(SX126X_IRQ_NONE, SX126X_IRQ_NONE);
delete[] data; delete[] data;
@ -1052,41 +1133,56 @@ int16_t SX126x::configFSK() {
// set DIO2 as IRQ // set DIO2 as IRQ
uint8_t* data = new uint8_t[1]; uint8_t* data = new uint8_t[1];
data[0] = SX126X_DIO2_AS_IRQ; data[0] = SX126X_DIO2_AS_IRQ;
SPIwriteCommand(SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, data, 1); int16_t state = SPIwriteCommand(SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, data, 1);
if(state != ERR_NONE) {
return(state);
}
// set regulator mode // set regulator mode
data[0] = SX126X_REGULATOR_DC_DC; data[0] = SX126X_REGULATOR_DC_DC;
SPIwriteCommand(SX126X_CMD_SET_REGULATOR_MODE, data, 1); state = SPIwriteCommand(SX126X_CMD_SET_REGULATOR_MODE, data, 1);
if(state != ERR_NONE) {
return(state);
}
// reset buffer base address // reset buffer base address
setBufferBaseAddress(); state = setBufferBaseAddress();
if(state != ERR_NONE) {
return(state);
}
// set FSK mode // set FSK mode
data[0] = SX126X_PACKET_TYPE_GFSK; data[0] = SX126X_PACKET_TYPE_GFSK;
SPIwriteCommand(SX126X_CMD_SET_PACKET_TYPE, data, 1); state = SPIwriteCommand(SX126X_CMD_SET_PACKET_TYPE, data, 1);
if(state != ERR_NONE) {
return(state);
}
// set Rx/Tx fallback mode to STDBY_RC // set Rx/Tx fallback mode to STDBY_RC
data[0] = SX126X_RX_TX_FALLBACK_MODE_STDBY_RC; data[0] = SX126X_RX_TX_FALLBACK_MODE_STDBY_RC;
SPIwriteCommand(SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1); state = SPIwriteCommand(SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1);
if(state != ERR_NONE) {
return(state);
}
// clear IRQ // clear IRQ
clearIrqStatus(); state = clearIrqStatus();
setDioIrqParams(SX126X_IRQ_NONE, SX126X_IRQ_NONE); state |= setDioIrqParams(SX126X_IRQ_NONE, SX126X_IRQ_NONE);
delete[] data; delete[] data;
return(ERR_NONE); return(state);
} }
void SX126x::SPIwriteCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy) { int16_t SX126x::SPIwriteCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy) {
SX126x::SPItransfer(cmd, true, data, NULL, numBytes, waitForBusy); return(SX126x::SPItransfer(cmd, true, data, NULL, numBytes, waitForBusy));
} }
void SX126x::SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy) { int16_t SX126x::SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy) {
SX126x::SPItransfer(cmd, false, NULL, data, numBytes, waitForBusy); return(SX126x::SPItransfer(cmd, false, NULL, data, numBytes, waitForBusy));
} }
void SX126x::SPItransfer(uint8_t cmd, bool write, uint8_t* dataOut, uint8_t* dataIn, uint8_t numBytes, bool waitForBusy) { int16_t SX126x::SPItransfer(uint8_t cmd, bool write, uint8_t* dataOut, uint8_t* dataIn, uint8_t numBytes, bool waitForBusy) {
// get pointer to used SPI interface and the settings // get pointer to used SPI interface and the settings
SPIClass* spi = _mod->getSpi(); SPIClass* spi = _mod->getSpi();
SPISettings spiSettings = _mod->getSpiSettings(); SPISettings spiSettings = _mod->getSpiSettings();
@ -1104,31 +1200,41 @@ void SX126x::SPItransfer(uint8_t cmd, bool write, uint8_t* dataOut, uint8_t* dat
DEBUG_PRINT(cmd, HEX); DEBUG_PRINT(cmd, HEX);
DEBUG_PRINT('\t'); DEBUG_PRINT('\t');
// variable to save error during SPI transfer
uint8_t status;
// send/receive all bytes // send/receive all bytes
if(write) { if(write) {
for(uint8_t n = 0; n < numBytes; n++) { for(uint8_t n = 0; n < numBytes; n++) {
#ifdef RADIOLIB_DEBUG // send byte
uint8_t in = spi->transfer(dataOut[n]); uint8_t in = spi->transfer(dataOut[n]);
#else
spi->transfer(dataOut[n]);
#endif
DEBUG_PRINT(dataOut[n], HEX); DEBUG_PRINT(dataOut[n], HEX);
DEBUG_PRINT('\t'); DEBUG_PRINT('\t');
DEBUG_PRINT(in, HEX); DEBUG_PRINT(in, HEX);
DEBUG_PRINT('\t'); DEBUG_PRINT('\t');
// check status
if(((in & 0b00001110) == SX126X_STATUS_CMD_TIMEOUT) ||
((in & 0b00001110) == SX126X_STATUS_CMD_INVALID) ||
((in & 0b00001110) == SX126X_STATUS_CMD_FAILED)) {
status = in;
}
} }
DEBUG_PRINTLN(); DEBUG_PRINTLN();
} else { } else {
// skip the first byte for read-type commands (status-only) // skip the first byte for read-type commands (status-only)
#ifdef RADIOLIB_DEBUG
uint8_t in = spi->transfer(SX126X_CMD_NOP); uint8_t in = spi->transfer(SX126X_CMD_NOP);
#else
spi->transfer(SX126X_CMD_NOP);
#endif
DEBUG_PRINT(SX126X_CMD_NOP, HEX); DEBUG_PRINT(SX126X_CMD_NOP, HEX);
DEBUG_PRINT('\t'); DEBUG_PRINT('\t');
DEBUG_PRINT(in, HEX); DEBUG_PRINT(in, HEX);
DEBUG_PRINT('\t') DEBUG_PRINT('\t')
// check status
if(((in & 0b00001110) == SX126X_STATUS_CMD_TIMEOUT) ||
((in & 0b00001110) == SX126X_STATUS_CMD_INVALID) ||
((in & 0b00001110) == SX126X_STATUS_CMD_FAILED)) {
status = in;
}
for(uint8_t n = 0; n < numBytes; n++) { for(uint8_t n = 0; n < numBytes; n++) {
dataIn[n] = spi->transfer(SX126X_CMD_NOP); dataIn[n] = spi->transfer(SX126X_CMD_NOP);
DEBUG_PRINT(SX126X_CMD_NOP, HEX); DEBUG_PRINT(SX126X_CMD_NOP, HEX);
@ -1149,4 +1255,16 @@ void SX126x::SPItransfer(uint8_t cmd, bool write, uint8_t* dataOut, uint8_t* dat
delayMicroseconds(1); delayMicroseconds(1);
while(digitalRead(_mod->getRx())); while(digitalRead(_mod->getRx()));
} }
// parse status
switch(status) {
case SX126X_STATUS_CMD_TIMEOUT:
return(ERR_SPI_CMD_TIMEOUT);
case SX126X_STATUS_CMD_INVALID:
return(ERR_SPI_CMD_INVALID);
case SX126X_STATUS_CMD_FAILED:
return(ERR_SPI_CMD_FAILED);
default:
return(ERR_NONE);
}
} }

43
src/modules/SX126x.h
View file

@ -108,6 +108,9 @@
#define SX126X_RX_TIMEOUT_NONE 0x000000 // 23 0 Rx timeout duration: no timeout (Rx single mode) #define SX126X_RX_TIMEOUT_NONE 0x000000 // 23 0 Rx timeout duration: no timeout (Rx single mode)
#define SX126X_RX_TIMEOUT_INF 0xFFFFFF // 23 0 infinite (Rx continuous mode) #define SX126X_RX_TIMEOUT_INF 0xFFFFFF // 23 0 infinite (Rx continuous mode)
//SX126X_CMD_SET_TX
#define SX126X_TX_TIMEOUT_NONE 0x000000 // 23 0 Tx timeout duration: no timeout (Tx single mode)
//SX126X_CMD_STOP_TIMER_ON_PREAMBLE //SX126X_CMD_STOP_TIMER_ON_PREAMBLE
#define SX126X_STOP_ON_PREAMBLE_OFF 0x00 // 7 0 stop timer on: sync word or header (default) #define SX126X_STOP_ON_PREAMBLE_OFF 0x00 // 7 0 stop timer on: sync word or header (default)
#define SX126X_STOP_ON_PREAMBLE_ON 0x01 // 7 0 preamble detection #define SX126X_STOP_ON_PREAMBLE_ON 0x01 // 7 0 preamble detection
@ -366,28 +369,28 @@ class SX126x: public PhysicalLayer {
protected: protected:
// SX1276x SPI command implementations // SX1276x SPI command implementations
void setTx(uint32_t timeout = 0); int16_t setTx(uint32_t timeout = 0);
void setRx(uint32_t timeout); int16_t setRx(uint32_t timeout);
void setCad(); int16_t setCad();
void setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax = SX126X_PA_CONFIG_HP_MAX, uint8_t paLut = SX126X_PA_CONFIG_PA_LUT); int16_t setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax = SX126X_PA_CONFIG_HP_MAX, uint8_t paLut = SX126X_PA_CONFIG_PA_LUT);
void writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes); int16_t writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes);
void writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset = 0x00); int16_t writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset = 0x00);
void readBuffer(uint8_t* data, uint8_t numBytes); int16_t readBuffer(uint8_t* data, uint8_t numBytes);
void setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask = SX126X_IRQ_NONE, uint16_t dio3Mask = SX126X_IRQ_NONE); int16_t setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask = SX126X_IRQ_NONE, uint16_t dio3Mask = SX126X_IRQ_NONE);
uint16_t getIrqStatus(); uint16_t getIrqStatus();
void clearIrqStatus(uint16_t clearIrqParams = SX126X_IRQ_ALL); int16_t clearIrqStatus(uint16_t clearIrqParams = SX126X_IRQ_ALL);
void setRfFrequency(uint32_t frf); int16_t setRfFrequency(uint32_t frf);
uint8_t getPacketType(); uint8_t getPacketType();
void setTxParams(uint8_t power, uint8_t rampTime = SX126X_PA_RAMP_200U); int16_t setTxParams(uint8_t power, uint8_t rampTime = SX126X_PA_RAMP_200U);
void setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro = 0xFF); int16_t setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro = 0xFF);
void setModulationParamsFSK(uint32_t br, uint8_t pulseShape, uint8_t rxBw, uint32_t freqDev); int16_t setModulationParamsFSK(uint32_t br, uint8_t pulseShape, uint8_t rxBw, uint32_t freqDev);
void setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength = 0xFF, uint8_t headerType = SX126X_LORA_HEADER_EXPLICIT, uint8_t invertIQ = SX126X_LORA_IQ_STANDARD); int16_t setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength = 0xFF, uint8_t headerType = SX126X_LORA_HEADER_EXPLICIT, uint8_t invertIQ = SX126X_LORA_IQ_STANDARD);
void setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t payloadLength = 0xFF, uint8_t packetType = SX126X_GFSK_PACKET_VARIABLE, uint8_t preambleDetectorLength = SX126X_GFSK_PREAMBLE_DETECT_16, uint8_t whitening = SX126X_GFSK_WHITENING_ON); int16_t setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t payloadLength = 0xFF, uint8_t packetType = SX126X_GFSK_PACKET_VARIABLE, uint8_t preambleDetectorLength = SX126X_GFSK_PREAMBLE_DETECT_16, uint8_t whitening = SX126X_GFSK_WHITENING_ON);
void setBufferBaseAddress(uint8_t txBaseAddress = 0x00, uint8_t rxBaseAddress = 0x00); int16_t setBufferBaseAddress(uint8_t txBaseAddress = 0x00, uint8_t rxBaseAddress = 0x00);
uint8_t getStatus(); uint8_t getStatus();
uint32_t getPacketStatus(); uint32_t getPacketStatus();
uint16_t getDeviceErrors(); uint16_t getDeviceErrors();
void clearDeviceErrors(); int16_t clearDeviceErrors();
int16_t setFrequencyRaw(float freq, bool calibrate = true); int16_t setFrequencyRaw(float freq, bool calibrate = true);
@ -409,9 +412,9 @@ class SX126x: public PhysicalLayer {
int16_t configFSK(); int16_t configFSK();
// common low-level SPI interface // common low-level SPI interface
void SPIwriteCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy = true); int16_t SPIwriteCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy = true);
void SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy = true); int16_t SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy = true);
void SPItransfer(uint8_t cmd, bool write, uint8_t* dataOut, uint8_t* dataIn, uint8_t numBytes, bool waitForBusy); int16_t SPItransfer(uint8_t cmd, bool write, uint8_t* dataOut, uint8_t* dataIn, uint8_t numBytes, bool waitForBusy);
}; };
#endif #endif