667 lines
19 KiB
C++
667 lines
19 KiB
C++
// Copyright (c) Sandeep Mistry. All rights reserved.
|
|
// Licensed under the MIT license.
|
|
|
|
// Modifications and additions copyright 2023 by Mark Qvist & Jacob Eva
|
|
// Obviously still under the MIT license.
|
|
|
|
#ifndef RADIO_H
|
|
#define RADIO_H
|
|
|
|
#include <Arduino.h>
|
|
#include <SPI.h>
|
|
#include "Interfaces.h"
|
|
#include "Boards.h"
|
|
|
|
#define MAX_PKT_LENGTH 255
|
|
|
|
// TX
|
|
#define PA_OUTPUT_RFO_PIN 0
|
|
#define PA_OUTPUT_PA_BOOST_PIN 1
|
|
|
|
// DCD
|
|
#define STATUS_INTERVAL_MS 3
|
|
#define DCD_SAMPLES 2500
|
|
#define UTIL_UPDATE_INTERVAL_MS 1000
|
|
#define UTIL_UPDATE_INTERVAL (UTIL_UPDATE_INTERVAL_MS/STATUS_INTERVAL_MS)
|
|
#define AIRTIME_LONGTERM 3600
|
|
#define AIRTIME_LONGTERM_MS (AIRTIME_LONGTERM*1000)
|
|
#define AIRTIME_BINLEN_MS (STATUS_INTERVAL_MS*DCD_SAMPLES)
|
|
#define AIRTIME_BINS ((AIRTIME_LONGTERM*1000)/AIRTIME_BINLEN_MS)
|
|
#define current_airtime_bin(void) (millis()%AIRTIME_LONGTERM_MS)/AIRTIME_BINLEN_MS
|
|
#define DCD_THRESHOLD 2
|
|
#define DCD_LED_STEP_D 3
|
|
#define LORA_PREAMBLE_SYMBOLS_HW 4
|
|
#define LORA_PREAMBLE_SYMBOLS_MIN 18
|
|
#define LORA_PREAMBLE_TARGET_MS 15
|
|
#define LORA_PREAMBLE_FAST_TARGET_MS 1
|
|
#define LORA_FAST_BITRATE_THRESHOLD 40000
|
|
|
|
#define RSSI_OFFSET 157
|
|
|
|
#define PHY_HEADER_LORA_SYMBOLS 8
|
|
|
|
#define _e 2.71828183
|
|
#define _S 10.0
|
|
|
|
// Status flags
|
|
const uint8_t SIG_DETECT = 0x01;
|
|
const uint8_t SIG_SYNCED = 0x02;
|
|
const uint8_t RX_ONGOING = 0x04;
|
|
|
|
// forward declare Utilities.h LED functions
|
|
void led_rx_on();
|
|
|
|
void led_rx_off();
|
|
void led_indicate_airtime_lock();
|
|
|
|
#if PLATFORM == PLATFORM_ESP32
|
|
// get update_lock for ESP32
|
|
extern portMUX_TYPE update_lock;
|
|
#endif
|
|
|
|
class RadioInterface : public Stream {
|
|
public:
|
|
// todo: in the future define _spiModem and _spiSettings from here for inheritence by child classes
|
|
RadioInterface(uint8_t index) : _index(index), _radio_locked(false),
|
|
_radio_online(false), _st_airtime_limit(0.0), _lt_airtime_limit(0.0),
|
|
_airtime_lock(false), _airtime(0.0), _longterm_airtime(0.0),
|
|
_local_channel_util(0.0), _total_channel_util(0.0),
|
|
_longterm_channel_util(0.0), _last_status_update(0), _last_dcd(0),
|
|
_stat_rx_ongoing(false), _stat_signal_detected(false),
|
|
_stat_signal_synced(false), _dcd_count(0), _dcd(false), _dcd_led(false),
|
|
_dcd_waiting(false), _dcd_wait_until(0), _dcd_sample(0),
|
|
_post_tx_yield_timeout(0), _csma_slot_ms(50), _csma_p_min(0.1),
|
|
_csma_p_max(0.8), _preambleLength(6), _lora_symbol_time_ms(0.0),
|
|
_lora_symbol_rate(0.0), _lora_us_per_byte(0.0), _bitrate(0),
|
|
_onReceive(NULL), _packet{0} {};
|
|
virtual int begin();
|
|
virtual void end();
|
|
|
|
virtual int beginPacket(int implicitHeader = false);
|
|
virtual int endPacket();
|
|
|
|
virtual int packetRssi();
|
|
virtual int currentRssi();
|
|
virtual uint8_t packetRssiRaw();
|
|
virtual uint8_t currentRssiRaw();
|
|
virtual uint8_t packetSnrRaw();
|
|
virtual float packetSnr();
|
|
virtual long packetFrequencyError();
|
|
|
|
// from Print
|
|
virtual size_t write(uint8_t byte);
|
|
virtual size_t write(const uint8_t *buffer, size_t size);
|
|
|
|
// from Stream
|
|
virtual int available();
|
|
virtual int read();
|
|
virtual int peek();
|
|
virtual void flush();
|
|
|
|
virtual void onReceive(void(*callback)(uint8_t, int));
|
|
|
|
virtual void receive(int size = 0);
|
|
virtual void standby();
|
|
virtual void sleep();
|
|
|
|
virtual bool preInit();
|
|
virtual uint8_t getTxPower();
|
|
virtual void setTxPower(int level, int outputPin = PA_OUTPUT_PA_BOOST_PIN);
|
|
virtual uint32_t getFrequency();
|
|
virtual void setFrequency(uint32_t frequency);
|
|
virtual void setSpreadingFactor(int sf);
|
|
virtual uint8_t getSpreadingFactor();
|
|
virtual uint32_t getSignalBandwidth();
|
|
virtual void setSignalBandwidth(uint32_t sbw);
|
|
virtual void setCodingRate4(int denominator);
|
|
virtual uint8_t getCodingRate4();
|
|
virtual void setPreambleLength(long length);
|
|
virtual uint8_t modemStatus();
|
|
virtual void enableCrc();
|
|
virtual void disableCrc();
|
|
virtual void enableTCXO();
|
|
virtual void disableTCXO();
|
|
|
|
virtual byte random();
|
|
|
|
virtual void setSPIFrequency(uint32_t frequency);
|
|
|
|
virtual void updateBitrate();
|
|
virtual void handleDio0Rise();
|
|
virtual void clearIRQStatus();
|
|
uint32_t getBitrate() { return _bitrate; };
|
|
uint8_t getIndex() { return _index; };
|
|
void setRadioLock(bool lock) { _radio_locked = lock; };
|
|
bool getRadioLock() { return _radio_locked; };
|
|
void setRadioOnline(bool online) { _radio_online = online; };
|
|
bool getRadioOnline() { return _radio_online; };
|
|
void setSTALock(float at) { _st_airtime_limit = at; };
|
|
float getSTALock() { return _st_airtime_limit; };
|
|
void setLTALock(float at) { _lt_airtime_limit = at; };
|
|
float getLTALock() { return _lt_airtime_limit; };
|
|
bool calculateALock() {
|
|
_airtime_lock = false;
|
|
if (_st_airtime_limit != 0.0 && _airtime >= _st_airtime_limit) {
|
|
_airtime_lock = true;
|
|
}
|
|
if (_lt_airtime_limit != 0.0 && _longterm_airtime >= _lt_airtime_limit) {
|
|
_airtime_lock = true;
|
|
}
|
|
return _airtime_lock;
|
|
};
|
|
void updateAirtime() {
|
|
uint16_t cb = current_airtime_bin();
|
|
uint16_t pb = cb-1; if (cb-1 < 0) { pb = AIRTIME_BINS-1; }
|
|
uint16_t nb = cb+1; if (nb == AIRTIME_BINS) { nb = 0; }
|
|
_airtime_bins[nb] = 0;
|
|
_airtime = (float)(_airtime_bins[cb]+_airtime_bins[pb])/(2.0*AIRTIME_BINLEN_MS);
|
|
|
|
uint32_t longterm_airtime_sum = 0;
|
|
for (uint16_t bin = 0; bin < AIRTIME_BINS; bin++) {
|
|
longterm_airtime_sum += _airtime_bins[bin];
|
|
}
|
|
_longterm_airtime = (float)longterm_airtime_sum/(float)AIRTIME_LONGTERM_MS;
|
|
|
|
float longterm_channel_util_sum = 0.0;
|
|
for (uint16_t bin = 0; bin < AIRTIME_BINS; bin++) {
|
|
longterm_channel_util_sum += _longterm_bins[bin];
|
|
}
|
|
_longterm_channel_util = (float)longterm_channel_util_sum/(float)AIRTIME_BINS;
|
|
|
|
updateCSMAp();
|
|
|
|
//kiss_indicate_channel_stats(); // todo: enable me!
|
|
};
|
|
void addAirtime(uint16_t written) {
|
|
float packet_cost_ms = 0.0;
|
|
float payload_cost_ms = ((float)written * _lora_us_per_byte)/1000.0;
|
|
packet_cost_ms += payload_cost_ms;
|
|
packet_cost_ms += (_preambleLength+4.25)*_lora_symbol_time_ms;
|
|
packet_cost_ms += PHY_HEADER_LORA_SYMBOLS * _lora_symbol_time_ms;
|
|
uint16_t cb = current_airtime_bin();
|
|
uint16_t nb = cb+1; if (nb == AIRTIME_BINS) { nb = 0; }
|
|
_airtime_bins[cb] += packet_cost_ms;
|
|
_airtime_bins[nb] = 0;
|
|
};
|
|
void checkModemStatus() {
|
|
if (millis()-_last_status_update >= STATUS_INTERVAL_MS) {
|
|
updateModemStatus();
|
|
|
|
_util_samples[_dcd_sample] = _dcd;
|
|
_dcd_sample = (_dcd_sample+1)%DCD_SAMPLES;
|
|
if (_dcd_sample % UTIL_UPDATE_INTERVAL == 0) {
|
|
int util_count = 0;
|
|
for (int ui = 0; ui < DCD_SAMPLES; ui++) {
|
|
if (_util_samples[ui]) util_count++;
|
|
}
|
|
_local_channel_util = (float)util_count / (float)DCD_SAMPLES;
|
|
_total_channel_util = _local_channel_util + _airtime;
|
|
if (_total_channel_util > 1.0) _total_channel_util = 1.0;
|
|
|
|
int16_t cb = current_airtime_bin();
|
|
uint16_t nb = cb+1; if (nb == AIRTIME_BINS) { nb = 0; }
|
|
if (_total_channel_util > _longterm_bins[cb]) _longterm_bins[cb] = _total_channel_util;
|
|
_longterm_bins[nb] = 0.0;
|
|
|
|
updateAirtime();
|
|
}
|
|
}
|
|
};
|
|
void updateModemStatus() {
|
|
#if PLATFORM == PLATFORM_ESP32
|
|
portENTER_CRITICAL(&update_lock);
|
|
#elif PLATFORM == PLATFORM_NRF52
|
|
portENTER_CRITICAL();
|
|
#endif
|
|
|
|
uint8_t status = modemStatus();
|
|
|
|
_last_status_update = millis();
|
|
|
|
#if PLATFORM == PLATFORM_ESP32
|
|
portEXIT_CRITICAL(&update_lock);
|
|
#elif PLATFORM == PLATFORM_NRF52
|
|
portEXIT_CRITICAL();
|
|
#endif
|
|
|
|
if ((status & SIG_DETECT) == SIG_DETECT) { _stat_signal_detected = true; } else { _stat_signal_detected = false; }
|
|
if ((status & SIG_SYNCED) == SIG_SYNCED) { _stat_signal_synced = true; } else { _stat_signal_synced = false; }
|
|
if ((status & RX_ONGOING) == RX_ONGOING) { _stat_rx_ongoing = true; } else { _stat_rx_ongoing = false; }
|
|
|
|
// if (stat_signal_detected || stat_signal_synced || stat_rx_ongoing) {
|
|
if (_stat_signal_detected || _stat_signal_synced) {
|
|
if (_stat_rx_ongoing) {
|
|
if (_dcd_count < DCD_THRESHOLD) {
|
|
_dcd_count++;
|
|
} else {
|
|
_last_dcd = _last_status_update;
|
|
_dcd_led = true;
|
|
_dcd = true;
|
|
}
|
|
}
|
|
} else {
|
|
if (_dcd_count == 0) {
|
|
_dcd_led = false;
|
|
} else if (_dcd_count > DCD_LED_STEP_D) {
|
|
_dcd_count -= DCD_LED_STEP_D;
|
|
} else {
|
|
_dcd_count = 0;
|
|
}
|
|
|
|
if (_last_status_update > _last_dcd+_csma_slot_ms) {
|
|
_dcd = false;
|
|
_dcd_led = false;
|
|
_dcd_count = 0;
|
|
}
|
|
}
|
|
|
|
|
|
if (_dcd_led) {
|
|
led_rx_on();
|
|
} else {
|
|
if (_airtime_lock) {
|
|
led_indicate_airtime_lock();
|
|
} else {
|
|
led_rx_off();
|
|
}
|
|
}
|
|
};
|
|
void setPostTxYieldTimeout(uint32_t timeout) { _post_tx_yield_timeout = timeout; };
|
|
uint32_t getPostTxYieldTimeout() { return _post_tx_yield_timeout; };
|
|
void setDCD(bool dcd) { _dcd = dcd; };
|
|
bool getDCD() { return _dcd; };
|
|
void setDCDWaiting(bool dcd_waiting) { _dcd_waiting = dcd_waiting; };
|
|
bool getDCDWaiting() { return _dcd_waiting; };
|
|
void setDCDWaitUntil(uint32_t dcd_wait_until) { _dcd_wait_until = dcd_wait_until; };
|
|
bool getDCDWaitUntil() { return _dcd_wait_until; };
|
|
float getAirtime() { return _airtime; };
|
|
float getLongtermAirtime() { return _longterm_airtime; };
|
|
float getTotalChannelUtil() { return _total_channel_util; };
|
|
float getLongtermChannelUtil() { return _longterm_channel_util; };
|
|
float CSMASlope(float u) { return (pow(_e,_S*u-_S/2.0))/(pow(_e,_S*u-_S/2.0)+1.0); };
|
|
void updateCSMAp() {
|
|
_csma_p = (uint8_t)((1.0-(_csma_p_min+(_csma_p_max-_csma_p_min)*CSMASlope(_airtime)))*255.0);
|
|
};
|
|
uint8_t getCSMAp() { return _csma_p; };
|
|
void setCSMASlotMS(int slot_size) { _csma_slot_ms = slot_size; };
|
|
int getCSMASlotMS() { return _csma_slot_ms; };
|
|
float getSymbolTime() { return _lora_symbol_time_ms; };
|
|
float getSymbolRate() { return _lora_symbol_rate; };
|
|
long getPreambleLength() { return _preambleLength; };
|
|
protected:
|
|
virtual void explicitHeaderMode();
|
|
virtual void implicitHeaderMode();
|
|
|
|
uint8_t _index;
|
|
bool _radio_locked;
|
|
bool _radio_online;
|
|
float _st_airtime_limit;
|
|
float _lt_airtime_limit;
|
|
bool _airtime_lock;
|
|
uint16_t _airtime_bins[AIRTIME_BINS] = {0};
|
|
uint16_t _longterm_bins[AIRTIME_BINS] = {0};
|
|
float _airtime;
|
|
float _longterm_airtime;
|
|
float _local_channel_util;
|
|
float _total_channel_util;
|
|
float _longterm_channel_util;
|
|
uint32_t _last_status_update;
|
|
bool _stat_signal_detected;
|
|
bool _stat_signal_synced;
|
|
bool _stat_rx_ongoing;
|
|
uint32_t _last_dcd;
|
|
uint16_t _dcd_count;
|
|
bool _dcd;
|
|
bool _dcd_led;
|
|
bool _dcd_waiting;
|
|
long _dcd_wait_until;
|
|
bool _util_samples[DCD_SAMPLES] = {false};
|
|
int _dcd_sample;
|
|
uint32_t _post_tx_yield_timeout;
|
|
uint8_t _csma_p;
|
|
int _csma_slot_ms;
|
|
float _csma_p_min;
|
|
float _csma_p_max;
|
|
long _preambleLength;
|
|
float _lora_symbol_time_ms;
|
|
float _lora_symbol_rate;
|
|
float _lora_us_per_byte;
|
|
uint32_t _bitrate;
|
|
uint8_t _packet[255];
|
|
void (*_onReceive)(uint8_t, int);
|
|
};
|
|
|
|
class sx126x : public RadioInterface {
|
|
public:
|
|
sx126x(uint8_t index, SPIClass spi, bool tcxo, bool dio2_as_rf_switch, int ss, int sclk, int mosi, int miso, int reset, int
|
|
dio0, int busy, int rxen);
|
|
|
|
int begin();
|
|
void end();
|
|
|
|
int beginPacket(int implicitHeader = false);
|
|
int endPacket();
|
|
|
|
int packetRssi();
|
|
int currentRssi();
|
|
uint8_t packetRssiRaw();
|
|
uint8_t currentRssiRaw();
|
|
uint8_t packetSnrRaw();
|
|
float packetSnr();
|
|
long packetFrequencyError();
|
|
|
|
// from Print
|
|
size_t write(uint8_t byte);
|
|
size_t write(const uint8_t *buffer, size_t size);
|
|
|
|
// from Stream
|
|
int available();
|
|
int read();
|
|
int peek();
|
|
void flush();
|
|
|
|
void onReceive(void(*callback)(uint8_t, int));
|
|
|
|
void receive(int size = 0);
|
|
void standby();
|
|
void sleep();
|
|
|
|
bool preInit();
|
|
uint8_t getTxPower();
|
|
void setTxPower(int level, int outputPin = PA_OUTPUT_PA_BOOST_PIN);
|
|
uint32_t getFrequency();
|
|
void setFrequency(uint32_t frequency);
|
|
void setSpreadingFactor(int sf);
|
|
uint8_t getSpreadingFactor();
|
|
uint32_t getSignalBandwidth();
|
|
void setSignalBandwidth(uint32_t sbw);
|
|
void setCodingRate4(int denominator);
|
|
uint8_t getCodingRate4();
|
|
void setPreambleLength(long length);
|
|
uint8_t modemStatus();
|
|
void enableCrc();
|
|
void disableCrc();
|
|
void enableTCXO();
|
|
void disableTCXO();
|
|
|
|
|
|
byte random();
|
|
|
|
void setSPIFrequency(uint32_t frequency);
|
|
|
|
void dumpRegisters(Stream& out);
|
|
|
|
void updateBitrate();
|
|
|
|
void handleDio0Rise();
|
|
private:
|
|
void writeBuffer(const uint8_t* buffer, size_t size);
|
|
void readBuffer(uint8_t* buffer, size_t size);
|
|
void loraMode();
|
|
void rxAntEnable();
|
|
void setPacketParams(uint32_t preamble, uint8_t headermode, uint8_t length, uint8_t crc);
|
|
void setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, int ldro);
|
|
void setSyncWord(uint16_t sw);
|
|
void waitOnBusy();
|
|
void executeOpcode(uint8_t opcode, uint8_t *buffer, uint8_t size);
|
|
void executeOpcodeRead(uint8_t opcode, uint8_t *buffer, uint8_t size);
|
|
void explicitHeaderMode();
|
|
void implicitHeaderMode();
|
|
|
|
|
|
uint8_t readRegister(uint16_t address);
|
|
void writeRegister(uint16_t address, uint8_t value);
|
|
uint8_t singleTransfer(uint8_t opcode, uint16_t address, uint8_t value);
|
|
|
|
static void onDio0Rise();
|
|
|
|
void handleLowDataRate();
|
|
void optimizeModemSensitivity();
|
|
|
|
void reset(void);
|
|
void calibrate(void);
|
|
void calibrate_image(uint32_t frequency);
|
|
void clearIRQStatus();
|
|
|
|
private:
|
|
SPISettings _spiSettings;
|
|
SPIClass _spiModem;
|
|
int _ss;
|
|
int _sclk;
|
|
int _mosi;
|
|
int _miso;
|
|
int _reset;
|
|
int _dio0;
|
|
int _rxen;
|
|
int _busy;
|
|
uint32_t _frequency;
|
|
int _txp;
|
|
uint8_t _sf;
|
|
uint8_t _bw;
|
|
uint8_t _cr;
|
|
uint8_t _ldro;
|
|
int _packetIndex;
|
|
int _implicitHeaderMode;
|
|
int _payloadLength;
|
|
int _crcMode;
|
|
int _fifo_tx_addr_ptr;
|
|
int _fifo_rx_addr_ptr;
|
|
bool _preinit_done;
|
|
uint8_t _index;
|
|
bool _tcxo;
|
|
bool _dio2_as_rf_switch;
|
|
};
|
|
|
|
class sx127x : public RadioInterface {
|
|
public:
|
|
sx127x(uint8_t index, SPIClass spi, int ss, int sclk, int mosi, int miso, int reset, int dio0, int busy);
|
|
|
|
int begin();
|
|
void end();
|
|
|
|
int beginPacket(int implicitHeader = false);
|
|
int endPacket();
|
|
|
|
int packetRssi();
|
|
int currentRssi();
|
|
uint8_t packetRssiRaw();
|
|
uint8_t currentRssiRaw();
|
|
uint8_t packetSnrRaw();
|
|
float packetSnr();
|
|
long packetFrequencyError();
|
|
|
|
// from Print
|
|
size_t write(uint8_t byte);
|
|
size_t write(const uint8_t *buffer, size_t size);
|
|
|
|
// from Stream
|
|
int available();
|
|
int read();
|
|
int peek();
|
|
void flush();
|
|
|
|
void onReceive(void(*callback)(uint8_t, int));
|
|
|
|
void receive(int size = 0);
|
|
void standby();
|
|
void sleep();
|
|
|
|
bool preInit();
|
|
uint8_t getTxPower();
|
|
void setTxPower(int level, int outputPin = PA_OUTPUT_PA_BOOST_PIN);
|
|
uint32_t getFrequency();
|
|
void setFrequency(uint32_t frequency);
|
|
void setSpreadingFactor(int sf);
|
|
uint8_t getSpreadingFactor();
|
|
uint32_t getSignalBandwidth();
|
|
void setSignalBandwidth(uint32_t sbw);
|
|
void setCodingRate4(int denominator);
|
|
uint8_t getCodingRate4();
|
|
void setPreambleLength(long length);
|
|
uint8_t modemStatus();
|
|
void enableCrc();
|
|
void disableCrc();
|
|
void enableTCXO();
|
|
void disableTCXO();
|
|
|
|
byte random();
|
|
|
|
void setSPIFrequency(uint32_t frequency);
|
|
|
|
void updateBitrate();
|
|
|
|
void handleDio0Rise();
|
|
void clearIRQStatus();
|
|
private:
|
|
void setSyncWord(uint8_t sw);
|
|
void explicitHeaderMode();
|
|
void implicitHeaderMode();
|
|
|
|
|
|
uint8_t readRegister(uint8_t address);
|
|
void writeRegister(uint8_t address, uint8_t value);
|
|
uint8_t singleTransfer(uint8_t address, uint8_t value);
|
|
|
|
static void onDio0Rise();
|
|
|
|
void handleLowDataRate();
|
|
void optimizeModemSensitivity();
|
|
|
|
private:
|
|
SPISettings _spiSettings;
|
|
SPIClass _spiModem;
|
|
int _ss;
|
|
int _sclk;
|
|
int _mosi;
|
|
int _miso;
|
|
int _reset;
|
|
int _dio0;
|
|
int _busy;
|
|
uint32_t _frequency;
|
|
int _packetIndex;
|
|
int _implicitHeaderMode;
|
|
bool _preinit_done;
|
|
uint8_t _index;
|
|
uint8_t _sf;
|
|
uint8_t _cr;
|
|
};
|
|
|
|
class sx128x : public RadioInterface {
|
|
public:
|
|
sx128x(uint8_t index, SPIClass spi, bool tcxo, int ss, int sclk, int mosi, int miso, int reset, int dio0, int busy, int rxen, int txen);
|
|
|
|
int begin();
|
|
void end();
|
|
|
|
int beginPacket(int implicitHeader = false);
|
|
int endPacket();
|
|
|
|
int packetRssi();
|
|
int currentRssi();
|
|
uint8_t packetRssiRaw();
|
|
uint8_t currentRssiRaw();
|
|
uint8_t packetSnrRaw();
|
|
float packetSnr();
|
|
long packetFrequencyError();
|
|
|
|
// from Print
|
|
size_t write(uint8_t byte);
|
|
size_t write(const uint8_t *buffer, size_t size);
|
|
|
|
// from Stream
|
|
int available();
|
|
int read();
|
|
int peek();
|
|
void flush();
|
|
|
|
void onReceive(void(*callback)(uint8_t, int));
|
|
|
|
void receive(int size = 0);
|
|
void standby();
|
|
void sleep();
|
|
|
|
bool preInit();
|
|
uint8_t getTxPower();
|
|
void setTxPower(int level, int outputPin = PA_OUTPUT_PA_BOOST_PIN);
|
|
uint32_t getFrequency();
|
|
void setFrequency(uint32_t frequency);
|
|
void setSpreadingFactor(int sf);
|
|
uint8_t getSpreadingFactor();
|
|
uint32_t getSignalBandwidth();
|
|
void setSignalBandwidth(uint32_t sbw);
|
|
void setCodingRate4(int denominator);
|
|
uint8_t getCodingRate4();
|
|
void setPreambleLength(long length);
|
|
uint8_t modemStatus();
|
|
void enableCrc();
|
|
void disableCrc();
|
|
void enableTCXO();
|
|
void disableTCXO();
|
|
|
|
byte random();
|
|
|
|
void setSPIFrequency(uint32_t frequency);
|
|
|
|
void dumpRegisters(Stream& out);
|
|
|
|
void updateBitrate();
|
|
|
|
void handleDio0Rise();
|
|
|
|
void clearIRQStatus();
|
|
private:
|
|
void writeBuffer(const uint8_t* buffer, size_t size);
|
|
void readBuffer(uint8_t* buffer, size_t size);
|
|
void txAntEnable();
|
|
void rxAntEnable();
|
|
void loraMode();
|
|
void waitOnBusy();
|
|
void executeOpcode(uint8_t opcode, uint8_t *buffer, uint8_t size);
|
|
void executeOpcodeRead(uint8_t opcode, uint8_t *buffer, uint8_t size);
|
|
void setPacketParams(uint32_t preamble, uint8_t headermode, uint8_t length, uint8_t crc);
|
|
void setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr);
|
|
void setSyncWord(int sw);
|
|
void explicitHeaderMode();
|
|
void implicitHeaderMode();
|
|
|
|
|
|
uint8_t readRegister(uint16_t address);
|
|
void writeRegister(uint16_t address, uint8_t value);
|
|
uint8_t singleTransfer(uint8_t opcode, uint16_t address, uint8_t value);
|
|
|
|
static void onDio0Rise();
|
|
|
|
void handleLowDataRate();
|
|
void optimizeModemSensitivity();
|
|
|
|
private:
|
|
SPISettings _spiSettings;
|
|
SPIClass _spiModem;
|
|
int _ss;
|
|
int _sclk;
|
|
int _mosi;
|
|
int _miso;
|
|
int _reset;
|
|
int _dio0;
|
|
int _rxen;
|
|
int _txen;
|
|
int _busy;
|
|
int _modem;
|
|
uint32_t _frequency;
|
|
int _txp;
|
|
uint8_t _sf;
|
|
uint8_t _bw;
|
|
uint8_t _cr;
|
|
int _packetIndex;
|
|
int _implicitHeaderMode;
|
|
int _payloadLength;
|
|
int _crcMode;
|
|
int _fifo_tx_addr_ptr;
|
|
int _fifo_rx_addr_ptr;
|
|
bool _preinit_done;
|
|
int _rxPacketLength;
|
|
uint8_t _index;
|
|
bool _tcxo;
|
|
};
|
|
#endif
|