parent
832fe1d15c
commit
d15164cc5e
|
@ -19,21 +19,25 @@ PROGMEM static const BG_RF95::ModemConfig MODEM_CONFIG_TABLE[] =
|
|||
{
|
||||
// 1d, 1e, 26
|
||||
{ 0x72, 0x74, 0x00}, // Bw125Cr45Sf128 (the chip default)
|
||||
{ 0x92, 0x74, 0x00}, // Bw500Cr45Sf128
|
||||
{ 0x48, 0x94, 0x00}, // Bw31_25Cr48Sf512
|
||||
{ 0x78, 0xc4, 0x00}, // Bw125Cr48Sf4096
|
||||
{0x76, 0x94, 0x04}, // Bw125Cr47Sf512
|
||||
{0x72, 0xb4, 0x00}, // Bw125Cr45Sf2048
|
||||
{0x88, 0xc4, 0x00}, // Bw250Cr48Sf4096
|
||||
{ 0x72, 0xc7, 0x8}, // BG 125 cr45 sf12
|
||||
{ 0x72, 0xb4, 0x00}, // Bw125Cr45Sf2048 <= M0IGA messup speed
|
||||
{ 0x76, 0x94, 0x04}, // Bw125Cr47Sf512 <= corrected 1200baud
|
||||
};
|
||||
|
||||
BG_RF95::BG_RF95(uint8_t slaveSelectPin, uint8_t interruptPin, RHGenericSPI& spi)
|
||||
:
|
||||
RHSPIDriver(slaveSelectPin, spi),
|
||||
_rxBufValid(0) {
|
||||
_rxBufValid(0)
|
||||
{
|
||||
_interruptPin = interruptPin;
|
||||
_myInterruptIndex = 0xff; // Not allocated yet
|
||||
}
|
||||
|
||||
bool BG_RF95::init() {
|
||||
bool BG_RF95::init()
|
||||
{
|
||||
if (!RHSPIDriver::init())
|
||||
return false;
|
||||
//Serial.println("RHSPIDriver::init completed");
|
||||
|
@ -52,7 +56,8 @@ bool BG_RF95::init() {
|
|||
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_SLEEP | BG_RF95_LONG_RANGE_MODE);
|
||||
delay(10); // Wait for sleep mode to take over from say, CAD
|
||||
// Check we are in sleep mode, with LORA set
|
||||
if (spiRead(BG_RF95_REG_01_OP_MODE) != (BG_RF95_MODE_SLEEP | BG_RF95_LONG_RANGE_MODE)) {
|
||||
if (spiRead(BG_RF95_REG_01_OP_MODE) != (BG_RF95_MODE_SLEEP | BG_RF95_LONG_RANGE_MODE))
|
||||
{
|
||||
//Serial.println(spiRead(BG_RF95_REG_01_OP_MODE), HEX);
|
||||
return false; // No device present?
|
||||
}
|
||||
|
@ -68,7 +73,8 @@ bool BG_RF95::init() {
|
|||
// ON some devices, notably most Arduinos, the interrupt pin passed in is actuallt the
|
||||
// interrupt number. You have to figure out the interruptnumber-to-interruptpin mapping
|
||||
// yourself based on knwledge of what Arduino board you are running on.
|
||||
if (_myInterruptIndex == 0xff) {
|
||||
if (_myInterruptIndex == 0xff)
|
||||
{
|
||||
// First run, no interrupt allocated yet
|
||||
if (_interruptCount <= BG_RF95_NUM_INTERRUPTS)
|
||||
_myInterruptIndex = _interruptCount++;
|
||||
|
@ -82,7 +88,8 @@ bool BG_RF95::init() {
|
|||
attachInterrupt(interruptNumber, isr1, RISING);
|
||||
else if (_myInterruptIndex == 2)
|
||||
attachInterrupt(interruptNumber, isr2, RISING);
|
||||
else {
|
||||
else
|
||||
{
|
||||
//Serial.println("Interrupt vector too many vectors");
|
||||
return false; // Too many devices, not enough interrupt vectors
|
||||
}
|
||||
|
@ -107,9 +114,9 @@ bool BG_RF95::init() {
|
|||
// setModemConfig(Bw125Cr48Sf4096); // slow and reliable?
|
||||
setPreambleLength(8); // Default is 8
|
||||
// An innocuous ISM frequency, same as RF22's
|
||||
setFrequency(433.850);
|
||||
setFrequency(433.800);
|
||||
// Lowish power
|
||||
setTxPower(23);
|
||||
setTxPower(20);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
@ -119,13 +126,17 @@ bool BG_RF95::init() {
|
|||
// On MiniWirelessLoRa, only one of the several interrupt lines (DI0) from the RFM95 is usefuly
|
||||
// connnected to the processor.
|
||||
// We use this to get RxDone and TxDone interrupts
|
||||
void BG_RF95::handleInterrupt() {
|
||||
void BG_RF95::handleInterrupt()
|
||||
{
|
||||
// Read the interrupt register
|
||||
//Serial.println("HandleInterrupt");
|
||||
uint8_t irq_flags = spiRead(BG_RF95_REG_12_IRQ_FLAGS);
|
||||
if (_mode == RHModeRx && irq_flags & (BG_RF95_RX_TIMEOUT | BG_RF95_PAYLOAD_CRC_ERROR)) {
|
||||
if (_mode == RHModeRx && irq_flags & (BG_RF95_RX_TIMEOUT | BG_RF95_PAYLOAD_CRC_ERROR))
|
||||
{
|
||||
_rxBad++;
|
||||
} else if (_mode == RHModeRx && irq_flags & BG_RF95_RX_DONE) {
|
||||
}
|
||||
else if (_mode == RHModeRx && irq_flags & BG_RF95_RX_DONE)
|
||||
{
|
||||
// Have received a packet
|
||||
uint8_t len = spiRead(BG_RF95_REG_13_RX_NB_BYTES);
|
||||
|
||||
|
@ -146,7 +157,9 @@ void BG_RF95::handleInterrupt() {
|
|||
validateRxBuf();
|
||||
if (_rxBufValid)
|
||||
setModeIdle(); // Got one
|
||||
} else if (_mode == RHModeTx && irq_flags & BG_RF95_TX_DONE) {
|
||||
}
|
||||
else if (_mode == RHModeTx && irq_flags & BG_RF95_TX_DONE)
|
||||
{
|
||||
_txGood++;
|
||||
setModeIdle();
|
||||
}
|
||||
|
@ -157,23 +170,25 @@ void BG_RF95::handleInterrupt() {
|
|||
// These are low level functions that call the interrupt handler for the correct
|
||||
// instance of BG_RF95.
|
||||
// 3 interrupts allows us to have 3 different devices
|
||||
void BG_RF95::isr0() {
|
||||
void BG_RF95::isr0()
|
||||
{
|
||||
if (_deviceForInterrupt[0])
|
||||
_deviceForInterrupt[0]->handleInterrupt();
|
||||
}
|
||||
|
||||
void BG_RF95::isr1() {
|
||||
void BG_RF95::isr1()
|
||||
{
|
||||
if (_deviceForInterrupt[1])
|
||||
_deviceForInterrupt[1]->handleInterrupt();
|
||||
}
|
||||
|
||||
void BG_RF95::isr2() {
|
||||
void BG_RF95::isr2()
|
||||
{
|
||||
if (_deviceForInterrupt[2])
|
||||
_deviceForInterrupt[2]->handleInterrupt();
|
||||
}
|
||||
|
||||
// Check whether the latest received message is complete and uncorrupted
|
||||
void BG_RF95::validateRxBuf() {
|
||||
void BG_RF95::validateRxBuf()
|
||||
{
|
||||
_promiscuous = 1;
|
||||
if (_bufLen < 4)
|
||||
return; // Too short to be a real message
|
||||
|
@ -185,20 +200,23 @@ void BG_RF95::validateRxBuf() {
|
|||
_rxHeaderFlags = _buf[3];
|
||||
if (_promiscuous ||
|
||||
_rxHeaderTo == _thisAddress ||
|
||||
_rxHeaderTo == RH_BROADCAST_ADDRESS) {
|
||||
_rxHeaderTo == RH_BROADCAST_ADDRESS)
|
||||
{
|
||||
_rxGood++;
|
||||
_rxBufValid = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool BG_RF95::available() {
|
||||
bool BG_RF95::available()
|
||||
{
|
||||
if (_mode == RHModeTx)
|
||||
return false;
|
||||
setModeRx();
|
||||
return _rxBufValid; // Will be set by the interrupt handler when a good message is received
|
||||
}
|
||||
|
||||
void BG_RF95::clearRxBuf() {
|
||||
void BG_RF95::clearRxBuf()
|
||||
{
|
||||
ATOMIC_BLOCK_START;
|
||||
_rxBufValid = false;
|
||||
_bufLen = 0;
|
||||
|
@ -207,10 +225,12 @@ void BG_RF95::clearRxBuf() {
|
|||
|
||||
|
||||
// BG 3 Byte header
|
||||
bool BG_RF95::recvAPRS(uint8_t *buf, uint8_t *len) {
|
||||
bool BG_RF95::recvAPRS(uint8_t* buf, uint8_t* len)
|
||||
{
|
||||
if (!available())
|
||||
return false;
|
||||
if (buf && len) {
|
||||
if (buf && len)
|
||||
{
|
||||
ATOMIC_BLOCK_START;
|
||||
// Skip the 4 headers that are at the beginning of the rxBuf
|
||||
if (*len > _bufLen-BG_RF95_HEADER_LEN)
|
||||
|
@ -222,10 +242,12 @@ bool BG_RF95::recvAPRS(uint8_t *buf, uint8_t *len) {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool BG_RF95::recv(uint8_t *buf, uint8_t *len) {
|
||||
bool BG_RF95::recv(uint8_t* buf, uint8_t* len)
|
||||
{
|
||||
if (!available())
|
||||
return false;
|
||||
if (buf && len) {
|
||||
if (buf && len)
|
||||
{
|
||||
ATOMIC_BLOCK_START;
|
||||
// Skip the 4 headers that are at the beginning of the rxBuf
|
||||
if (*len > _bufLen-BG_RF95_HEADER_LEN)
|
||||
|
@ -237,12 +259,14 @@ bool BG_RF95::recv(uint8_t *buf, uint8_t *len) {
|
|||
return true;
|
||||
}
|
||||
|
||||
uint8_t BG_RF95::lastSNR() {
|
||||
uint8_t BG_RF95::lastSNR()
|
||||
{
|
||||
return(_lastSNR);
|
||||
}
|
||||
|
||||
|
||||
bool BG_RF95::send(const uint8_t *data, uint8_t len) {
|
||||
bool BG_RF95::send(const uint8_t* data, uint8_t len)
|
||||
{
|
||||
if (len > BG_RF95_MAX_MESSAGE_LEN)
|
||||
return false;
|
||||
|
||||
|
@ -265,7 +289,8 @@ bool BG_RF95::send(const uint8_t *data, uint8_t len) {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool BG_RF95::sendAPRS(const uint8_t *data, uint8_t len) {
|
||||
bool BG_RF95::sendAPRS(const uint8_t* data, uint8_t len)
|
||||
{
|
||||
if (len > BG_RF95_MAX_MESSAGE_LEN)
|
||||
return false;
|
||||
|
||||
|
@ -288,14 +313,14 @@ bool BG_RF95::sendAPRS(const uint8_t *data, uint8_t len) {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool BG_RF95::printRegisters() {
|
||||
bool BG_RF95::printRegisters()
|
||||
{
|
||||
#ifdef RH_HAVE_SERIAL
|
||||
uint8_t registers[] = {0x01, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
|
||||
0x014, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22,
|
||||
0x23, 0x24, 0x25, 0x26, 0x27, 0x4d};
|
||||
uint8_t registers[] = { 0x01, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x014, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x4d };
|
||||
|
||||
uint8_t i;
|
||||
for (i = 0; i < sizeof(registers); i++) {
|
||||
for (i = 0; i < sizeof(registers); i++)
|
||||
{
|
||||
Serial.print(registers[i], HEX);
|
||||
Serial.print(": ");
|
||||
Serial.println(spiRead(registers[i]), HEX);
|
||||
|
@ -304,11 +329,13 @@ bool BG_RF95::printRegisters() {
|
|||
return true;
|
||||
}
|
||||
|
||||
uint8_t BG_RF95::maxMessageLength() {
|
||||
uint8_t BG_RF95::maxMessageLength()
|
||||
{
|
||||
return BG_RF95_MAX_MESSAGE_LEN;
|
||||
}
|
||||
|
||||
bool BG_RF95::setFrequency(float centre) {
|
||||
bool BG_RF95::setFrequency(float centre)
|
||||
{
|
||||
// Frf = FRF / FSTEP
|
||||
uint32_t frf = (centre * 1000000.0) / BG_RF95_FSTEP;
|
||||
spiWrite(BG_RF95_REG_06_FRF_MSB, (frf >> 16) & 0xff);
|
||||
|
@ -318,24 +345,30 @@ bool BG_RF95::setFrequency(float centre) {
|
|||
return true;
|
||||
}
|
||||
|
||||
void BG_RF95::setModeIdle() {
|
||||
if (_mode != RHModeIdle) {
|
||||
void BG_RF95::setModeIdle()
|
||||
{
|
||||
if (_mode != RHModeIdle)
|
||||
{
|
||||
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_STDBY);
|
||||
_mode = RHModeIdle;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool BG_RF95::sleep() {
|
||||
if (_mode != RHModeSleep) {
|
||||
bool BG_RF95::sleep()
|
||||
{
|
||||
if (_mode != RHModeSleep)
|
||||
{
|
||||
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_SLEEP);
|
||||
_mode = RHModeSleep;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void BG_RF95::setModeRx() {
|
||||
if (_mode != RHModeRx) {
|
||||
void BG_RF95::setModeRx()
|
||||
{
|
||||
if (_mode != RHModeRx)
|
||||
{
|
||||
//Serial.println("SetModeRx");
|
||||
_mode = RHModeRx;
|
||||
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_RXCONTINUOUS);
|
||||
|
@ -343,19 +376,23 @@ void BG_RF95::setModeRx() {
|
|||
}
|
||||
}
|
||||
|
||||
void BG_RF95::setModeTx() {
|
||||
if (_mode != RHModeTx) {
|
||||
void BG_RF95::setModeTx()
|
||||
{
|
||||
if (_mode != RHModeTx)
|
||||
{
|
||||
_mode = RHModeTx; // set first to avoid possible race condition
|
||||
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_TX);
|
||||
spiWrite(BG_RF95_REG_40_DIO_MAPPING1, 0x40); // Interrupt on TxDone
|
||||
}
|
||||
}
|
||||
|
||||
void BG_RF95::setTxPower(int8_t power, bool useRFO) {
|
||||
void BG_RF95::setTxPower(int8_t power, bool useRFO)
|
||||
{
|
||||
// Sigh, different behaviours depending on whther the module use PA_BOOST or the RFO pin
|
||||
// for the transmitter output
|
||||
if (useRFO) {
|
||||
if (power > 19) power = 19;
|
||||
if (useRFO)
|
||||
{
|
||||
if (power > 14) power = 14;
|
||||
if (power < -1) power = -1;
|
||||
spiWrite(BG_RF95_REG_09_PA_CONFIG, BG_RF95_MAX_POWER | (power + 1));
|
||||
} else {
|
||||
|
@ -370,7 +407,7 @@ void BG_RF95::setTxPower(int8_t power, bool useRFO) {
|
|||
spiWrite(BG_RF95_REG_0B_OCP, ( BG_RF95_OCP_ON | BG_RF95_OCP_TRIM ) ); // Trim max current tp 240mA
|
||||
spiWrite(BG_RF95_REG_4D_PA_DAC, BG_RF95_PA_DAC_ENABLE);
|
||||
//power -= 3;
|
||||
power = 23; // and set PA_DAC_ENABLE
|
||||
power = 20; // and set PA_DAC_ENABLE
|
||||
|
||||
} else {
|
||||
spiWrite(BG_RF95_REG_4D_PA_DAC, BG_RF95_PA_DAC_DISABLE);
|
||||
|
@ -389,7 +426,8 @@ void BG_RF95::setTxPower(int8_t power, bool useRFO) {
|
|||
}
|
||||
|
||||
// Sets registers from a canned modem configuration structure
|
||||
void BG_RF95::setModemRegisters(const ModemConfig *config) {
|
||||
void BG_RF95::setModemRegisters(const ModemConfig* config)
|
||||
{
|
||||
spiWrite(BG_RF95_REG_1D_MODEM_CONFIG1, config->reg_1d);
|
||||
spiWrite(BG_RF95_REG_1E_MODEM_CONFIG2, config->reg_1e);
|
||||
spiWrite(BG_RF95_REG_26_MODEM_CONFIG3, config->reg_26);
|
||||
|
@ -397,7 +435,8 @@ void BG_RF95::setModemRegisters(const ModemConfig *config) {
|
|||
|
||||
// Set one of the canned FSK Modem configs
|
||||
// Returns true if its a valid choice
|
||||
bool BG_RF95::setModemConfig(ModemConfigChoice index) {
|
||||
bool BG_RF95::setModemConfig(ModemConfigChoice index)
|
||||
{
|
||||
if (index > (signed int)(sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig)))
|
||||
return false;
|
||||
|
||||
|
@ -408,7 +447,8 @@ bool BG_RF95::setModemConfig(ModemConfigChoice index) {
|
|||
return true;
|
||||
}
|
||||
|
||||
void BG_RF95::setPreambleLength(uint16_t bytes) {
|
||||
void BG_RF95::setPreambleLength(uint16_t bytes)
|
||||
{
|
||||
spiWrite(BG_RF95_REG_20_PREAMBLE_MSB, bytes >> 8);
|
||||
spiWrite(BG_RF95_REG_21_PREAMBLE_LSB, bytes & 0xff);
|
||||
}
|
||||
|
|
|
@ -183,15 +183,15 @@
|
|||
|
||||
// BG_RF95_REG_1D_MODEM_CONFIG1 0x1d
|
||||
#define BG_RF95_BW 0xc0
|
||||
#define BG_RF95_BW_125KHZ 0x70
|
||||
#define BG_RF95_BW_250KHZ 0x80
|
||||
#define BG_RF95_BW_500KHZ 0x90
|
||||
#define BG_RF95_BW_125KHZ 0x00
|
||||
#define BG_RF95_BW_250KHZ 0x40
|
||||
#define BG_RF95_BW_500KHZ 0x80
|
||||
#define BG_RF95_BW_RESERVED 0xc0
|
||||
#define BG_RF95_CODING_RATE 0x38
|
||||
#define BG_RF95_CODING_RATE_4_5 0x02
|
||||
#define BG_RF95_CODING_RATE_4_6 0x04
|
||||
#define BG_RF95_CODING_RATE_4_7 0x06
|
||||
#define BG_RF95_CODING_RATE_4_8 0x08
|
||||
#define BG_RF95_CODING_RATE_4_5 0x00
|
||||
#define BG_RF95_CODING_RATE_4_6 0x08
|
||||
#define BG_RF95_CODING_RATE_4_7 0x10
|
||||
#define BG_RF95_CODING_RATE_4_8 0x18
|
||||
#define BG_RF95_IMPLICIT_HEADER_MODE_ON 0x04
|
||||
#define BG_RF95_RX_PAYLOAD_CRC_ON 0x02
|
||||
#define BG_RF95_LOW_DATA_RATE_OPTIMIZE 0x01
|
||||
|
@ -461,7 +461,7 @@
|
|||
/// -1 to +14 (for modules that use RFO transmitter pin)
|
||||
/// The default is 13. Eg:
|
||||
/// \code
|
||||
/// driver.setTxPower(23); // use PA_BOOST transmitter pin
|
||||
/// driver.setTxPower(10); // use PA_BOOST transmitter pin
|
||||
/// driver.setTxPower(10, true); // use PA_RFO pin transmitter pin
|
||||
/// \endcode
|
||||
///
|
||||
|
@ -543,11 +543,12 @@ public:
|
|||
typedef enum
|
||||
{
|
||||
Bw125Cr45Sf128 = 0, ///< Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Default medium range
|
||||
Bw500Cr45Sf128, ///< Bw = 500 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Fast+short range
|
||||
Bw31_25Cr48Sf512, ///< Bw = 31.25 kHz, Cr = 4/8, Sf = 512chips/symbol, CRC on. Slow+long range
|
||||
Bw125Cr48Sf4096, ///< Bw = 125 kHz, Cr = 4/8, Sf = 4096chips/symbol, CRC on. Slow+long range
|
||||
Bw125Cr45Sf4096, ///< APRS
|
||||
Bw125Cr47Sf512, /// 1200 bps
|
||||
Bw125Cr45Sf2048, ///<Bw = 125 kHz Cr = 4/5, Sf= 2048 chips/symbol, CRC on.
|
||||
Bw250Cr48Sf4096, ///< Bw = 250 kHz, Cr = 4/8, Sf = 4096chips/symbol, CRC on.
|
||||
Bw125Cr45Sf2048, ///< M0IGA Messup speed / 698baud (not 1200)
|
||||
Bw125Cr47Sf512, ///< corrected 1200 baud
|
||||
} ModemConfigChoice;
|
||||
|
||||
/// Constructor. You can have multiple instances, but each instance must have its own
|
||||
|
|
|
@ -707,12 +707,12 @@ void setup(){
|
|||
#endif
|
||||
batt_read();
|
||||
writedisplaytext("LoRa-APRS","","Init:","ADC OK!","BAT: "+String(BattVolts,1),"");
|
||||
rf95.setFrequency(433.775);
|
||||
#ifdef SPEED_1200
|
||||
rf95.setModemConfig(BG_RF95::Bw125Cr47Sf512);
|
||||
#else
|
||||
rf95.setModemConfig(BG_RF95::Bw125Cr45Sf4096);
|
||||
#endif
|
||||
rf95.setFrequency(433.775);
|
||||
rf95.setTxPower(txPower);
|
||||
delay(250);
|
||||
#ifdef KISS_PROTOCOL
|
||||
|
|
Loading…
Reference in New Issue