US1GHQ
/
TTGO-T-Beam-LoRa-APRS
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Reformated code

Browse Source
master_sq9mdd
Łukasz Nidecki 2 years ago
parent d9ae7f0fd0
commit 29d151b1e9
1 changed files with 320 additions and 358 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 678
      lib/BG_RF95/BG_RF95.cpp

678
lib/BG_RF95/BG_RF95.cpp
Unescape View File

@ -10,113 +10,108 @@ byte _lastSNR = 0;
// Interrupt vectors for the 3 Arduino interrupt pins
// Each interrupt can be handled by a different instance of BG_RF95, allowing you to have
// 2 or more LORAs per Arduino
BG_RF95* BG_RF95::_deviceForInterrupt[BG_RF95_NUM_INTERRUPTS] = {0, 0, 0};
BG_RF95 *BG_RF95::_deviceForInterrupt[BG_RF95_NUM_INTERRUPTS] = {0, 0, 0};
uint8_t BG_RF95::_interruptCount = 0; // Index into _deviceForInterrupt for next device
// These are indexed by the values of ModemConfigChoice
// Stored in flash (program) memory to save SRAM
PROGMEM static const BG_RF95::ModemConfig MODEM_CONFIG_TABLE[] =
{
// 1d, 1e, 26
{ 0x72, 0x74, 0x00}, // Bw125Cr45Sf128 (the chip default)
{ 0x78, 0xc4, 0x00}, // Bw125Cr48Sf4096
{ 0x76, 0x94, 0x04}, // Bw125Cr47Sf512
{ 0x72, 0xb4, 0x00}, // Bw125Cr45Sf2048
{ 0x88, 0xc4, 0x00}, // Bw250Cr48Sf4096
};
BG_RF95::BG_RF95(uint8_t slaveSelectPin, uint8_t interruptPin, RHGenericSPI& spi)
:
RHSPIDriver(slaveSelectPin, spi),
_rxBufValid(0)
{
_interruptPin = interruptPin;
_myInterruptIndex = 0xff; // Not allocated yet
{
// 1d, 1e, 26
{0x72, 0x74, 0x00}, // Bw125Cr45Sf128 (the chip default)
{0x78, 0xc4, 0x00}, // Bw125Cr48Sf4096
{0x76, 0x94, 0x04}, // Bw125Cr47Sf512
{0x72, 0xb4, 0x00}, // Bw125Cr45Sf2048
{0x88, 0xc4, 0x00}, // Bw250Cr48Sf4096
};
BG_RF95::BG_RF95(uint8_t slaveSelectPin, uint8_t interruptPin, RHGenericSPI &spi)
:
RHSPIDriver(slaveSelectPin, spi),
_rxBufValid(0) {
_interruptPin = interruptPin;
_myInterruptIndex = 0xff; // Not allocated yet
}
bool BG_RF95::init()
{
if (!RHSPIDriver::init())
return false;
//Serial.println("RHSPIDriver::init completed");
// Determine the interrupt number that corresponds to the interruptPin
int interruptNumber = digitalPinToInterrupt(_interruptPin);
if (interruptNumber == NOT_AN_INTERRUPT)
return false;
bool BG_RF95::init() {
if (!RHSPIDriver::init())
return false;
//Serial.println("RHSPIDriver::init completed");
// Determine the interrupt number that corresponds to the interruptPin
int interruptNumber = digitalPinToInterrupt(_interruptPin);
if (interruptNumber == NOT_AN_INTERRUPT)
return false;
#ifdef RH_ATTACHINTERRUPT_TAKES_PIN_NUMBER
interruptNumber = _interruptPin;
interruptNumber = _interruptPin;
#endif
//Serial.println("Attach Interrupt completed");
// No way to check the device type :-(
// Set sleep mode, so we can also set LORA mode:
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))
{
//Serial.println(spiRead(BG_RF95_REG_01_OP_MODE), HEX);
return false; // No device present?
}
// Add by Adrien van den Bossche <vandenbo@univ-tlse2.fr> for Teensy
// ARM M4 requires the below. else pin interrupt doesn't work properly.
// On all other platforms, its innocuous, belt and braces
pinMode(_interruptPin, INPUT);
// Set up interrupt handler
// Since there are a limited number of interrupt glue functions isr*() available,
// we can only support a limited number of devices simultaneously
// 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)
{
// First run, no interrupt allocated yet
if (_interruptCount <= BG_RF95_NUM_INTERRUPTS)
_myInterruptIndex = _interruptCount++;
else
return false; // Too many devices, not enough interrupt vectors
}
_deviceForInterrupt[_myInterruptIndex] = this;
if (_myInterruptIndex == 0)
attachInterrupt(interruptNumber, isr0, RISING);
else if (_myInterruptIndex == 1)
attachInterrupt(interruptNumber, isr1, RISING);
else if (_myInterruptIndex == 2)
attachInterrupt(interruptNumber, isr2, RISING);
//Serial.println("Attach Interrupt completed");
// No way to check the device type :-(
// Set sleep mode, so we can also set LORA mode:
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)) {
//Serial.println(spiRead(BG_RF95_REG_01_OP_MODE), HEX);
return false; // No device present?
}
// Add by Adrien van den Bossche <vandenbo@univ-tlse2.fr> for Teensy
// ARM M4 requires the below. else pin interrupt doesn't work properly.
// On all other platforms, its innocuous, belt and braces
pinMode(_interruptPin, INPUT);
// Set up interrupt handler
// Since there are a limited number of interrupt glue functions isr*() available,
// we can only support a limited number of devices simultaneously
// 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) {
// First run, no interrupt allocated yet
if (_interruptCount <= BG_RF95_NUM_INTERRUPTS)
_myInterruptIndex = _interruptCount++;
else
{
//Serial.println("Interrupt vector too many vectors");
return false; // Too many devices, not enough interrupt vectors
}
// Set up FIFO
// We configure so that we can use the entire 256 byte FIFO for either receive
// or transmit, but not both at the same time
spiWrite(BG_RF95_REG_0E_FIFO_TX_BASE_ADDR, 0);
spiWrite(BG_RF95_REG_0F_FIFO_RX_BASE_ADDR, 0);
// Packet format is preamble + explicit-header + payload + crc
// Explicit Header Mode
// payload is TO + FROM + ID + FLAGS + message data
// RX mode is implmented with RXCONTINUOUS
// max message data length is 255 - 4 = 251 octets
setModeIdle();
// Set up default configuration
// No Sync Words in LORA mode.
setModemConfig(Bw125Cr45Sf128); // Radio default
return false; // Too many devices, not enough interrupt vectors
}
_deviceForInterrupt[_myInterruptIndex] = this;
if (_myInterruptIndex == 0)
attachInterrupt(interruptNumber, isr0, RISING);
else if (_myInterruptIndex == 1)
attachInterrupt(interruptNumber, isr1, RISING);
else if (_myInterruptIndex == 2)
attachInterrupt(interruptNumber, isr2, RISING);
else {
//Serial.println("Interrupt vector too many vectors");
return false; // Too many devices, not enough interrupt vectors
}
// Set up FIFO
// We configure so that we can use the entire 256 byte FIFO for either receive
// or transmit, but not both at the same time
spiWrite(BG_RF95_REG_0E_FIFO_TX_BASE_ADDR, 0);
spiWrite(BG_RF95_REG_0F_FIFO_RX_BASE_ADDR, 0);
// Packet format is preamble + explicit-header + payload + crc
// Explicit Header Mode
// payload is TO + FROM + ID + FLAGS + message data
// RX mode is implmented with RXCONTINUOUS
// max message data length is 255 - 4 = 251 octets
setModeIdle();
// Set up default configuration
// No Sync Words in LORA mode.
setModemConfig(Bw125Cr45Sf128); // Radio default
// setModemConfig(Bw125Cr48Sf4096); // slow and reliable?
setPreambleLength(8); // Default is 8
// An innocuous ISM frequency, same as RF22's
setFrequency(433.850);
// Lowish power
setTxPower(23);
setPreambleLength(8); // Default is 8
// An innocuous ISM frequency, same as RF22's
setFrequency(433.850);
// Lowish power
setTxPower(23);
return true;
return true;
}
// C++ level interrupt handler for this instance
@ -124,329 +119,296 @@ 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()
{
// 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))
{
_rxBad++;
}
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);
// Reset the fifo read ptr to the beginning of the packet
spiWrite(BG_RF95_REG_0D_FIFO_ADDR_PTR, spiRead(BG_RF95_REG_10_FIFO_RX_CURRENT_ADDR));
spiBurstRead(BG_RF95_REG_00_FIFO, _buf, len);
_bufLen = len;
spiWrite(BG_RF95_REG_12_IRQ_FLAGS, 0xff); // Clear all IRQ flags
// Remember the RSSI of this packet
// this is according to the doc, but is it really correct?
// weakest receiveable signals are reported RSSI at about -66
_lastRssi = spiRead(BG_RF95_REG_1A_PKT_RSSI_VALUE) - 137;
_lastSNR = spiRead(BG_RF95_REG_19_PKT_SNR_VALUE);
// We have received a message.
validateRxBuf();
if (_rxBufValid)
setModeIdle(); // Got one
}
else if (_mode == RHModeTx && irq_flags & BG_RF95_TX_DONE)
{
_txGood++;
setModeIdle();
}
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)) {
_rxBad++;
} 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);
// Reset the fifo read ptr to the beginning of the packet
spiWrite(BG_RF95_REG_0D_FIFO_ADDR_PTR, spiRead(BG_RF95_REG_10_FIFO_RX_CURRENT_ADDR));
spiBurstRead(BG_RF95_REG_00_FIFO, _buf, len);
_bufLen = len;
spiWrite(BG_RF95_REG_12_IRQ_FLAGS, 0xff); // Clear all IRQ flags
// Remember the RSSI of this packet
// this is according to the doc, but is it really correct?
// weakest receiveable signals are reported RSSI at about -66
_lastRssi = spiRead(BG_RF95_REG_1A_PKT_RSSI_VALUE) - 137;
_lastSNR = spiRead(BG_RF95_REG_19_PKT_SNR_VALUE);
// We have received a message.
validateRxBuf();
if (_rxBufValid)
setModeIdle(); // Got one
} else if (_mode == RHModeTx && irq_flags & BG_RF95_TX_DONE) {
_txGood++;
setModeIdle();
}
spiWrite(BG_RF95_REG_12_IRQ_FLAGS, 0xff); // Clear all IRQ flags
}
// 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()
{
if (_deviceForInterrupt[0])
_deviceForInterrupt[0]->handleInterrupt();
void BG_RF95::isr0() {
if (_deviceForInterrupt[0])
_deviceForInterrupt[0]->handleInterrupt();
}
void BG_RF95::isr1()
{
if (_deviceForInterrupt[1])
_deviceForInterrupt[1]->handleInterrupt();
void BG_RF95::isr1() {
if (_deviceForInterrupt[1])
_deviceForInterrupt[1]->handleInterrupt();
}
void BG_RF95::isr2()
{
if (_deviceForInterrupt[2])
_deviceForInterrupt[2]->handleInterrupt();
void BG_RF95::isr2() {
if (_deviceForInterrupt[2])
_deviceForInterrupt[2]->handleInterrupt();
}
// Check whether the latest received message is complete and uncorrupted
void BG_RF95::validateRxBuf()
{
_promiscuous = 1;
if (_bufLen < 4)
return; // Too short to be a real message
// Extract the 4 headers
//Serial.println("validateRxBuf >= 4");
_rxHeaderTo = _buf[0];
_rxHeaderFrom = _buf[1];
_rxHeaderId = _buf[2];
_rxHeaderFlags = _buf[3];
if (_promiscuous ||
_rxHeaderTo == _thisAddress ||
_rxHeaderTo == RH_BROADCAST_ADDRESS)
{
_rxGood++;
_rxBufValid = true;
}
void BG_RF95::validateRxBuf() {
_promiscuous = 1;
if (_bufLen < 4)
return; // Too short to be a real message
// Extract the 4 headers
//Serial.println("validateRxBuf >= 4");
_rxHeaderTo = _buf[0];
_rxHeaderFrom = _buf[1];
_rxHeaderId = _buf[2];
_rxHeaderFlags = _buf[3];
if (_promiscuous ||
_rxHeaderTo == _thisAddress ||
_rxHeaderTo == RH_BROADCAST_ADDRESS) {
_rxGood++;
_rxBufValid = true;
}
}
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
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()
{
ATOMIC_BLOCK_START;
_rxBufValid = false;
_bufLen = 0;
ATOMIC_BLOCK_END;
void BG_RF95::clearRxBuf() {
ATOMIC_BLOCK_START;
_rxBufValid = false;
_bufLen = 0;
ATOMIC_BLOCK_END;
}
// BG 3 Byte header
bool BG_RF95::recvAPRS(uint8_t* buf, uint8_t* len)
{
if (!available())
return false;
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)
*len = _bufLen-(BG_RF95_HEADER_LEN-1);
memcpy(buf, _buf+(BG_RF95_HEADER_LEN-1), *len); // BG only 3 Byte header (-1)
ATOMIC_BLOCK_END;
}
clearRxBuf(); // This message accepted and cleared
return true;
bool BG_RF95::recvAPRS(uint8_t *buf, uint8_t *len) {
if (!available())
return false;
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)
*len = _bufLen - (BG_RF95_HEADER_LEN - 1);
memcpy(buf, _buf + (BG_RF95_HEADER_LEN - 1), *len); // BG only 3 Byte header (-1)
ATOMIC_BLOCK_END;
}
clearRxBuf(); // This message accepted and cleared
return true;
}
bool BG_RF95::recv(uint8_t* buf, uint8_t* len)
{
if (!available())
return false;
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)
*len = _bufLen-BG_RF95_HEADER_LEN;
memcpy(buf, _buf+BG_RF95_HEADER_LEN, *len);
ATOMIC_BLOCK_END;
}
clearRxBuf(); // This message accepted and cleared
return true;
bool BG_RF95::recv(uint8_t *buf, uint8_t *len) {
if (!available())
return false;
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)
*len = _bufLen - BG_RF95_HEADER_LEN;
memcpy(buf, _buf + BG_RF95_HEADER_LEN, *len);
ATOMIC_BLOCK_END;
}
clearRxBuf(); // This message accepted and cleared
return true;
}
uint8_t BG_RF95::lastSNR()
{
return(_lastSNR);
uint8_t BG_RF95::lastSNR() {
return (_lastSNR);
}
bool BG_RF95::send(const uint8_t* data, uint8_t len)
{
if (len > BG_RF95_MAX_MESSAGE_LEN)
return false;
bool BG_RF95::send(const uint8_t *data, uint8_t len) {
if (len > BG_RF95_MAX_MESSAGE_LEN)
return false;
waitPacketSent(); // Make sure we dont interrupt an outgoing message
setModeIdle();
// Position at the beginning of the FIFO
spiWrite(BG_RF95_REG_0D_FIFO_ADDR_PTR, 0);
// The headers
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderTo);
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFrom);
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderId);
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFlags);
// The message data
spiBurstWrite(BG_RF95_REG_00_FIFO, data, len);
spiWrite(BG_RF95_REG_22_PAYLOAD_LENGTH, len + BG_RF95_HEADER_LEN);
setModeTx(); // Start the transmitter
// when Tx is done, interruptHandler will fire and radio mode will return to STANDBY
return true;
}
waitPacketSent(); // Make sure we dont interrupt an outgoing message
setModeIdle();
bool BG_RF95::sendAPRS(const uint8_t* data, uint8_t len)
{
if (len > BG_RF95_MAX_MESSAGE_LEN)
return false;
// Position at the beginning of the FIFO
spiWrite(BG_RF95_REG_0D_FIFO_ADDR_PTR, 0);
// The headers
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderTo);
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFrom);
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderId);
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFlags);
// The message data
spiBurstWrite(BG_RF95_REG_00_FIFO, data, len);
spiWrite(BG_RF95_REG_22_PAYLOAD_LENGTH, len + BG_RF95_HEADER_LEN);
waitPacketSent(); // Make sure we dont interrupt an outgoing message
setModeIdle();
setModeTx(); // Start the transmitter
// when Tx is done, interruptHandler will fire and radio mode will return to STANDBY
return true;
}
// Position at the beginning of the FIFO
spiWrite(BG_RF95_REG_0D_FIFO_ADDR_PTR, 0);
// The headers for APRS
spiWrite(BG_RF95_REG_00_FIFO, '<');
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFrom);
spiWrite(BG_RF95_REG_00_FIFO, 0x1 );
//spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFlags);
// The message data
spiBurstWrite(BG_RF95_REG_00_FIFO, data, len);
spiWrite(BG_RF95_REG_22_PAYLOAD_LENGTH, len + BG_RF95_HEADER_LEN -1 ); // only 3 Byte header BG
setModeTx(); // Start the transmitter
// when Tx is done, interruptHandler will fire and radio mode will return to STANDBY
return true;
bool BG_RF95::sendAPRS(const uint8_t *data, uint8_t len) {
if (len > BG_RF95_MAX_MESSAGE_LEN)
return false;
waitPacketSent(); // Make sure we dont interrupt an outgoing message
setModeIdle();
// Position at the beginning of the FIFO
spiWrite(BG_RF95_REG_0D_FIFO_ADDR_PTR, 0);
// The headers for APRS
spiWrite(BG_RF95_REG_00_FIFO, '<');
spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFrom);
spiWrite(BG_RF95_REG_00_FIFO, 0x1);
//spiWrite(BG_RF95_REG_00_FIFO, _txHeaderFlags);
// The message data
spiBurstWrite(BG_RF95_REG_00_FIFO, data, len);
spiWrite(BG_RF95_REG_22_PAYLOAD_LENGTH, len + BG_RF95_HEADER_LEN - 1); // only 3 Byte header BG
setModeTx(); // Start the transmitter
// when Tx is done, interruptHandler will fire and radio mode will return to STANDBY
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 i;
for (i = 0; i < sizeof(registers); i++)
{
Serial.print(registers[i], HEX);
Serial.print(": ");
Serial.println(spiRead(registers[i]), HEX);
}
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++) {
Serial.print(registers[i], HEX);
Serial.print(": ");
Serial.println(spiRead(registers[i]), HEX);
}
#endif
return true;
return true;
}
uint8_t BG_RF95::maxMessageLength()
{
return BG_RF95_MAX_MESSAGE_LEN;
uint8_t BG_RF95::maxMessageLength() {
return BG_RF95_MAX_MESSAGE_LEN;
}
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);
spiWrite(BG_RF95_REG_07_FRF_MID, (frf >> 8) & 0xff);
spiWrite(BG_RF95_REG_08_FRF_LSB, frf & 0xff);
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);
spiWrite(BG_RF95_REG_07_FRF_MID, (frf >> 8) & 0xff);
spiWrite(BG_RF95_REG_08_FRF_LSB, frf & 0xff);
return true;
return true;
}
void BG_RF95::setModeIdle()
{
if (_mode != RHModeIdle)
{
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_STDBY);
_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)
{
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_SLEEP);
_mode = RHModeSleep;
}
return true;
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)
{
//Serial.println("SetModeRx");
_mode = RHModeRx;
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_RXCONTINUOUS);
spiWrite(BG_RF95_REG_40_DIO_MAPPING1, 0x00); // Interrupt on RxDone
}
void BG_RF95::setModeRx() {
if (_mode != RHModeRx) {
//Serial.println("SetModeRx");
_mode = RHModeRx;
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_RXCONTINUOUS);
spiWrite(BG_RF95_REG_40_DIO_MAPPING1, 0x00); // Interrupt on RxDone
}
}
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
}
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)
{
// 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 (power < -1) power = -1;
spiWrite(BG_RF95_REG_09_PA_CONFIG, BG_RF95_MAX_POWER | (power + 1));
} else {
if (power > 23) power = 23;
if (power < 5) power = 5;
// For BG_RF95_PA_DAC_ENABLE, manual says '+20dBm on PA_BOOST when OutputPower=0xf'
// BG_RF95_PA_DAC_ENABLE actually adds about 3dBm to all power levels. We will us it
// for 21, 22 and 23dBm -= 3;
}
if (power > 20) {
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
} else {
spiWrite(BG_RF95_REG_4D_PA_DAC, BG_RF95_PA_DAC_DISABLE);
}
// RFM95/96/97/98 does not have RFO pins connected to anything. Only PA_BOOST
// pin is connected, so must use PA_BOOST
// Pout = 2 + OutputPower.
// The documentation is pretty confusing on this topic: PaSelect says the max power is 20dBm,
// but OutputPower claims it would be 17dBm.
// My measurements show 20dBm is correct
//spiWrite(BG_RF95_REG_09_PA_CONFIG, (BG_RF95_PA_SELECT | (power-5)) );
spiWrite(BG_RF95_REG_09_PA_CONFIG, (BG_RF95_PA_SELECT | BG_RF95_MAX_POWER | (power-5)) );
//}
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 (power < -1) power = -1;
spiWrite(BG_RF95_REG_09_PA_CONFIG, BG_RF95_MAX_POWER | (power + 1));
} else {
if (power > 23) power = 23;
if (power < 5) power = 5;
// For BG_RF95_PA_DAC_ENABLE, manual says '+20dBm on PA_BOOST when OutputPower=0xf'
// BG_RF95_PA_DAC_ENABLE actually adds about 3dBm to all power levels. We will us it
// for 21, 22 and 23dBm -= 3;
}
if (power > 20) {
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
} else {
spiWrite(BG_RF95_REG_4D_PA_DAC, BG_RF95_PA_DAC_DISABLE);
}
// RFM95/96/97/98 does not have RFO pins connected to anything. Only PA_BOOST
// pin is connected, so must use PA_BOOST
// Pout = 2 + OutputPower.
// The documentation is pretty confusing on this topic: PaSelect says the max power is 20dBm,
// but OutputPower claims it would be 17dBm.
// My measurements show 20dBm is correct
//spiWrite(BG_RF95_REG_09_PA_CONFIG, (BG_RF95_PA_SELECT | (power-5)) );
spiWrite(BG_RF95_REG_09_PA_CONFIG, (BG_RF95_PA_SELECT | BG_RF95_MAX_POWER | (power - 5)));
//}
}
// Sets registers from a canned modem configuration structure
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);
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);
}
// Set one of the canned FSK Modem configs
// Returns true if its a valid choice
bool BG_RF95::setModemConfig(ModemConfigChoice index)
{
if (index > (signed int)(sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig)))
return false;
bool BG_RF95::setModemConfig(ModemConfigChoice index) {
if (index > (signed int) (sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig)))
return false;
ModemConfig cfg;
memcpy_P(&cfg, &MODEM_CONFIG_TABLE[index], sizeof(BG_RF95::ModemConfig));
setModemRegisters(&cfg);
ModemConfig cfg;
memcpy_P(&cfg, &MODEM_CONFIG_TABLE[index], sizeof(BG_RF95::ModemConfig));
setModemRegisters(&cfg);
return true;
return true;
}
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);
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);
}

Write Preview
Loading…
Cancel
Save