ua1zbe
/
TTGO-T-Beam-LoRa-APRS
mirror of https://github.com/SQ9MDD/TTGO-T-Beam-LoRa-APRS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reformated code

This commit is contained in:
Łukasz Nidecki 2021-06-11 00:29:07 +02:00
parent d9ae7f0fd0
commit 29d151b1e9
1 changed files with 301 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
lib/BG_RF95/BG_RF95.cpp
View File

@ -28,14 +28,12 @@ PROGMEM static const BG_RF95::ModemConfig MODEM_CONFIG_TABLE[] =
BG_RF95::BG_RF95(uint8_t slaveSelectPin, uint8_t interruptPin, RHGenericSPI &spi) BG_RF95::BG_RF95(uint8_t slaveSelectPin, uint8_t interruptPin, RHGenericSPI &spi)
: :
RHSPIDriver(slaveSelectPin, spi), RHSPIDriver(slaveSelectPin, spi),
_rxBufValid(0) _rxBufValid(0) {
{
_interruptPin = interruptPin; _interruptPin = interruptPin;
_myInterruptIndex = 0xff; // Not allocated yet _myInterruptIndex = 0xff; // Not allocated yet
} }
bool BG_RF95::init() bool BG_RF95::init() {
{
if (!RHSPIDriver::init()) if (!RHSPIDriver::init())
return false; return false;
//Serial.println("RHSPIDriver::init completed"); //Serial.println("RHSPIDriver::init completed");
@ -54,8 +52,7 @@ bool BG_RF95::init()
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_SLEEP | BG_RF95_LONG_RANGE_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 delay(10); // Wait for sleep mode to take over from say, CAD
// Check we are in sleep mode, with LORA set // 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); //Serial.println(spiRead(BG_RF95_REG_01_OP_MODE), HEX);
return false; // No device present? return false; // No device present?
} }
@ -71,8 +68,7 @@ bool BG_RF95::init()
// ON some devices, notably most Arduinos, the interrupt pin passed in is actuallt the // 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 // interrupt number. You have to figure out the interruptnumber-to-interruptpin mapping
// yourself based on knwledge of what Arduino board you are running on. // yourself based on knwledge of what Arduino board you are running on.
if (_myInterruptIndex == 0xff) if (_myInterruptIndex == 0xff) {
{
// First run, no interrupt allocated yet // First run, no interrupt allocated yet
if (_interruptCount <= BG_RF95_NUM_INTERRUPTS) if (_interruptCount <= BG_RF95_NUM_INTERRUPTS)
_myInterruptIndex = _interruptCount++; _myInterruptIndex = _interruptCount++;
@ -86,8 +82,7 @@ bool BG_RF95::init()
attachInterrupt(interruptNumber, isr1, RISING); attachInterrupt(interruptNumber, isr1, RISING);
else if (_myInterruptIndex == 2) else if (_myInterruptIndex == 2)
attachInterrupt(interruptNumber, isr2, RISING); attachInterrupt(interruptNumber, isr2, RISING);
else else {
{
//Serial.println("Interrupt vector too many vectors"); //Serial.println("Interrupt vector too many vectors");
return false; // Too many devices, not enough interrupt vectors return false; // Too many devices, not enough interrupt vectors
} }
@ -124,17 +119,13 @@ bool BG_RF95::init()
// On MiniWirelessLoRa, only one of the several interrupt lines (DI0) from the RFM95 is usefuly // On MiniWirelessLoRa, only one of the several interrupt lines (DI0) from the RFM95 is usefuly
// connnected to the processor. // connnected to the processor.
// We use this to get RxDone and TxDone interrupts // We use this to get RxDone and TxDone interrupts
void BG_RF95::handleInterrupt() void BG_RF95::handleInterrupt() {
{
// Read the interrupt register // Read the interrupt register
//Serial.println("HandleInterrupt"); //Serial.println("HandleInterrupt");
uint8_t irq_flags = spiRead(BG_RF95_REG_12_IRQ_FLAGS); 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++; _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 // Have received a packet
uint8_t len = spiRead(BG_RF95_REG_13_RX_NB_BYTES); uint8_t len = spiRead(BG_RF95_REG_13_RX_NB_BYTES);
@ -155,9 +146,7 @@ void BG_RF95::handleInterrupt()
validateRxBuf(); validateRxBuf();
if (_rxBufValid) if (_rxBufValid)
setModeIdle(); // Got one setModeIdle(); // Got one
} } else if (_mode == RHModeTx && irq_flags & BG_RF95_TX_DONE) {
else if (_mode == RHModeTx && irq_flags & BG_RF95_TX_DONE)
{
_txGood++; _txGood++;
setModeIdle(); setModeIdle();
} }
@ -168,25 +157,23 @@ void BG_RF95::handleInterrupt()
// These are low level functions that call the interrupt handler for the correct // These are low level functions that call the interrupt handler for the correct
// instance of BG_RF95. // instance of BG_RF95.
// 3 interrupts allows us to have 3 different devices // 3 interrupts allows us to have 3 different devices
void BG_RF95::isr0() void BG_RF95::isr0() {
{
if (_deviceForInterrupt[0]) if (_deviceForInterrupt[0])
_deviceForInterrupt[0]->handleInterrupt(); _deviceForInterrupt[0]->handleInterrupt();
} }
void BG_RF95::isr1()
{ void BG_RF95::isr1() {
if (_deviceForInterrupt[1]) if (_deviceForInterrupt[1])
_deviceForInterrupt[1]->handleInterrupt(); _deviceForInterrupt[1]->handleInterrupt();
} }
void BG_RF95::isr2()
{ void BG_RF95::isr2() {
if (_deviceForInterrupt[2]) if (_deviceForInterrupt[2])
_deviceForInterrupt[2]->handleInterrupt(); _deviceForInterrupt[2]->handleInterrupt();
} }
// Check whether the latest received message is complete and uncorrupted // Check whether the latest received message is complete and uncorrupted
void BG_RF95::validateRxBuf() void BG_RF95::validateRxBuf() {
{
_promiscuous = 1; _promiscuous = 1;
if (_bufLen < 4) if (_bufLen < 4)
return; // Too short to be a real message return; // Too short to be a real message
@ -198,23 +185,20 @@ void BG_RF95::validateRxBuf()
_rxHeaderFlags = _buf[3]; _rxHeaderFlags = _buf[3];
if (_promiscuous || if (_promiscuous ||
_rxHeaderTo == _thisAddress || _rxHeaderTo == _thisAddress ||
_rxHeaderTo == RH_BROADCAST_ADDRESS) _rxHeaderTo == RH_BROADCAST_ADDRESS) {
{
_rxGood++; _rxGood++;
_rxBufValid = true; _rxBufValid = true;
} }
} }
bool BG_RF95::available() bool BG_RF95::available() {
{
if (_mode == RHModeTx) if (_mode == RHModeTx)
return false; return false;
setModeRx(); setModeRx();
return _rxBufValid; // Will be set by the interrupt handler when a good message is received 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; ATOMIC_BLOCK_START;
_rxBufValid = false; _rxBufValid = false;
_bufLen = 0; _bufLen = 0;
@ -223,12 +207,10 @@ void BG_RF95::clearRxBuf()
// BG 3 Byte header // 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()) if (!available())
return false; return false;
if (buf && len) if (buf && len) {
{
ATOMIC_BLOCK_START; ATOMIC_BLOCK_START;
// Skip the 4 headers that are at the beginning of the rxBuf // Skip the 4 headers that are at the beginning of the rxBuf
if (*len > _bufLen - BG_RF95_HEADER_LEN) if (*len > _bufLen - BG_RF95_HEADER_LEN)
@ -240,12 +222,10 @@ bool BG_RF95::recvAPRS(uint8_t* buf, uint8_t* len)
return true; return true;
} }
bool BG_RF95::recv(uint8_t* buf, uint8_t* len) bool BG_RF95::recv(uint8_t *buf, uint8_t *len) {
{
if (!available()) if (!available())
return false; return false;
if (buf && len) if (buf && len) {
{
ATOMIC_BLOCK_START; ATOMIC_BLOCK_START;
// Skip the 4 headers that are at the beginning of the rxBuf // Skip the 4 headers that are at the beginning of the rxBuf
if (*len > _bufLen - BG_RF95_HEADER_LEN) if (*len > _bufLen - BG_RF95_HEADER_LEN)
@ -257,14 +237,12 @@ bool BG_RF95::recv(uint8_t* buf, uint8_t* len)
return true; return true;
} }
uint8_t BG_RF95::lastSNR() uint8_t BG_RF95::lastSNR() {
{
return (_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) if (len > BG_RF95_MAX_MESSAGE_LEN)
return false; return false;
@ -287,8 +265,7 @@ bool BG_RF95::send(const uint8_t* data, uint8_t len)
return true; 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) if (len > BG_RF95_MAX_MESSAGE_LEN)
return false; return false;
@ -311,14 +288,14 @@ bool BG_RF95::sendAPRS(const uint8_t* data, uint8_t len)
return true; return true;
} }
bool BG_RF95::printRegisters() bool BG_RF95::printRegisters() {
{
#ifdef RH_HAVE_SERIAL #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; uint8_t i;
for (i = 0; i < sizeof(registers); i++) for (i = 0; i < sizeof(registers); i++) {
{
Serial.print(registers[i], HEX); Serial.print(registers[i], HEX);
Serial.print(": "); Serial.print(": ");
Serial.println(spiRead(registers[i]), HEX); Serial.println(spiRead(registers[i]), HEX);
@ -327,13 +304,11 @@ bool BG_RF95::printRegisters()
return true; return true;
} }
uint8_t BG_RF95::maxMessageLength() uint8_t BG_RF95::maxMessageLength() {
{
return BG_RF95_MAX_MESSAGE_LEN; return BG_RF95_MAX_MESSAGE_LEN;
} }
bool BG_RF95::setFrequency(float centre) bool BG_RF95::setFrequency(float centre) {
{
// Frf = FRF / FSTEP // Frf = FRF / FSTEP
uint32_t frf = (centre * 1000000.0) / BG_RF95_FSTEP; uint32_t frf = (centre * 1000000.0) / BG_RF95_FSTEP;
spiWrite(BG_RF95_REG_06_FRF_MSB, (frf >> 16) & 0xff); spiWrite(BG_RF95_REG_06_FRF_MSB, (frf >> 16) & 0xff);
@ -343,30 +318,24 @@ bool BG_RF95::setFrequency(float centre)
return true; return true;
} }
void BG_RF95::setModeIdle() void BG_RF95::setModeIdle() {
{ if (_mode != RHModeIdle) {
if (_mode != RHModeIdle)
{
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_STDBY); spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_STDBY);
_mode = RHModeIdle; _mode = RHModeIdle;
} }
} }
bool BG_RF95::sleep() bool BG_RF95::sleep() {
{ if (_mode != RHModeSleep) {
if (_mode != RHModeSleep)
{
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_SLEEP); spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_SLEEP);
_mode = RHModeSleep; _mode = RHModeSleep;
} }
return true; return true;
} }
void BG_RF95::setModeRx() void BG_RF95::setModeRx() {
{ if (_mode != RHModeRx) {
if (_mode != RHModeRx)
{
//Serial.println("SetModeRx"); //Serial.println("SetModeRx");
_mode = RHModeRx; _mode = RHModeRx;
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_RXCONTINUOUS); spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_RXCONTINUOUS);
@ -374,22 +343,18 @@ void BG_RF95::setModeRx()
} }
} }
void BG_RF95::setModeTx() void BG_RF95::setModeTx() {
{ if (_mode != RHModeTx) {
if (_mode != RHModeTx)
{
_mode = RHModeTx; // set first to avoid possible race condition _mode = RHModeTx; // set first to avoid possible race condition
spiWrite(BG_RF95_REG_01_OP_MODE, BG_RF95_MODE_TX); 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_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 // Sigh, different behaviours depending on whther the module use PA_BOOST or the RFO pin
// for the transmitter output // for the transmitter output
if (useRFO) if (useRFO) {
{
if (power > 19) power = 19; if (power > 19) power = 19;
if (power < -1) power = -1; if (power < -1) power = -1;
spiWrite(BG_RF95_REG_09_PA_CONFIG, BG_RF95_MAX_POWER | (power + 1)); spiWrite(BG_RF95_REG_09_PA_CONFIG, BG_RF95_MAX_POWER | (power + 1));
@ -424,8 +389,7 @@ void BG_RF95::setTxPower(int8_t power, bool useRFO)
} }
// Sets registers from a canned modem configuration structure // 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_1D_MODEM_CONFIG1, config->reg_1d);
spiWrite(BG_RF95_REG_1E_MODEM_CONFIG2, config->reg_1e); spiWrite(BG_RF95_REG_1E_MODEM_CONFIG2, config->reg_1e);
spiWrite(BG_RF95_REG_26_MODEM_CONFIG3, config->reg_26); spiWrite(BG_RF95_REG_26_MODEM_CONFIG3, config->reg_26);
@ -433,8 +397,7 @@ void BG_RF95::setModemRegisters(const ModemConfig* config)
// Set one of the canned FSK Modem configs // Set one of the canned FSK Modem configs
// Returns true if its a valid choice // 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))) if (index > (signed int) (sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig)))
return false; return false;
@ -445,8 +408,7 @@ bool BG_RF95::setModemConfig(ModemConfigChoice index)
return true; 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_20_PREAMBLE_MSB, bytes >> 8);
spiWrite(BG_RF95_REG_21_PREAMBLE_LSB, bytes & 0xff); spiWrite(BG_RF95_REG_21_PREAMBLE_LSB, bytes & 0xff);
} }