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

[SX126x] Use module stream read/write

Browse source
This commit is contained in:
jgromes 2023-02-19 17:02:51 +01:00
parent 6bf9cebc43
commit 95083e32b1
2 changed files with 38 additions and 145 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

169
src/modules/SX126x/SX126x.cpp
View file

@ -17,6 +17,7 @@ int16_t SX126x::begin(uint8_t cr, uint8_t syncWord, uint16_t preambleLength, flo
_mod->SPIreadCommand = RADIOLIB_SX126X_CMD_READ_REGISTER;
_mod->SPIwriteCommand = RADIOLIB_SX126X_CMD_WRITE_REGISTER;
_mod->SPInopCommand = RADIOLIB_SX126X_CMD_NOP;
_mod->SPIstatusCommand = RADIOLIB_SX126X_CMD_GET_STATUS;
_mod->SPIstreamType = true;
_mod->SPIparseStatusCb = SPIparseStatus;
RADIOLIB_DEBUG_PRINTLN(F("M\tSX126x"));
@ -88,6 +89,7 @@ int16_t SX126x::beginFSK(float br, float freqDev, float rxBw, uint16_t preambleL
_mod->SPIreadCommand = RADIOLIB_SX126X_CMD_READ_REGISTER;
_mod->SPIwriteCommand = RADIOLIB_SX126X_CMD_WRITE_REGISTER;
_mod->SPInopCommand = RADIOLIB_SX126X_CMD_NOP;
_mod->SPIstatusCommand = RADIOLIB_SX126X_CMD_GET_STATUS;
_mod->SPIstreamType = true;
_mod->SPIparseStatusCb = SPIparseStatus;
RADIOLIB_DEBUG_PRINTLN(F("M\tSX126x"));
@ -419,7 +421,7 @@ int16_t SX126x::sleep(bool retainConfig) {
if(!retainConfig) {
sleepMode = RADIOLIB_SX126X_SLEEP_START_COLD | RADIOLIB_SX126X_SLEEP_RTC_OFF;
}
int16_t state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_SLEEP, &sleepMode, 1, false);
int16_t state = _mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_SLEEP, &sleepMode, 1, false);
// wait for SX126x to safely enter sleep mode
_mod->delay(1);
@ -436,7 +438,7 @@ int16_t SX126x::standby(uint8_t mode) {
_mod->setRfSwitchState(Module::MODE_IDLE);
uint8_t data[] = {mode};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_STANDBY, data, 1));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_STANDBY, data, 1));
}
void SX126x::setDio1Action(void (*func)(void)) {
@ -553,7 +555,7 @@ int16_t SX126x::startReceiveDutyCycle(uint32_t rxPeriod, uint32_t sleepPeriod) {
uint8_t data[6] = {(uint8_t)((rxPeriodRaw >> 16) & 0xFF), (uint8_t)((rxPeriodRaw >> 8) & 0xFF), (uint8_t)(rxPeriodRaw & 0xFF),
(uint8_t)((sleepPeriodRaw >> 16) & 0xFF), (uint8_t)((sleepPeriodRaw >> 8) & 0xFF), (uint8_t)(sleepPeriodRaw & 0xFF)};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RX_DUTY_CYCLE, data, 6));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_RX_DUTY_CYCLE, data, 6));
}
int16_t SX126x::startReceiveDutyCycleAuto(uint16_t senderPreambleLength, uint16_t minSymbols) {
@ -853,9 +855,6 @@ int16_t SX126x::setFrequencyDeviation(float freqDev) {
uint32_t freqDevRaw = (uint32_t)(((newFreqDev * 1000.0) * (float)((uint32_t)(1) << 25)) / (RADIOLIB_SX126X_CRYSTAL_FREQ * 1000000.0));
// check modulation parameters
/*if(2 * freqDevRaw + _br > _rxBwKhz * 1000.0) {
return(RADIOLIB_ERR_INVALID_MODULATION_PARAMETERS);
}*/
_freqDev = freqDevRaw;
// update modulation parameters
@ -874,9 +873,6 @@ int16_t SX126x::setBitRate(float br) {
uint32_t brRaw = (uint32_t)((RADIOLIB_SX126X_CRYSTAL_FREQ * 1000000.0 * 32.0) / (br * 1000.0));
// check modulation parameters
/*if(2 * _freqDev + brRaw > _rxBwKhz * 1000.0) {
return(RADIOLIB_ERR_INVALID_MODULATION_PARAMETERS);
}*/
_br = brRaw;
// update modulation parameters
@ -1234,7 +1230,7 @@ float SX126x::getSNR() {
size_t SX126x::getPacketLength(bool update) {
(void)update;
uint8_t rxBufStatus[2] = {0, 0};
SPIreadCommand(RADIOLIB_SX126X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2);
_mod->SPIreadStream(RADIOLIB_SX126X_CMD_GET_RX_BUFFER_STATUS, rxBufStatus, 2);
return((size_t)rxBufStatus[0]);
}
@ -1283,7 +1279,7 @@ uint32_t SX126x::getTimeOnAir(size_t len) {
float SX126x::getRSSIInst() {
uint8_t data[3] = {0, 0, 0}; // RssiInst, Status, RFU
SPIreadCommand(RADIOLIB_SX126X_CMD_GET_RSSI_INST, data, 3);
_mod->SPIreadStream(RADIOLIB_SX126X_CMD_GET_RSSI_INST, data, 3);
return (float)data[0] / (-2.0);
}
@ -1358,10 +1354,6 @@ uint8_t SX126x::randomByte() {
return(randByte);
}
int16_t SX126x::getLastError() {
return(_lastError);
}
#if !defined(RADIOLIB_EXCLUDE_DIRECT_RECEIVE)
void SX126x::setDirectAction(void (*func)(void)) {
setDio1Action(func);
@ -1417,7 +1409,7 @@ int16_t SX126x::setTCXO(float voltage, uint32_t delay) {
_tcxoDelay = delay;
// enable TCXO control on DIO3
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_DIO3_AS_TCXO_CTRL, data, 4));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_DIO3_AS_TCXO_CTRL, data, 4));
}
int16_t SX126x::setDio2AsRfSwitch(bool enable) {
@ -1427,17 +1419,17 @@ int16_t SX126x::setDio2AsRfSwitch(bool enable) {
} else {
data = RADIOLIB_SX126X_DIO2_AS_IRQ;
}
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, &data, 1));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_DIO2_AS_RF_SWITCH_CTRL, &data, 1));
}
int16_t SX126x::setTx(uint32_t timeout) {
uint8_t data[] = { (uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF)} ;
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_TX, data, 3));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_TX, data, 3));
}
int16_t SX126x::setRx(uint32_t timeout) {
uint8_t data[] = { (uint8_t)((timeout >> 16) & 0xFF), (uint8_t)((timeout >> 8) & 0xFF), (uint8_t)(timeout & 0xFF) };
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RX, data, 3, true, false));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_RX, data, 3, true, false));
}
int16_t SX126x::setCad(uint8_t symbolNum, uint8_t detPeak, uint8_t detMin) {
@ -1475,16 +1467,16 @@ int16_t SX126x::setCad(uint8_t symbolNum, uint8_t detPeak, uint8_t detMin) {
}
// configure paramaters
int16_t state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_CAD_PARAMS, data, 7);
int16_t state = _mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_CAD_PARAMS, data, 7);
RADIOLIB_ASSERT(state);
// start CAD
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_CAD, NULL, 0));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_CAD, NULL, 0));
}
int16_t SX126x::setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax, uint8_t paLut) {
uint8_t data[] = { paDutyCycle, hpMax, deviceSel, paLut };
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PA_CONFIG, data, 4));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_PA_CONFIG, data, 4));
}
int16_t SX126x::writeRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) {
@ -1497,18 +1489,18 @@ int16_t SX126x::readRegister(uint16_t addr, uint8_t* data, uint8_t numBytes) {
_mod->SPIreadRegisterBurst(addr, numBytes, data);
// check the status
int16_t state = checkCommandResult();
int16_t state = _mod->SPIcheckStream();
return(state);
}
int16_t SX126x::writeBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset) {
uint8_t cmd[] = { RADIOLIB_SX126X_CMD_WRITE_BUFFER, offset };
return(SPIwriteCommand(cmd, 2, data, numBytes));
return(_mod->SPIwriteStream(cmd, 2, data, numBytes));
}
int16_t SX126x::readBuffer(uint8_t* data, uint8_t numBytes) {
uint8_t cmd[] = { RADIOLIB_SX126X_CMD_READ_BUFFER, RADIOLIB_SX126X_CMD_NOP };
return(SPIreadCommand(cmd, 2, data, numBytes));
return(_mod->SPIreadStream(cmd, 2, data, numBytes));
}
int16_t SX126x::setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask) {
@ -1516,38 +1508,38 @@ int16_t SX126x::setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t di
(uint8_t)((dio1Mask >> 8) & 0xFF), (uint8_t)(dio1Mask & 0xFF),
(uint8_t)((dio2Mask >> 8) & 0xFF), (uint8_t)(dio2Mask & 0xFF),
(uint8_t)((dio3Mask >> 8) & 0xFF), (uint8_t)(dio3Mask & 0xFF)};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_DIO_IRQ_PARAMS, data, 8));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_DIO_IRQ_PARAMS, data, 8));
}
uint16_t SX126x::getIrqStatus() {
uint8_t data[] = { 0x00, 0x00 };
SPIreadCommand(RADIOLIB_SX126X_CMD_GET_IRQ_STATUS, data, 2);
_mod->SPIreadStream(RADIOLIB_SX126X_CMD_GET_IRQ_STATUS, data, 2);
return(((uint16_t)(data[0]) << 8) | data[1]);
}
int16_t SX126x::clearIrqStatus(uint16_t clearIrqParams) {
uint8_t data[] = { (uint8_t)((clearIrqParams >> 8) & 0xFF), (uint8_t)(clearIrqParams & 0xFF) };
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_CLEAR_IRQ_STATUS, data, 2));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_CLEAR_IRQ_STATUS, data, 2));
}
int16_t SX126x::setRfFrequency(uint32_t frf) {
uint8_t data[] = { (uint8_t)((frf >> 24) & 0xFF), (uint8_t)((frf >> 16) & 0xFF), (uint8_t)((frf >> 8) & 0xFF), (uint8_t)(frf & 0xFF) };
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RF_FREQUENCY, data, 4));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_RF_FREQUENCY, data, 4));
}
int16_t SX126x::calibrateImage(uint8_t* data) {
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_CALIBRATE_IMAGE, data, 2));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_CALIBRATE_IMAGE, data, 2));
}
uint8_t SX126x::getPacketType() {
uint8_t data = 0xFF;
SPIreadCommand(RADIOLIB_SX126X_CMD_GET_PACKET_TYPE, &data, 1);
_mod->SPIreadStream(RADIOLIB_SX126X_CMD_GET_PACKET_TYPE, &data, 1);
return(data);
}
int16_t SX126x::setTxParams(uint8_t power, uint8_t rampTime) {
uint8_t data[] = { power, rampTime };
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_TX_PARAMS, data, 2));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_TX_PARAMS, data, 2));
}
int16_t SX126x::setPacketMode(uint8_t mode, uint8_t len) {
@ -1600,62 +1592,62 @@ int16_t SX126x::setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t
// 500/9/8 - 0x09 0x04 0x03 0x00 - SF9, BW125, 4/8
// 500/11/8 - 0x0B 0x04 0x03 0x00 - SF11 BW125, 4/7
uint8_t data[4] = {sf, bw, cr, _ldro};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS, data, 4));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS, data, 4));
}
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),
pulseShape, rxBw,
(uint8_t)((freqDev >> 16) & 0xFF), (uint8_t)((freqDev >> 8) & 0xFF), (uint8_t)(freqDev & 0xFF)};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS, data, 8));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_MODULATION_PARAMS, data, 8));
}
int16_t SX126x::setPacketParams(uint16_t preambleLength, uint8_t crcType, uint8_t payloadLength, uint8_t headerType, uint8_t invertIQ) {
int16_t state = fixInvertedIQ(invertIQ);
RADIOLIB_ASSERT(state);
uint8_t data[6] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF), headerType, payloadLength, crcType, invertIQ};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS, data, 6));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS, data, 6));
}
int16_t SX126x::setPacketParamsFSK(uint16_t preambleLength, uint8_t crcType, uint8_t syncWordLength, uint8_t addrComp, uint8_t whitening, uint8_t packetType, uint8_t payloadLength, uint8_t preambleDetectorLength) {
uint8_t data[9] = {(uint8_t)((preambleLength >> 8) & 0xFF), (uint8_t)(preambleLength & 0xFF),
preambleDetectorLength, syncWordLength, addrComp,
packetType, payloadLength, crcType, whitening};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS, data, 9));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_PACKET_PARAMS, data, 9));
}
int16_t SX126x::setBufferBaseAddress(uint8_t txBaseAddress, uint8_t rxBaseAddress) {
uint8_t data[2] = {txBaseAddress, rxBaseAddress};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_BUFFER_BASE_ADDRESS, data, 2));
}
int16_t SX126x::setRegulatorMode(uint8_t mode) {
uint8_t data[1] = {mode};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_REGULATOR_MODE, data, 1));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_REGULATOR_MODE, data, 1));
}
uint8_t SX126x::getStatus() {
uint8_t data = 0;
SPIreadCommand(RADIOLIB_SX126X_CMD_GET_STATUS, &data, 1);
_mod->SPIreadStream(RADIOLIB_SX126X_CMD_GET_STATUS, &data, 1);
return(data);
}
uint32_t SX126x::getPacketStatus() {
uint8_t data[3] = {0, 0, 0};
SPIreadCommand(RADIOLIB_SX126X_CMD_GET_PACKET_STATUS, data, 3);
_mod->SPIreadStream(RADIOLIB_SX126X_CMD_GET_PACKET_STATUS, data, 3);
return((((uint32_t)data[0]) << 16) | (((uint32_t)data[1]) << 8) | (uint32_t)data[2]);
}
uint16_t SX126x::getDeviceErrors() {
uint8_t data[2] = {0, 0};
SPIreadCommand(RADIOLIB_SX126X_CMD_GET_DEVICE_ERRORS, data, 2);
_mod->SPIreadStream(RADIOLIB_SX126X_CMD_GET_DEVICE_ERRORS, data, 2);
uint16_t opError = (((uint16_t)data[0] & 0xFF) << 8) & ((uint16_t)data[1]);
return(opError);
}
int16_t SX126x::clearDeviceErrors() {
uint8_t data[2] = {RADIOLIB_SX126X_CMD_NOP, RADIOLIB_SX126X_CMD_NOP};
return(SPIwriteCommand(RADIOLIB_SX126X_CMD_CLEAR_DEVICE_ERRORS, data, 2));
return(_mod->SPIwriteStream(RADIOLIB_SX126X_CMD_CLEAR_DEVICE_ERRORS, data, 2));
}
int16_t SX126x::setFrequencyRaw(float freq) {
@ -1752,12 +1744,12 @@ int16_t SX126x::config(uint8_t modem) {
// set modem
uint8_t data[7];
data[0] = modem;
state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_PACKET_TYPE, data, 1);
state = _mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_PACKET_TYPE, data, 1);
RADIOLIB_ASSERT(state);
// set Rx/Tx fallback mode to STDBY_RC
data[0] = RADIOLIB_SX126X_RX_TX_FALLBACK_MODE_STDBY_RC;
state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1);
state = _mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_RX_TX_FALLBACK_MODE, data, 1);
RADIOLIB_ASSERT(state);
// set some CAD parameters - will be overwritten whel calling CAD anyway
@ -1768,7 +1760,7 @@ int16_t SX126x::config(uint8_t modem) {
data[4] = 0x00;
data[5] = 0x00;
data[6] = 0x00;
state = SPIwriteCommand(RADIOLIB_SX126X_CMD_SET_CAD_PARAMS, data, 7);
state = _mod->SPIwriteStream(RADIOLIB_SX126X_CMD_SET_CAD_PARAMS, data, 7);
RADIOLIB_ASSERT(state);
// clear IRQ
@ -1778,7 +1770,7 @@ int16_t SX126x::config(uint8_t modem) {
// calibrate all blocks
data[0] = RADIOLIB_SX126X_CALIBRATE_ALL;
state = SPIwriteCommand(RADIOLIB_SX126X_CMD_CALIBRATE, data, 1, true, false);
state = _mod->SPIwriteStream(RADIOLIB_SX126X_CMD_CALIBRATE, data, 1, true, false);
RADIOLIB_ASSERT(state);
// wait for calibration completion
@ -1790,91 +1782,6 @@ int16_t SX126x::config(uint8_t modem) {
return(RADIOLIB_ERR_NONE);
}
int16_t SX126x::checkCommandResult() {
int16_t state = RADIOLIB_ERR_NONE;
#if defined(RADIOLIB_SPI_PARANOID)
// get the status
uint8_t spiStatus = 0;
uint8_t cmd = RADIOLIB_SX126X_CMD_GET_STATUS;
state = _mod->SPItransferStream(&cmd, 1, false, NULL, &spiStatus, 1, true, 5000);
RADIOLIB_ASSERT(state);
// translate to RadioLib status code
switch(spiStatus) {
case RADIOLIB_SX126X_STATUS_CMD_TIMEOUT:
_lastError = RADIOLIB_ERR_SPI_CMD_TIMEOUT;
break;
case RADIOLIB_SX126X_STATUS_CMD_INVALID:
_lastError = RADIOLIB_ERR_SPI_CMD_INVALID;
break;
case RADIOLIB_SX126X_STATUS_CMD_FAILED:
_lastError = RADIOLIB_ERR_SPI_CMD_FAILED;
break;
case RADIOLIB_SX126X_STATUS_SPI_FAILED:
_lastError = RADIOLIB_ERR_CHIP_NOT_FOUND;
break;
default:
_lastError = RADIOLIB_ERR_NONE;
}
#endif
return(state);
}
int16_t SX126x::SPIwriteCommand(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, uint8_t numBytes, bool waitForBusy, bool verify) {
// send the command
int16_t state = _mod->SPItransferStream(cmd, cmdLen, true, data, NULL, numBytes, waitForBusy, 5000);
RADIOLIB_ASSERT(state);
// check the status
if(verify) {
state = checkCommandResult();
}
return(state);
}
int16_t SX126x::SPIwriteCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy, bool verify) {
// send the command
int16_t state = _mod->SPItransferStream(&cmd, 1, true, data, NULL, numBytes, waitForBusy, 5000);
RADIOLIB_ASSERT(state);
// check the status
if(verify) {
state = checkCommandResult();
}
return(state);
}
int16_t SX126x::SPIreadCommand(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, uint8_t numBytes, bool waitForBusy, bool verify) {
// send the command
int16_t state = _mod->SPItransferStream(cmd, cmdLen, false, NULL, data, numBytes, waitForBusy, 5000);
RADIOLIB_ASSERT(state);
// check the status
if(verify) {
state = checkCommandResult();
}
return(state);
}
int16_t SX126x::SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy, bool verify) {
// send the command
int16_t state = _mod->SPItransferStream(&cmd, 1, false, NULL, data, numBytes, waitForBusy, 5000);
RADIOLIB_ASSERT(state);
// check the status
if(verify) {
state = checkCommandResult();
}
return(state);
}
int16_t SX126x::SPIparseStatus(uint8_t in) {
if((in & 0b00001110) == RADIOLIB_SX126X_STATUS_CMD_TIMEOUT) {
return(RADIOLIB_ERR_SPI_CMD_TIMEOUT);

14
src/modules/SX126x/SX126x.h
View file

@ -985,13 +985,6 @@ class SX126x: public PhysicalLayer {
*/
uint8_t randomByte();
/*!
\brief Get the last recorded transaction error.
\returns \ref status_codes
*/
int16_t getLastError();
#if !defined(RADIOLIB_EXCLUDE_DIRECT_RECEIVE)
/*!
\brief Dummy method, to ensure PhysicalLayer compatibility.
@ -1057,10 +1050,6 @@ class SX126x: public PhysicalLayer {
Module* _mod;
// common low-level SPI interface
int16_t SPIwriteCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy = true, bool verify = true);
int16_t SPIwriteCommand(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, uint8_t numBytes, bool waitForBusy = true, bool verify = true);
int16_t SPIreadCommand(uint8_t cmd, uint8_t* data, uint8_t numBytes, bool waitForBusy = true, bool verify = true);
int16_t SPIreadCommand(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, uint8_t numBytes, bool waitForBusy = true, bool verify = true);
static int16_t SPIparseStatus(uint8_t in);
#if !defined(RADIOLIB_GODMODE)
@ -1083,13 +1072,10 @@ class SX126x: public PhysicalLayer {
size_t _implicitLen = 0;
int16_t _lastError = RADIOLIB_ERR_NONE;
// Allow subclasses to define different TX modes
uint8_t _tx_mode = Module::MODE_TX;
int16_t config(uint8_t modem);
int16_t checkCommandResult();
};
#endif