iotmanager/IoTManager
1
0
Fork 0
mirror of https://github.com/IoTManagerProject/IoTManager.git synced 2026-03-30 20:09:14 +03:00
Code Issues Packages Projects Releases Wiki Activity

удаляем библиотеку

Browse Source
This commit is contained in:
Dmitry Borisenko
2022-12-01 01:27:54 +01:00
parent 9436af94df
commit 2c61580157
295 changed files with 3 additions and 67232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
lib/MySensors/hal/transport/RFM95/MyTransportRFM95.cpp
View File

@@ -1,126 +0,0 @@
/*
* The MySensors Arduino library handles the wireless radio link and protocol
* between your home built sensors/actuators and HA controller of choice.
* The sensors forms a self healing radio network with optional repeaters. Each
* repeater and gateway builds a routing tables in EEPROM which keeps track of the
* network topology allowing messages to be routed to nodes.
*
* Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
* Copyright (C) 2013-2019 Sensnology AB
* Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
*
* Documentation: http://www.mysensors.org
* Support Forum: http://forum.mysensors.org
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 as published by the Free Software Foundation.
*/
#include "hal/transport/RFM95/driver/RFM95.h"
bool transportInit(void)
{
const bool result = RFM95_initialise(MY_RFM95_FREQUENCY);
#if defined(MY_RFM95_TCXO)
RFM95_enableTCXO();
#endif
#if !defined(MY_GATEWAY_FEATURE) && !defined(MY_RFM95_ATC_MODE_DISABLED)
// only enable ATC mode in nodes
RFM95_ATCmode(true, MY_RFM95_ATC_TARGET_RSSI);
#endif
return result;
}
void transportSetAddress(const uint8_t address)
{
RFM95_setAddress(address);
}
uint8_t transportGetAddress(void)
{
return RFM95_getAddress();
}
bool transportSend(const uint8_t to, const void *data, const uint8_t len, const bool noACK)
{
return RFM95_sendWithRetry(to, data, len, noACK);
}
bool transportDataAvailable(void)
{
RFM95_handler();
return RFM95_available();
}
bool transportSanityCheck(void)
{
return RFM95_sanityCheck();
}
uint8_t transportReceive(void *data)
{
uint8_t len = RFM95_receive((uint8_t *)data, MAX_MESSAGE_SIZE);
return len;
}
void transportSleep(void)
{
(void)RFM95_sleep();
}
void transportStandBy(void)
{
(void)RFM95_standBy();
}
void transportPowerDown(void)
{
RFM95_powerDown();
}
void transportPowerUp(void)
{
RFM95_powerUp();
}
void transportToggleATCmode(const bool OnOff, const int16_t targetRSSI)
{
RFM95_ATCmode(OnOff, targetRSSI);
}
int16_t transportGetSendingRSSI(void)
{
return RFM95_getSendingRSSI();
}
int16_t transportGetReceivingRSSI(void)
{
return RFM95_getReceivingRSSI();
}
int16_t transportGetSendingSNR(void)
{
return RFM95_getSendingSNR();
}
int16_t transportGetReceivingSNR(void)
{
return RFM95_getReceivingSNR();
}
int16_t transportGetTxPowerPercent(void)
{
return RFM95_getTxPowerPercent();
}
int16_t transportGetTxPowerLevel(void)
{
return RFM95_getTxPowerLevel();
}
bool transportSetTxPowerPercent(const uint8_t powerPercent)
{
return RFM95_setTxPowerPercent(powerPercent);
}

685
lib/MySensors/hal/transport/RFM95/driver/RFM95.cpp
View File

@@ -1,685 +0,0 @@
/*
* The MySensors Arduino library handles the wireless radio link and protocol
* between your home built sensors/actuators and HA controller of choice.
* The sensors forms a self healing radio network with optional repeaters. Each
* repeater and gateway builds a routing tables in EEPROM which keeps track of the
* network topology allowing messages to be routed to nodes.
*
* Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
* Copyright (C) 2013-2019 Sensnology AB
* Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
*
* Documentation: http://www.mysensors.org
* Support Forum: http://forum.mysensors.org
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 as published by the Free Software Foundation.
*
* Based on Mike McCauley's RFM95 library, Copyright (C) 2014 Mike McCauley <mikem@airspayce.com>
* Radiohead http://www.airspayce.com/mikem/arduino/RadioHead/index.html
*
* RFM95 driver refactored and optimized for MySensors, Copyright (C) 2017-2018 Olivier Mauti <olivier@mysensors.org>
*
* Definitions for HopeRF LoRa radios:
* http://www.hoperf.com/upload/rf/RFM95_96_97_98W.pdf
*
*/
#include "RFM95.h"
// debug
#if defined(MY_DEBUG_VERBOSE_RFM95)
#define RFM95_DEBUG(x,...) DEBUG_OUTPUT(x, ##__VA_ARGS__) //!< Debug print
#else
#define RFM95_DEBUG(x,...) //!< DEBUG null
#endif
rfm95_internal_t RFM95; //!< internal variables
volatile uint8_t RFM95_irq; //<! rfm95 irq flag
#if defined(__linux__)
// SPI RX and TX buffers (max packet len + 1 byte for the command)
uint8_t RFM95_spi_rxbuff[RFM95_MAX_PACKET_LEN + 1];
uint8_t RFM95_spi_txbuff[RFM95_MAX_PACKET_LEN + 1];
#endif
LOCAL void RFM95_csn(const bool level)
{
#if defined(__linux__)
(void)level;
#else
hwDigitalWrite(MY_RFM95_CS_PIN, level);
#endif
}
LOCAL uint8_t RFM95_spiMultiByteTransfer(const uint8_t cmd, uint8_t *buf, uint8_t len,
const bool aReadMode)
{
uint8_t status;
uint8_t *current = buf;
#if !defined(MY_SOFTSPI) && defined(SPI_HAS_TRANSACTION)
RFM95_SPI.beginTransaction(SPISettings(MY_RFM95_SPI_SPEED, RFM95_SPI_DATA_ORDER,
RFM95_SPI_DATA_MODE));
#endif
RFM95_csn(LOW);
#if defined(__linux__)
uint8_t *prx = RFM95_spi_rxbuff;
uint8_t *ptx = RFM95_spi_txbuff;
uint8_t size = len + 1; // Add register value to transmit buffer
*ptx++ = cmd;
while (len--) {
if (aReadMode) {
*ptx++ = (uint8_t)RFM95_NOP;
} else {
*ptx++ = *current++;
}
}
RFM95_SPI.transfernb((char *)RFM95_spi_txbuff, (char *)RFM95_spi_rxbuff, size);
if (aReadMode) {
if (size == 2) {
status = *++prx; // result is 2nd byte of receive buffer
} else {
status = *prx++; // status is 1st byte of receive buffer
// decrement before to skip status byte
while (--size && (buf != NULL)) {
*buf++ = *prx++;
}
}
} else {
status = *prx; // status is 1st byte of receive buffer
}
#else
status = RFM95_SPI.transfer(cmd);
while (len--) {
if (aReadMode) {
status = RFM95_SPI.transfer((uint8_t)RFM95_NOP);
if (buf != NULL) {
*current++ = status;
}
} else {
status = RFM95_SPI.transfer(*current++);
}
}
#endif
RFM95_csn(HIGH);
#if !defined(MY_SOFTSPI) && defined(SPI_HAS_TRANSACTION)
RFM95_SPI.endTransaction();
#endif
return status;
}
// low level register access
LOCAL uint8_t RFM95_RAW_readByteRegister(const uint8_t address)
{
return RFM95_spiMultiByteTransfer(address, NULL, 1, true);
}
// low level register access
LOCAL uint8_t RFM95_RAW_writeByteRegister(const uint8_t address, uint8_t value)
{
return RFM95_spiMultiByteTransfer(address, &value, 1, false);
}
// helper functions
LOCAL inline uint8_t RFM95_readReg(const uint8_t reg)
{
return RFM95_RAW_readByteRegister(reg & RFM95_READ_REGISTER);
}
LOCAL inline uint8_t RFM95_writeReg(const uint8_t reg, const uint8_t value)
{
return RFM95_RAW_writeByteRegister(reg | RFM95_WRITE_REGISTER, value);
}
LOCAL inline uint8_t RFM95_burstReadReg(const uint8_t reg, void *buf, uint8_t len)
{
return RFM95_spiMultiByteTransfer(reg & RFM95_READ_REGISTER, (uint8_t *)buf, len, true);
}
LOCAL inline uint8_t RFM95_burstWriteReg(const uint8_t reg, const void *buf, uint8_t len)
{
return RFM95_spiMultiByteTransfer(reg | RFM95_WRITE_REGISTER, (uint8_t *)buf, len, false);
}
LOCAL inline rfm95_RSSI_t RFM95_RSSItoInternal(const int16_t externalRSSI)
{
return static_cast<rfm95_RSSI_t>(externalRSSI + RFM95_RSSI_OFFSET);
}
LOCAL inline int16_t RFM95_internalToRSSI(const rfm95_RSSI_t internalRSSI)
{
return static_cast<int16_t>(internalRSSI - RFM95_RSSI_OFFSET);
}
LOCAL bool RFM95_initialise(const uint32_t frequencyHz)
{
RFM95_DEBUG(PSTR("RFM95:INIT\n"));
// power pin, if defined
#if defined(MY_RFM95_POWER_PIN)
hwPinMode(MY_RFM95_POWER_PIN, OUTPUT);
#endif
RFM95_powerUp();
// reset radio module if rst pin defined
#if defined(MY_RFM95_RST_PIN)
hwPinMode(MY_RFM95_RST_PIN, OUTPUT);
hwDigitalWrite(MY_RFM95_RST_PIN, LOW);
// 100uS
delayMicroseconds(RFM95_POWERUP_DELAY_MS);
hwDigitalWrite(MY_RFM95_RST_PIN, HIGH);
// wait until chip ready
delay(5);
RFM95_DEBUG(PSTR("RFM95:INIT:PIN,CS=%" PRIu8 ",IQP=%" PRIu8 ",IQN=%" PRIu8 ",RST=%" PRIu8 "\n"),
MY_RFM95_CS_PIN, MY_RFM95_IRQ_PIN,
MY_RFM95_IRQ_NUM,MY_RFM95_RST_PIN);
#else
RFM95_DEBUG(PSTR("RFM95:INIT:PIN,CS=%" PRIu8 ",IQP=%" PRIu8 ",IQN=%" PRIu8 "\n"), MY_RFM95_CS_PIN,
MY_RFM95_IRQ_PIN,
MY_RFM95_IRQ_NUM);
#endif
// set variables
RFM95.address = RFM95_BROADCAST_ADDRESS;
RFM95.ackReceived = false;
RFM95.dataReceived = false;
RFM95.txSequenceNumber = 0; // initialise TX sequence counter
RFM95.powerLevel = 0;
RFM95.ATCenabled = false;
RFM95.ATCtargetRSSI = RFM95_RSSItoInternal(RFM95_TARGET_RSSI);
// SPI init
#if !defined(__linux__)
hwDigitalWrite(MY_RFM95_CS_PIN, HIGH);
hwPinMode(MY_RFM95_CS_PIN, OUTPUT);
#endif
RFM95_SPI.begin();
// Set LoRa mode (during sleep mode)
(void)RFM95_writeReg(RFM95_REG_01_OP_MODE, RFM95_MODE_SLEEP | RFM95_LONG_RANGE_MODE);
delay(10); // Wait for sleep mode to take over
// TCXO init, if present
#if defined(MY_RFM95_TCXO)
RFM95_enableTCXO();
#else
(void)RFM95_enableTCXO;
#endif
// Set up FIFO, 256 bytes: LoRa max message 64 bytes, set half RX half TX (default)
(void)RFM95_writeReg(RFM95_REG_0F_FIFO_RX_BASE_ADDR, RFM95_RX_FIFO_ADDR);
(void)RFM95_writeReg(RFM95_REG_0E_FIFO_TX_BASE_ADDR, RFM95_TX_FIFO_ADDR);
(void)RFM95_writeReg(RFM95_REG_23_MAX_PAYLOAD_LENGTH, RFM95_MAX_PACKET_LEN);
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_STDBY);
const rfm95_modemConfig_t configuration = { MY_RFM95_MODEM_CONFIGRUATION };
RFM95_setModemRegisters(&configuration);
RFM95_setPreambleLength(RFM95_PREAMBLE_LENGTH);
RFM95_setFrequency(frequencyHz);
(void)RFM95_setTxPowerLevel(MY_RFM95_TX_POWER_DBM);
if (!RFM95_sanityCheck()) {
// sanity check failed, check wiring or replace module
RFM95_DEBUG(PSTR("!RFM95:INIT:SANCHK FAIL\n"));
return false;
}
// IRQ
RFM95_irq = false;
hwPinMode(MY_RFM95_IRQ_PIN, INPUT);
attachInterrupt(MY_RFM95_IRQ_NUM, RFM95_interruptHandler, RISING);
return true;
}
LOCAL void IRQ_HANDLER_ATTR RFM95_interruptHandler(void)
{
// set flag
RFM95_irq = true;
}
// RxDone, TxDone, CADDone is mapped to DI0
LOCAL void RFM95_interruptHandling(void)
{
// read interrupt register
const uint8_t irqFlags = RFM95_readReg(RFM95_REG_12_IRQ_FLAGS);
if (RFM95.radioMode == RFM95_RADIO_MODE_RX && (irqFlags & RFM95_RX_DONE)) {
// RXSingle mode: Radio goes automatically to STDBY after packet received
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_STDBY);
// Check CRC flag
if (!(irqFlags & RFM95_PAYLOAD_CRC_ERROR)) {
const uint8_t bufLen = min(RFM95_readReg(RFM95_REG_13_RX_NB_BYTES), (uint8_t)RFM95_MAX_PACKET_LEN);
if (bufLen >= RFM95_HEADER_LEN) {
// Reset the fifo read ptr to the beginning of the packet
(void)RFM95_writeReg(RFM95_REG_0D_FIFO_ADDR_PTR, RFM95_readReg(RFM95_REG_10_FIFO_RX_CURRENT_ADDR));
(void)RFM95_burstReadReg(RFM95_REG_00_FIFO, RFM95.currentPacket.data, bufLen);
RFM95.currentPacket.RSSI = static_cast<rfm95_RSSI_t>(RFM95_readReg(
RFM95_REG_1A_PKT_RSSI_VALUE)); // RSSI of latest packet received
RFM95.currentPacket.SNR = static_cast<rfm95_SNR_t>(RFM95_readReg(RFM95_REG_19_PKT_SNR_VALUE));
RFM95.currentPacket.payloadLen = bufLen - RFM95_HEADER_LEN;
if ((RFM95.currentPacket.header.version >= RFM95_MIN_PACKET_HEADER_VERSION) &&
(RFM95_PROMISCUOUS || RFM95.currentPacket.header.recipient == RFM95.address ||
RFM95.currentPacket.header.recipient == RFM95_BROADCAST_ADDRESS)) {
// Message for us
RFM95.ackReceived = RFM95_getACKReceived(RFM95.currentPacket.header.controlFlags) &&
!RFM95_getACKRequested(RFM95.currentPacket.header.controlFlags);
RFM95.dataReceived = !RFM95.ackReceived;
}
}
} else {
// CRC error
RFM95_DEBUG(PSTR("!RFM95:IRH:CRC ERROR\n"));
// FIFO is cleared when switch from STDBY to RX or TX
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_RX);
}
} else if (RFM95.radioMode == RFM95_RADIO_MODE_TX && (irqFlags & RFM95_TX_DONE) ) {
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_RX);
} else if (RFM95.radioMode == RFM95_RADIO_MODE_CAD && (irqFlags & RFM95_CAD_DONE) ) {
RFM95.channelActive = irqFlags & RFM95_CAD_DETECTED;
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_STDBY);
}
// Clear IRQ flags
RFM95_writeReg(RFM95_REG_12_IRQ_FLAGS, RFM95_CLEAR_IRQ);
}
LOCAL void RFM95_handler(void)
{
if (RFM95_irq) {
RFM95_irq = false;
RFM95_interruptHandling();
}
}
LOCAL bool RFM95_available(void)
{
if (RFM95.dataReceived) {
// data received - we are still in STDBY from IRQ handler
return true;
} else if (RFM95.radioMode == RFM95_RADIO_MODE_TX) {
return false;
} else if (RFM95.radioMode != RFM95_RADIO_MODE_RX) {
// we are not in RX, not CAD, and no data received
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_RX);
}
return false;
}
LOCAL uint8_t RFM95_receive(uint8_t *buf, const uint8_t maxBufSize)
{
const uint8_t payloadLen = min(RFM95.currentPacket.payloadLen, maxBufSize);
const uint8_t sender = RFM95.currentPacket.header.sender;
const rfm95_sequenceNumber_t sequenceNumber = RFM95.currentPacket.header.sequenceNumber;
const rfm95_controlFlags_t controlFlags = RFM95.currentPacket.header.controlFlags;
const rfm95_RSSI_t RSSI = RFM95.currentPacket.RSSI;
const rfm95_SNR_t SNR = RFM95.currentPacket.SNR;
if (buf != NULL) {
(void)memcpy((void *)buf, (void *)&RFM95.currentPacket.payload, payloadLen);
}
// clear data flag
RFM95.dataReceived = false;
// ACK handling
if (RFM95_getACKRequested(controlFlags) && !RFM95_getACKReceived(controlFlags)) {
#if defined(MY_GATEWAY_FEATURE) && (F_CPU>16*1000000ul)
// delay for fast GW and slow nodes
delay(50);
#endif
RFM95_sendACK(sender, sequenceNumber, RSSI, SNR);
}
return payloadLen;
}
LOCAL bool RFM95_sendFrame(rfm95_packet_t *packet, const bool increaseSequenceCounter)
{
// Check channel activity
if (!RFM95_waitCAD()) {
return false;
}
// radio is in STDBY
if (increaseSequenceCounter) {
// increase sequence counter, overflow is ok
RFM95.txSequenceNumber++;
}
packet->header.sequenceNumber = RFM95.txSequenceNumber;
// Position at the beginning of the TX FIFO
(void)RFM95_writeReg(RFM95_REG_0D_FIFO_ADDR_PTR, RFM95_TX_FIFO_ADDR);
// write packet
const uint8_t finalLen = packet->payloadLen + RFM95_HEADER_LEN;
(void)RFM95_burstWriteReg(RFM95_REG_00_FIFO, packet->data, finalLen);
// total payload length
(void)RFM95_writeReg(RFM95_REG_22_PAYLOAD_LENGTH, finalLen);
// send message, if sent, irq fires and radio returns to standby
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_TX);
// wait until IRQ fires or timeout
const uint32_t startTX_MS = hwMillis();
// todo: make this payload length + bit rate dependend
while (!RFM95_irq && (hwMillis() - startTX_MS < MY_RFM95_TX_TIMEOUT_MS) ) {
doYield();
}
return RFM95_irq;
}
LOCAL bool RFM95_send(const uint8_t recipient, uint8_t *data, const uint8_t len,
const rfm95_controlFlags_t flags, const bool increaseSequenceCounter)
{
rfm95_packet_t packet;
packet.header.version = RFM95_PACKET_HEADER_VERSION;
packet.header.sender = RFM95.address;
packet.header.recipient = recipient;
packet.payloadLen = min(len, (uint8_t)RFM95_MAX_PAYLOAD_LEN);
packet.header.controlFlags = flags;
(void)memcpy((void *)&packet.payload, (void *)data, packet.payloadLen);
return RFM95_sendFrame(&packet, increaseSequenceCounter);
}
LOCAL void RFM95_setFrequency(const uint32_t frequencyHz)
{
const uint32_t freqReg = (uint32_t)(frequencyHz / RFM95_FSTEP);
(void)RFM95_writeReg(RFM95_REG_06_FRF_MSB, (uint8_t)((freqReg >> 16) & 0xff));
(void)RFM95_writeReg(RFM95_REG_07_FRF_MID, (uint8_t)((freqReg >> 8) & 0xff));
(void)RFM95_writeReg(RFM95_REG_08_FRF_LSB, (uint8_t)(freqReg & 0xff));
}
LOCAL bool RFM95_setTxPowerLevel(rfm95_powerLevel_t newPowerLevel)
{
// RFM95/96/97/98 does not have RFO pins connected to anything. Only PA_BOOST
newPowerLevel = max((int8_t)RFM95_MIN_POWER_LEVEL_DBM, newPowerLevel);
newPowerLevel = min((int8_t)RFM95_MAX_POWER_LEVEL_DBM, newPowerLevel);
if (newPowerLevel != RFM95.powerLevel) {
RFM95.powerLevel = newPowerLevel;
uint8_t val;
if (newPowerLevel > 20) {
// enable DAC, adds 3dBm
// The documentation is pretty confusing on this topic: PaSelect says the max power is 20dBm,
// but OutputPower claims it would be 17dBm. Measurements show 20dBm is correct
(void)RFM95_writeReg(RFM95_REG_4D_PA_DAC, RFM95_PA_DAC_ENABLE);
val = newPowerLevel - 8;
} else {
(void)RFM95_writeReg(RFM95_REG_4D_PA_DAC, RFM95_PA_DAC_DISABLE);
val = newPowerLevel - 5;
}
(void)RFM95_writeReg(RFM95_REG_09_PA_CONFIG, RFM95_PA_SELECT | val);
RFM95_DEBUG(PSTR("RFM95:PTX:LEVEL=%" PRIi8 "\n"), newPowerLevel);
return true;
}
return false;
}
LOCAL void RFM95_enableTCXO(void)
{
while ((RFM95_readReg(RFM95_REG_4B_TCXO) & RFM95_TCXO_TCXO_INPUT_ON) != RFM95_TCXO_TCXO_INPUT_ON) {
(void)RFM95_writeReg(RFM95_REG_4B_TCXO,
(RFM95_readReg(RFM95_REG_4B_TCXO) | RFM95_TCXO_TCXO_INPUT_ON));
}
}
// Sets registers from a canned modem configuration structure
LOCAL void RFM95_setModemRegisters(const rfm95_modemConfig_t *config)
{
(void)RFM95_writeReg(RFM95_REG_1D_MODEM_CONFIG1, config->reg_1d);
(void)RFM95_writeReg(RFM95_REG_1E_MODEM_CONFIG2, config->reg_1e);
(void)RFM95_writeReg(RFM95_REG_26_MODEM_CONFIG3, config->reg_26);
}
LOCAL void RFM95_setPreambleLength(const uint16_t preambleLength)
{
(void)RFM95_writeReg(RFM95_REG_20_PREAMBLE_MSB, (uint8_t)((preambleLength >> 8) & 0xff));
(void)RFM95_writeReg(RFM95_REG_21_PREAMBLE_LSB, (uint8_t)(preambleLength & 0xff));
}
LOCAL void RFM95_setAddress(const uint8_t addr)
{
RFM95.address = addr;
}
LOCAL uint8_t RFM95_getAddress(void)
{
return RFM95.address;
}
LOCAL bool RFM95_setRadioMode(const rfm95_radioMode_t newRadioMode)
{
if (RFM95.radioMode == newRadioMode) {
return false;
}
uint8_t regMode;
if (newRadioMode == RFM95_RADIO_MODE_STDBY) {
regMode = RFM95_MODE_STDBY;
} else if (newRadioMode == RFM95_RADIO_MODE_SLEEP) {
regMode = RFM95_MODE_SLEEP;
} else if (newRadioMode == RFM95_RADIO_MODE_CAD) {
regMode = RFM95_MODE_CAD;
(void)RFM95_writeReg(RFM95_REG_40_DIO_MAPPING1, 0x80); // Interrupt on CadDone, DIO0
} else if (newRadioMode == RFM95_RADIO_MODE_RX) {
RFM95.dataReceived = false;
RFM95.ackReceived = false;
regMode = RFM95_MODE_RXCONTINUOUS;
(void)RFM95_writeReg(RFM95_REG_40_DIO_MAPPING1, 0x00); // Interrupt on RxDone, DIO0
(void)RFM95_writeReg(RFM95_REG_0D_FIFO_ADDR_PTR,
RFM95_RX_FIFO_ADDR); // set FIFO ptr to beginning of RX FIFO address
} else if (newRadioMode == RFM95_RADIO_MODE_TX) {
regMode = RFM95_MODE_TX;
(void)RFM95_writeReg(RFM95_REG_40_DIO_MAPPING1, 0x40); // Interrupt on TxDone, DIO0
} else {
return false;
}
(void)RFM95_writeReg(RFM95_REG_01_OP_MODE, regMode);
RFM95.radioMode = newRadioMode;
return true;
}
LOCAL void RFM95_powerUp(void)
{
#if defined(MY_RFM95_POWER_PIN)
RFM95_DEBUG(PSTR("RFM95:PWU\n")); // power up radio
hwDigitalWrite(MY_RFM95_POWER_PIN, HIGH);
delay(RFM95_POWERUP_DELAY_MS);
#endif
}
LOCAL void RFM95_powerDown(void)
{
#if defined(MY_RFM95_POWER_PIN)
RFM95_DEBUG(PSTR("RFM95:PWD\n")); // power down radio
hwDigitalWrite(MY_RFM95_POWER_PIN, LOW);
#endif
}
LOCAL bool RFM95_sleep(void)
{
RFM95_DEBUG(PSTR("RFM95:RSL\n")); // put radio to sleep
return RFM95_setRadioMode(RFM95_RADIO_MODE_SLEEP);
}
LOCAL bool RFM95_standBy(void)
{
RFM95_DEBUG(PSTR("RFM95:RSB\n")); // put radio to standby
return RFM95_setRadioMode(RFM95_RADIO_MODE_STDBY);
}
// should be called immediately after reception in case sender wants ACK
LOCAL void RFM95_sendACK(const uint8_t recipient, const rfm95_sequenceNumber_t sequenceNumber,
const rfm95_RSSI_t RSSI, const rfm95_SNR_t SNR)
{
RFM95_DEBUG(PSTR("RFM95:SAC:SEND ACK,TO=%" PRIu8 ",SEQ=%" PRIu16 ",RSSI=%" PRIi16 ",SNR=%" PRIi8
"\n"),recipient,sequenceNumber,
RFM95_internalToRSSI(RSSI),RFM95_internalToSNR(SNR));
rfm95_ack_t ACK;
ACK.sequenceNumber = sequenceNumber;
ACK.RSSI = RSSI;
ACK.SNR = SNR;
rfm95_controlFlags_t flags = 0u;
RFM95_setACKReceived(flags, true);
RFM95_setACKRSSIReport(flags, true);
(void)RFM95_send(recipient, (uint8_t *)&ACK, sizeof(rfm95_ack_t), flags);
}
LOCAL bool RFM95_executeATC(const rfm95_RSSI_t currentRSSI, const rfm95_RSSI_t targetRSSI)
{
rfm95_powerLevel_t newPowerLevel = RFM95.powerLevel;
const int16_t ownRSSI = RFM95_internalToRSSI(currentRSSI);
const int16_t uRange = RFM95_internalToRSSI(targetRSSI) + RFM95_ATC_TARGET_RANGE_DBM;
const int16_t lRange = RFM95_internalToRSSI(targetRSSI) - RFM95_ATC_TARGET_RANGE_DBM;
if (ownRSSI < lRange && RFM95.powerLevel < RFM95_MAX_POWER_LEVEL_DBM) {
// increase transmitter power
newPowerLevel++;
} else if (ownRSSI > uRange && RFM95.powerLevel > RFM95_MIN_POWER_LEVEL_DBM) {
// decrease transmitter power
newPowerLevel--;
} else {
// nothing to adjust
return false;
}
RFM95_DEBUG(PSTR("RFM95:ATC:ADJ TXL,cR=%" PRIi16 ",tR=%" PRIi16 "..%" PRIi16 ",TXL=%" PRIi8 "\n"),
ownRSSI, lRange, uRange, RFM95.powerLevel);
return RFM95_setTxPowerLevel(newPowerLevel);
}
LOCAL bool RFM95_sendWithRetry(const uint8_t recipient, const void *buffer,
const uint8_t bufferSize, const bool noACK)
{
for (uint8_t retry = 0; retry < RFM95_RETRIES; retry++) {
RFM95_DEBUG(PSTR("RFM95:SWR:SEND,TO=%" PRIu8 ",SEQ=%" PRIu16 ",RETRY=%" PRIu8 "\n"), recipient,
RFM95.txSequenceNumber,
retry);
rfm95_controlFlags_t flags = 0u;
RFM95_setACKRequested(flags, !noACK);
// send packet
if (!RFM95_send(recipient, (uint8_t *)buffer, bufferSize, flags, !retry)) {
return false;
}
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_RX);
if (noACK) {
return true;
}
const uint32_t enterMS = hwMillis();
while (hwMillis() - enterMS < RFM95_RETRY_TIMEOUT_MS && !RFM95.dataReceived) {
RFM95_handler();
if (RFM95.ackReceived) {
const uint8_t sender = RFM95.currentPacket.header.sender;
const rfm95_sequenceNumber_t ACKsequenceNumber = RFM95.currentPacket.ACK.sequenceNumber;
const rfm95_controlFlags_t flag = RFM95.currentPacket.header.controlFlags;
const rfm95_RSSI_t RSSI = RFM95.currentPacket.ACK.RSSI;
//const rfm95_SNR_t SNR = RFM95.currentPacket.ACK.SNR;
RFM95.ackReceived = false;
// packet read, back to RX
RFM95_setRadioMode(RFM95_RADIO_MODE_RX);
if (sender == recipient &&
(ACKsequenceNumber == RFM95.txSequenceNumber)) {
RFM95_DEBUG(PSTR("RFM95:SWR:ACK FROM=%" PRIu8 ",SEQ=%" PRIu16 ",RSSI=%" PRIi16 "\n"),sender,
ACKsequenceNumber,
RFM95_internalToRSSI(RSSI));
//RFM95_clearRxBuffer();
// ATC
if (RFM95.ATCenabled && RFM95_getACKRSSIReport(flag)) {
(void)RFM95_executeATC(RSSI, RFM95.ATCtargetRSSI);
}
return true;
} // seq check
}
doYield();
}
RFM95_DEBUG(PSTR("!RFM95:SWR:NACK\n"));
const uint32_t enterCSMAMS = hwMillis();
const uint16_t randDelayCSMA = enterMS % 100;
while (hwMillis() - enterCSMAMS < randDelayCSMA) {
doYield();
}
}
if (RFM95.ATCenabled) {
// No ACK received, maybe out of reach: increase power level
(void)RFM95_setTxPowerLevel(RFM95.powerLevel + 1);
}
return false;
}
// Wait until no channel activity detected or timeout
LOCAL bool RFM95_waitCAD(void)
{
// receiver needs to be in STDBY before entering CAD mode
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_STDBY);
(void)RFM95_setRadioMode(RFM95_RADIO_MODE_CAD);
const uint32_t enterMS = hwMillis();
while (RFM95.radioMode == RFM95_RADIO_MODE_CAD && (hwMillis() - enterMS < RFM95_CAD_TIMEOUT_MS) ) {
doYield();
RFM95_handler();
}
return !RFM95.channelActive;
}
LOCAL void RFM95_ATCmode(const bool OnOff, const int16_t targetRSSI)
{
RFM95.ATCenabled = OnOff;
RFM95.ATCtargetRSSI = RFM95_RSSItoInternal(targetRSSI);
}
LOCAL bool RFM95_sanityCheck(void)
{
bool result = true;
result &= RFM95_readReg(RFM95_REG_0F_FIFO_RX_BASE_ADDR) == RFM95_RX_FIFO_ADDR;
result &= RFM95_readReg(RFM95_REG_0E_FIFO_TX_BASE_ADDR) == RFM95_TX_FIFO_ADDR;
result &= RFM95_readReg(RFM95_REG_23_MAX_PAYLOAD_LENGTH) == RFM95_MAX_PACKET_LEN;
return result;
}
LOCAL int16_t RFM95_getSendingRSSI(void)
{
// own RSSI, as measured by the recipient - ACK part
if (RFM95_getACKRSSIReport(RFM95.currentPacket.header.controlFlags)) {
return RFM95_internalToRSSI(RFM95.currentPacket.ACK.RSSI);
} else {
// not possible
return INVALID_RSSI;
}
}
LOCAL int16_t RFM95_getSendingSNR(void)
{
// own SNR, as measured by the recipient - ACK part
if (RFM95_getACKRSSIReport(RFM95.currentPacket.header.controlFlags)) {
return static_cast<int16_t>(RFM95_internalToSNR(RFM95.currentPacket.ACK.SNR));
} else {
// not possible
return INVALID_SNR;
}
}
LOCAL int16_t RFM95_getReceivingRSSI(void)
{
// RSSI from last received packet
return static_cast<int16_t>(RFM95_internalToRSSI(RFM95.currentPacket.RSSI));
}
LOCAL int16_t RFM95_getReceivingSNR(void)
{
// SNR from last received packet
return static_cast<int16_t>(RFM95_internalToSNR(RFM95.currentPacket.SNR));
}
LOCAL uint8_t RFM95_getTxPowerLevel(void)
{
return RFM95.powerLevel;
}
LOCAL uint8_t RFM95_getTxPowerPercent(void)
{
// report TX level in %
const uint8_t result = static_cast<uint8_t>(100.0f * (RFM95.powerLevel -
RFM95_MIN_POWER_LEVEL_DBM) /
(RFM95_MAX_POWER_LEVEL_DBM
- RFM95_MIN_POWER_LEVEL_DBM));
return result;
}
LOCAL bool RFM95_setTxPowerPercent(const uint8_t newPowerPercent)
{
const rfm95_powerLevel_t newPowerLevel = static_cast<rfm95_powerLevel_t>
(RFM95_MIN_POWER_LEVEL_DBM + (RFM95_MAX_POWER_LEVEL_DBM
- RFM95_MIN_POWER_LEVEL_DBM) * (newPowerPercent / 100.0f));
RFM95_DEBUG(PSTR("RFM95:SPP:PCT=%" PRIu8 ",TX LEVEL=%" PRIi8 "\n"), newPowerPercent,newPowerLevel);
return RFM95_setTxPowerLevel(newPowerLevel);
}

487
lib/MySensors/hal/transport/RFM95/driver/RFM95.h
View File

@@ -1,487 +0,0 @@
/*
* The MySensors Arduino library handles the wireless radio link and protocol
* between your home built sensors/actuators and HA controller of choice.
* The sensors forms a self healing radio network with optional repeaters. Each
* repeater and gateway builds a routing tables in EEPROM which keeps track of the
* network topology allowing messages to be routed to nodes.
*
* Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
* Copyright (C) 2013-2019 Sensnology AB
* Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
*
* Documentation: http://www.mysensors.org
* Support Forum: http://forum.mysensors.org
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 as published by the Free Software Foundation.
*
* Based on Mike McCauley's RFM95 library, Copyright (C) 2014 Mike McCauley <mikem@airspayce.com>
* Radiohead http://www.airspayce.com/mikem/arduino/RadioHead/index.html
*
* RFM95 driver refactored and optimized for MySensors, Copyright (C) 2017-2018 Olivier Mauti <olivier@mysensors.org>
*
* Changelog:
* - ACK with sequenceNumber
* - ATC control
*
* Definitions for HopeRF LoRa radios:
* http://www.hoperf.com/upload/rf/RFM95_96_97_98W.pdf
*
*/
/**
* @file RFM95.h
*
* @defgroup RFM95grp RFM95
* @ingroup internals
* @{
*
* RFM95 driver-related log messages, format: [!]SYSTEM:[SUB SYSTEM:]MESSAGE
* - [!] Exclamation mark is prepended in case of error
*
* |E| SYS | SUB | Message | Comment
* |-|-------|------|----------------------------------------|-----------------------------------------------------------------------------------
* | | RFM95 | INIT | | Initialise RFM95 radio
* | | RFM95 | INIT | PIN,CS=%%d,IQP=%%d,IQN=%%d[,RST=%%d] | Pin configuration: chip select (CS), IRQ pin (IQP), IRQ number (IQN), Reset (RST)
* |!| RFM95 | INIT | SANCHK FAIL | Sanity check failed, check wiring or replace module
* |!| RFM95 | IRH | CRC FAIL | Incoming packet has CRC error, skip
* | | RFM95 | RCV | SEND ACK | ACK request received, sending ACK back
* | | RFM95 | PTC | LEVEL=%%d | Set TX power level
* | | RFM95 | SAC | SEND ACK,TO=%%d,RSSI=%%d,SNR=%%d | Send ACK to node (TO), RSSI of received message (RSSI), SNR of message (SNR)
* | | RFM95 | ATC | ADJ TXL,cR=%%d,tR=%%d..%%d,TXL=%%d | Adjust TX level, current RSSI (cR), target RSSI range (tR), TX level (TXL)
* | | RFM95 | SWR | SEND,TO=%%d,RETRY=%%d | Send message to (TO), NACK retry counter (RETRY)
* | | RFM95 | SWR | ACK FROM=%%d,SEQ=%%d,RSSI=%%d,SNR=%%d | ACK received from node (FROM), seq ID (SEQ), (RSSI), (SNR)
* |!| RFM95 | SWR | NACK | No ACK received
* | | RFM95 | SPP | PCT=%%d,TX LEVEL=%%d | Set TX level percent (PCT), TX level (LEVEL)
* | | RFM95 | PWD | | Power down radio
* | | RFM95 | PWU | | Power up radio
*
* RFM95 modem configuration
*
* BW = Bandwidth in kHz
* CR = Error correction code
* SF = Spreading factor, chips / symbol
*
* | CONFIG | BW | CR | SF | Comment | air-time (15 bytes)
* |------------------|-------|-----|------|-----------------------|------------------------
* | BW125CR45SF128 | 125 | 4/5 | 128 | Default, medium range | 50ms
* | BW500CR45SF128 | 500 | 4/5 | 128 | Fast, short range | 15ms
* | BW31_25CR48SF512 | 31.25 | 4/8 | 512 | Slow, long range | 900ms
* | BW125CR48SF4096 | 125 | 4/8 | 4096 | Slow, long range | 1500ms
*
* See here for air-time calculation: https://docs.google.com/spreadsheets/d/1voGAtQAjC1qBmaVuP1ApNKs1ekgUjavHuVQIXyYSvNc
*
* @brief API declaration for RFM95
*
*/
#ifndef _RFM95_h
#define _RFM95_h
#include "RFM95registers.h"
#if !defined(RFM95_SPI)
#define RFM95_SPI hwSPI //!< default SPI
#endif
// default PIN assignments, can be overridden
#if defined(ARDUINO_ARCH_AVR)
#if defined(__AVR_ATmega32U4__)
#define DEFAULT_RFM95_IRQ_PIN (3) //!< DEFAULT_RFM95_IRQ_PIN
#else
#define DEFAULT_RFM95_IRQ_PIN (2) //!< DEFAULT_RFM95_IRQ_PIN
#endif
#elif defined(ARDUINO_ARCH_ESP8266)
#define DEFAULT_RFM95_IRQ_PIN (5) //!< DEFAULT_RFM95_IRQ_PIN
#elif defined(ARDUINO_ARCH_ESP32)
#define DEFAULT_RFM95_IRQ_PIN (16) //!< DEFAULT_RFM95_IRQ_PIN
#define DEFAULT_RFM95_IRQ_NUM digitalPinToInterrupt(DEFAULT_RFM95_IRQ_PIN) //!< DEFAULT_RFM95_IRQ_NUM
#elif defined(ARDUINO_ARCH_SAMD)
#define DEFAULT_RFM95_IRQ_PIN (2) //!< DEFAULT_RFM95_IRQ_PIN
#elif defined(LINUX_ARCH_RASPBERRYPI)
#define DEFAULT_RFM95_IRQ_PIN (22) //!< DEFAULT_RFM95_IRQ_PIN
#elif defined(ARDUINO_ARCH_STM32F1)
#define DEFAULT_RFM95_IRQ_PIN (PA3) //!< DEFAULT_RFM95_IRQ_PIN
#elif defined(TEENSYDUINO)
#define DEFAULT_RFM95_IRQ_PIN (8) //!< DEFAULT_RFM95_IRQ_PIN
#else
#define DEFAULT_RFM95_IRQ_PIN (2) //!< DEFAULT_RFM95_IRQ_PIN
#endif
#define DEFAULT_RFM95_CS_PIN (SS) //!< DEFAULT_RFM95_CS_PIN
// SPI settings
#define RFM95_SPI_DATA_ORDER MSBFIRST //!< SPI data order
#define RFM95_SPI_DATA_MODE SPI_MODE0 //!< SPI mode
// RFM95 radio configurations: reg_1d, reg_1e, reg_26 (see datasheet)
#define RFM95_BW125CR45SF128 RFM95_BW_125KHZ | RFM95_CODING_RATE_4_5, RFM95_SPREADING_FACTOR_128CPS | RFM95_RX_PAYLOAD_CRC_ON, RFM95_AGC_AUTO_ON //!< 0x72,0x74,0x04
#define RFM95_BW500CR45SF128 RFM95_BW_500KHZ | RFM95_CODING_RATE_4_5, RFM95_SPREADING_FACTOR_128CPS | RFM95_RX_PAYLOAD_CRC_ON, RFM95_AGC_AUTO_ON //!< 0x92,0x74,0x04
#define RFM95_BW31_25CR48SF512 RFM95_BW_31_25KHZ | RFM95_CODING_RATE_4_8, RFM95_SPREADING_FACTOR_512CPS | RFM95_RX_PAYLOAD_CRC_ON, RFM95_AGC_AUTO_ON //!< 0x48,0x94,0x04
#define RFM95_BW125CR48SF4096 RFM95_BW_125KHZ | RFM95_CODING_RATE_4_8, RFM95_SPREADING_FACTOR_4096CPS | RFM95_RX_PAYLOAD_CRC_ON, RFM95_AGC_AUTO_ON | RFM95_LOW_DATA_RATE_OPTIMIZE //!< 0x78,0xc4,0x0C
#if !defined(RFM95_RETRY_TIMEOUT_MS)
// air-time approximation for timeout, 1 hop ~15 bytes payload - adjust if needed
// BW125/SF128: 50ms
// BW500/SF128: 15ms
// BW31.25/SF512: 900ms
// BW125/SF4096: 1500ms
#define RFM95_RETRY_TIMEOUT_MS (500ul) //!< Timeout for ACK, adjustments needed if modem configuration changed (air time different)
#endif
#if !defined(MY_RFM95_TX_TIMEOUT_MS)
#define MY_RFM95_TX_TIMEOUT_MS (5*1000ul) //!< TX timeout
#endif
// Frequency definitions
#define RFM95_169MHZ (169000000ul) //!< 169 Mhz
#define RFM95_315MHZ (315000000ul) //!< 315 Mhz
#define RFM95_434MHZ (433920000ul) //!< 433.92 Mhz
#define RFM95_868MHZ (868100000ul) //!< 868.1 Mhz
#define RFM95_915MHZ (915000000ul) //!< 915 Mhz
#define RFM95_RETRIES (5u) //!< Retries in case of failed transmission
#define RFM95_FIFO_SIZE (0xFFu) //!< Max number of bytes the LORA Rx/Tx FIFO can hold
#define RFM95_RX_FIFO_ADDR (0x00u) //!< RX FIFO addr pointer
#define RFM95_TX_FIFO_ADDR (0x80u) //!< TX FIFO addr pointer
#define RFM95_MAX_PACKET_LEN (0x40u) //!< This is the maximum number of bytes that can be carried by the LORA
#define RFM95_PREAMBLE_LENGTH (8u) //!< Preamble length, default=8
#define RFM95_CAD_TIMEOUT_MS (2*1000ul) //!< channel activity detection timeout
#define RFM95_POWERUP_DELAY_MS (100u) //!< Power up delay, allow VCC to settle, transport to become fully operational
#define RFM95_PACKET_HEADER_VERSION (1u) //!< RFM95 packet header version
#define RFM95_MIN_PACKET_HEADER_VERSION (1u) //!< Minimal RFM95 packet header version
#define RFM95_BIT_ACK_REQUESTED (7u) //!< RFM95 header, controlFlag, bit 7
#define RFM95_BIT_ACK_RECEIVED (6u) //!< RFM95 header, controlFlag, bit 6
#define RFM95_BIT_ACK_RSSI_REPORT (5u) //!< RFM95 header, controlFlag, bit 5
#define RFM95_BROADCAST_ADDRESS (255u) //!< Broadcasting address
#define RFM95_ATC_TARGET_RANGE_DBM (2u) //!< ATC target range +/- dBm
#define RFM95_RSSI_OFFSET (137u) //!< RSSI offset
#define RFM95_TARGET_RSSI (-70) //!< RSSI target
#define RFM95_PROMISCUOUS (false) //!< RFM95 promiscuous mode
#define RFM95_FXOSC (32*1000000ul) //!< The crystal oscillator frequency of the module
#define RFM95_FSTEP (RFM95_FXOSC / 524288.0f) //!< The Frequency Synthesizer step
// helper macros
#define RFM95_getACKRequested(__value) ((bool)bitRead(__value, RFM95_BIT_ACK_REQUESTED)) //!< getACKRequested
#define RFM95_setACKRequested(__value, __flag) bitWrite(__value, RFM95_BIT_ACK_REQUESTED,__flag) //!< setACKRequested
#define RFM95_getACKReceived(__value) ((bool)bitRead(__value, RFM95_BIT_ACK_RECEIVED)) //!< getACKReceived
#define RFM95_setACKReceived(__value, __flag) bitWrite(__value, RFM95_BIT_ACK_RECEIVED,__flag) //!< setACKReceived
#define RFM95_setACKRSSIReport(__value, __flag) bitWrite(__value, RFM95_BIT_ACK_RSSI_REPORT,__flag) //!< setACKRSSIReport
#define RFM95_getACKRSSIReport(__value) ((bool)bitRead(__value, RFM95_BIT_ACK_RSSI_REPORT)) //!< getACKRSSIReport
#define RFM95_internalToSNR(__value) ((int8_t)(__value / 4)) //!< Convert internal SNR to SNR
#define RFM95_MIN_POWER_LEVEL_DBM ((rfm95_powerLevel_t)5u) //!< min. power level
#if defined(MY_RFM95_MAX_POWER_LEVEL_DBM)
#define RFM95_MAX_POWER_LEVEL_DBM MY_RFM95_MAX_POWER_LEVEL_DBM //!< MY_RFM95_MAX_POWER_LEVEL_DBM
#else
#define RFM95_MAX_POWER_LEVEL_DBM ((rfm95_powerLevel_t)23u) //!< max. power level
#endif
/**
* @brief Radio modes
*/
typedef enum {
RFM95_RADIO_MODE_RX = 0, //!< RX mode
RFM95_RADIO_MODE_TX = 1, //!< TX mode
RFM95_RADIO_MODE_CAD = 2, //!< CAD mode
RFM95_RADIO_MODE_SLEEP = 3, //!< SLEEP mode
RFM95_RADIO_MODE_STDBY = 4 //!< STDBY mode
} rfm95_radioMode_t;
/**
* @brief RFM95 modem config registers
*/
typedef struct {
uint8_t reg_1d; //!< Value for register REG_1D_MODEM_CONFIG1
uint8_t reg_1e; //!< Value for register REG_1E_MODEM_CONFIG2
uint8_t reg_26; //!< Value for register REG_26_MODEM_CONFIG3
} rfm95_modemConfig_t;
/**
* @brief Sequence number data type
*/
typedef uint16_t rfm95_sequenceNumber_t; // will eventually change to uint8_t in 3.0
/**
* @brief RSSI data type
*/
typedef uint8_t rfm95_RSSI_t;
/**
* @brief SNR data type
*/
typedef int8_t rfm95_SNR_t;
/**
* @brief Control flag data type
*/
typedef uint8_t rfm95_controlFlags_t;
/**
* @brief Power level in dBm
*/
typedef int8_t rfm95_powerLevel_t;
/**
* @brief RFM95 LoRa header
*/
typedef struct {
uint8_t version; //!< Header version
uint8_t recipient; //!< Payload recipient
uint8_t sender; //!< Payload sender
rfm95_controlFlags_t controlFlags; //!< Control flags, used for ACK
rfm95_sequenceNumber_t sequenceNumber; //!< Packet sequence number, used for ACK
} __attribute__((packed)) rfm95_header_t;
/**
* @brief RFM95 LoRa ACK packet structure
*/
typedef struct {
rfm95_sequenceNumber_t sequenceNumber; //!< sequence number
rfm95_RSSI_t RSSI; //!< RSSI
rfm95_SNR_t SNR; //!< SNR
} __attribute__((packed)) rfm95_ack_t;
#define RFM95_HEADER_LEN sizeof(rfm95_header_t) //!< Size header inside LoRa payload
#define RFM95_MAX_PAYLOAD_LEN (RFM95_MAX_PACKET_LEN - RFM95_HEADER_LEN) //!< Max payload length
/**
* @brief LoRa packet structure
*/
typedef struct {
union {
struct {
rfm95_header_t header; //!< LoRa header
union {
uint8_t payload[RFM95_MAX_PAYLOAD_LEN]; //!< Payload, i.e. MySensors message
rfm95_ack_t ACK; //!< Union: ACK
};
};
uint8_t data[RFM95_MAX_PACKET_LEN]; //!< RAW
};
uint8_t payloadLen; //!< Length of payload (excluding header)
rfm95_RSSI_t RSSI; //!< RSSI of current packet, RSSI = value - 137
rfm95_SNR_t SNR; //!< SNR of current packet
} __attribute__((packed)) rfm95_packet_t;
/**
* @brief RFM95 internal variables
*/
typedef struct {
uint8_t address; //!< Node address
rfm95_packet_t currentPacket; //!< Buffer for current packet
rfm95_sequenceNumber_t txSequenceNumber; //!< RFM95_txSequenceNumber
rfm95_powerLevel_t powerLevel; //!< TX power level dBm
rfm95_RSSI_t ATCtargetRSSI; //!< ATC: target RSSI
// 8 bit
rfm95_radioMode_t radioMode : 3; //!< current transceiver state
bool channelActive : 1; //!< RFM95_cad
bool ATCenabled : 1; //!< ATC enabled
bool ackReceived : 1; //!< ACK received
bool dataReceived : 1; //!< Data received
bool reserved : 1; //!< unused
} rfm95_internal_t;
#define LOCAL static //!< static
/**
* @brief Initialise the driver transport hardware and software
* @param frequencyHz Transmitter frequency in Hz
* @return True if initialisation succeeded
*/
LOCAL bool RFM95_initialise(const uint32_t frequencyHz);
/**
* @brief Set the driver/node address
* @param addr
*/
LOCAL void RFM95_setAddress(const uint8_t addr);
/**
* @brief Get driver/node address
* @return Node address
*/
LOCAL uint8_t RFM95_getAddress(void);
/**
* @brief Sets all the registers required to configure the data modem in the RF95/96/97/98, including the
* bandwidth, spreading factor etc.
* @param config See modemConfig_t and references therein
*/
LOCAL void RFM95_setModemRegisters(const rfm95_modemConfig_t *config);
/**
* @brief Tests whether a new message is available
* @return True if a new, complete, error-free uncollected message is available to be retreived by @ref RFM95_receive()
*/
LOCAL bool RFM95_available(void);
/**
* @brief If a valid message is received, copy it to buf and return length. 0 byte messages are permitted.
* @param buf Location to copy the received message
* @param maxBufSize Max buffer size
* @return Number of bytes
*/
LOCAL uint8_t RFM95_receive(uint8_t *buf, const uint8_t maxBufSize);
/**
* @brief RFM95_send
* @param recipient
* @param data
* @param len
* @param flags
* @param increaseSequenceCounter
* @return True if packet sent
*/
LOCAL bool RFM95_send(const uint8_t recipient, uint8_t *data, const uint8_t len,
const rfm95_controlFlags_t flags, const bool increaseSequenceCounter = true);
/**
* @brief RFM95_sendFrame
* @param packet
* @param increaseSequenceCounter
* @return True if frame sent
*/
LOCAL bool RFM95_sendFrame(rfm95_packet_t *packet, const bool increaseSequenceCounter = true);
/**
* @brief RFM95_setPreambleLength
* @param preambleLength
*/
LOCAL void RFM95_setPreambleLength(const uint16_t preambleLength);
/**
* @brief Sets the transmitter and receiver centre frequency
* @param frequencyHz Frequency in Hz
*/
LOCAL void RFM95_setFrequency(const uint32_t frequencyHz);
/**
* @brief Sets the transmitter power output level, and configures the transmitter pin
* @param newPowerLevel Transmitter power level in dBm (+5 to +23)
* @return True power level adjusted
*/
LOCAL bool RFM95_setTxPowerLevel(rfm95_powerLevel_t newPowerLevel);
/**
* @brief Sets the transmitter power output percent.
* @param newPowerPercent Transmitter power level in percent
* @return True power level adjusted
*/
LOCAL bool RFM95_setTxPowerPercent(const uint8_t newPowerPercent);
/**
* @brief Enable TCXO mode
* Call this immediately after init(), to force your radio to use an external
* frequency source, such as a Temperature Compensated Crystal Oscillator (TCXO).
* See the comments in the main documentation about the sensitivity of this radio to
* clock frequency especially when using narrow bandwidths.
* @note Has to be called while radio is in sleep mode.
*/
LOCAL void RFM95_enableTCXO(void);
/**
* @brief Sets the radio into low-power sleep mode
* @return true if sleep mode was successfully entered
*/
LOCAL bool RFM95_sleep(void);
/**
* @brief Sets the radio into standby mode
* @return true if standby mode was successfully entered
*/
LOCAL bool RFM95_standBy(void);
/**
* @brief Powerdown radio, if RFM95_POWER_PIN defined
*/
LOCAL void RFM95_powerDown(void);
/**
* @brief Powerup radio, if RFM95_POWER_PIN defined
*/
LOCAL void RFM95_powerUp(void);
/**
* @brief RFM95_sendACK
* @param recipient
* @param sequenceNumber
* @param RSSI (rfm95_RSSI_t)
* @param SNR (rfm95_SNR_t)
*/
LOCAL void RFM95_sendACK(const uint8_t recipient, const rfm95_sequenceNumber_t sequenceNumber,
const rfm95_RSSI_t RSSI, const rfm95_SNR_t SNR);
/**
* @brief RFM95_sendWithRetry
* @param recipient
* @param buffer
* @param bufferSize
* @param noACK
* @return True if packet successfully sent
*/
LOCAL bool RFM95_sendWithRetry(const uint8_t recipient, const void *buffer,
const uint8_t bufferSize, const bool noACK);
/**
* @brief Wait until no channel activity detected
* @return True if no channel activity detected, False if timeout occured
*/
LOCAL bool RFM95_waitCAD(void);
/**
* @brief RFM95_setRadioMode
* @param newRadioMode
* @return True if mode changed
*/
LOCAL bool RFM95_setRadioMode(const rfm95_radioMode_t newRadioMode);
/**
* @brief Low level interrupt handler
*/
LOCAL void RFM95_interruptHandler(void);
/**
* @brief Packet engine
*/
LOCAL void RFM95_interruptHandling(void);
/**
* @brief RFM95_handler
*/
LOCAL void RFM95_handler(void);
/**
* @brief RFM95_getSendingRSSI
* @return RSSI Signal strength of last packet received
*/
LOCAL int16_t RFM95_getReceivingRSSI(void);
/**
* @brief RFM95_getSendingRSSI
* @return RSSI Signal strength of last packet sent (if ACK and ATC enabled)
*/
LOCAL int16_t RFM95_getSendingRSSI(void);
/**
* @brief RFM95_getReceivingSNR
* @return SNR
*/
LOCAL int16_t RFM95_getReceivingSNR(void);
/**
* @brief RFM95_getSendingSNR
* @return SNR of last packet sent (if ACK and ATC enabled)
*/
LOCAL int16_t RFM95_getSendingSNR(void);
/**
* @brief Get transmitter power level
* @return Transmitter power level in percents
*/
LOCAL uint8_t RFM95_getTxPowerPercent(void);
/**
* @brief Get transmitter power level
* @return Transmitter power level in dBm
*/
LOCAL uint8_t RFM95_getTxPowerLevel(void);
/**
* @brief RFM_executeATC
* @param currentRSSI
* @param targetRSSI
* @return True if power level adjusted
*/
LOCAL bool RFM95_executeATC(const rfm95_RSSI_t currentRSSI, const rfm95_RSSI_t targetRSSI);
/**
* @brief RFM95_ATCmode
* @param targetRSSI Target RSSI for transmitter (default -60)
* @param OnOff True to enable ATC
*/
LOCAL void RFM95_ATCmode(const bool OnOff, const int16_t targetRSSI = RFM95_TARGET_RSSI);
/**
* @brief RFM95_sanityCheck
* @return True if sanity check passed
*/
LOCAL bool RFM95_sanityCheck(void);
#endif
/** @}*/

205
lib/MySensors/hal/transport/RFM95/driver/RFM95registers.h
View File

@@ -1,205 +0,0 @@
/*
* The MySensors Arduino library handles the wireless radio link and protocol
* between your home built sensors/actuators and HA controller of choice.
* The sensors forms a self healing radio network with optional repeaters. Each
* repeater and gateway builds a routing tables in EEPROM which keeps track of the
* network topology allowing messages to be routed to nodes.
*
* Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
* Copyright (C) 2013-2019 Sensnology AB
* Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
*
* Documentation: http://www.mysensors.org
* Support Forum: http://forum.mysensors.org
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 as published by the Free Software Foundation.
*
* Based on Mike McCauley's RFM95 library, Copyright (C) 2014 Mike McCauley <mikem@airspayce.com>
* Radiohead http://www.airspayce.com/mikem/arduino/RadioHead/index.html
*
* RFM95 driver refactored and optimized for MySensors, Copyright (C) 2017-2018 Olivier Mauti <olivier@mysensors.org>
*
* Definitions for HopeRF LoRa radios:
* http://www.hoperf.com/upload/rf/RFM95_96_97_98W.pdf
*
*/
// Register access
#define RFM95_READ_REGISTER (0x7Fu) //!< reading register
#define RFM95_WRITE_REGISTER (0x80u) //!< writing register
#define RFM95_NOP (0x00u) //!< NOP
// Registers, available in LoRa mode
#define RFM95_REG_00_FIFO 0x00 //!< REG_00_FIFO
#define RFM95_REG_01_OP_MODE 0x01 //!< REG_01_OP_MODE
#define RFM95_REG_02_RESERVED 0x02 //!< REG_02_RESERVED
#define RFM95_REG_03_RESERVED 0x03 //!< REG_03_RESERVED
#define RFM95_REG_04_RESERVED 0x04 //!< REG_04_RESERVED
#define RFM95_REG_05_RESERVED 0x05 //!< REG_05_RESERVED
#define RFM95_REG_06_FRF_MSB 0x06 //!< REG_06_FRF_MSB
#define RFM95_REG_07_FRF_MID 0x07 //!< REG_07_FRF_MID
#define RFM95_REG_08_FRF_LSB 0x08 //!< REG_08_FRF_LSB
#define RFM95_REG_09_PA_CONFIG 0x09 //!< REG_09_PA_CONFIG
#define RFM95_REG_0A_PA_RAMP 0x0a //!< REG_0A_PA_RAMP
#define RFM95_REG_0B_OCP 0x0b //!< REG_0B_OCP
#define RFM95_REG_0C_LNA 0x0c //!< REG_0C_LNA
#define RFM95_REG_0D_FIFO_ADDR_PTR 0x0d //!< REG_0D_FIFO_ADDR_PTR
#define RFM95_REG_0E_FIFO_TX_BASE_ADDR 0x0e //!< REG_0E_FIFO_TX_BASE_ADDR
#define RFM95_REG_0F_FIFO_RX_BASE_ADDR 0x0f //!< REG_0F_FIFO_RX_BASE_ADDR
#define RFM95_REG_10_FIFO_RX_CURRENT_ADDR 0x10 //!< REG_10_FIFO_RX_CURRENT_ADDR
#define RFM95_REG_11_IRQ_FLAGS_MASK 0x11 //!< REG_11_IRQ_FLAGS_MASK
#define RFM95_REG_12_IRQ_FLAGS 0x12 //!< REG_12_IRQ_FLAGS
#define RFM95_REG_13_RX_NB_BYTES 0x13 //!< REG_13_RX_NB_BYTES
#define RFM95_REG_14_RX_HEADER_CNT_VALUE_MSB 0x14 //!< REG_14_RX_HEADER_CNT_VALUE_MSB
#define RFM95_REG_15_RX_HEADER_CNT_VALUE_LSB 0x15 //!< REG_15_RX_HEADER_CNT_VALUE_LSB
#define RFM95_REG_16_RX_PACKET_CNT_VALUE_MSB 0x16 //!< REG_16_RX_PACKET_CNT_VALUE_MSB
#define RFM95_REG_17_RX_PACKET_CNT_VALUE_LSB 0x17 //!< REG_17_RX_PACKET_CNT_VALUE_LSB
#define RFM95_REG_18_MODEM_STAT 0x18 //!< REG_18_MODEM_STAT
#define RFM95_REG_19_PKT_SNR_VALUE 0x19 //!< REG_19_PKT_SNR_VALUE
#define RFM95_REG_1A_PKT_RSSI_VALUE 0x1a //!< REG_1A_PKT_RSSI_VALUE
#define RFM95_REG_1B_RSSI_VALUE 0x1b //!< REG_1B_RSSI_VALUE
#define RFM95_REG_1C_HOP_CHANNEL 0x1c //!< REG_1C_HOP_CHANNEL
#define RFM95_REG_1D_MODEM_CONFIG1 0x1d //!< REG_1D_MODEM_CONFIG1
#define RFM95_REG_1E_MODEM_CONFIG2 0x1e //!< REG_1E_MODEM_CONFIG2
#define RFM95_REG_1F_SYMB_TIMEOUT_LSB 0x1f //!< REG_1F_SYMB_TIMEOUT_LSB
#define RFM95_REG_20_PREAMBLE_MSB 0x20 //!< REG_20_PREAMBLE_MSB
#define RFM95_REG_21_PREAMBLE_LSB 0x21 //!< REG_21_PREAMBLE_LSB
#define RFM95_REG_22_PAYLOAD_LENGTH 0x22 //!< REG_22_PAYLOAD_LENGTH
#define RFM95_REG_23_MAX_PAYLOAD_LENGTH 0x23 //!< REG_23_MAX_PAYLOAD_LENGTH
#define RFM95_REG_24_HOP_PERIOD 0x24 //!< REG_24_HOP_PERIOD
#define RFM95_REG_25_FIFO_RX_BYTE_ADDR 0x25 //!< REG_25_FIFO_RX_BYTE_ADDR
#define RFM95_REG_26_MODEM_CONFIG3 0x26 //!< REG_26_MODEM_CONFIG3
// Reserved when in LoRa mode
#define RFM95_REG_40_DIO_MAPPING1 0x40 //!< REG_40_DIO_MAPPING1
#define RFM95_REG_41_DIO_MAPPING2 0x41 //!< REG_41_DIO_MAPPING2
#define RFM95_REG_42_VERSION 0x42 //!< REG_42_VERSION
#define RFM95_REG_4B_TCXO 0x4b //!< REG_4B_TCXO
#define RFM95_REG_4D_PA_DAC 0x4d //!< REG_4D_PA_DAC
#define RFM95_REG_5B_FORMER_TEMP 0x5b //!< REG_5B_FORMER_TEMP
#define RFM95_REG_61_AGC_REF 0x61 //!< REG_61_AGC_REF
#define RFM95_REG_62_AGC_THRESH1 0x62 //!< REG_62_AGC_THRESH1
#define RFM95_REG_63_AGC_THRESH2 0x63 //!< REG_63_AGC_THRESH2
#define RFM95_REG_64_AGC_THRESH3 0x64 //!< REG_64_AGC_THRESH3
// RFM95_REG_01_OP_MODE 0x01
#define RFM95_LONG_RANGE_MODE 0x80 //!< LONG_RANGE_MODE
#define RFM95_ACCESS_SHARED_REG 0x40 //!< ACCESS_SHARED_REG
#define RFM95_MODE_SLEEP 0x00 //!< MODE_SLEEP
#define RFM95_MODE_STDBY 0x01 //!< MODE_STDBY
#define RFM95_MODE_FSTX 0x02 //!< MODE_FSTX
#define RFM95_MODE_TX 0x03 //!< MODE_TX
#define RFM95_MODE_FSRX 0x04 //!< MODE_FSRX
#define RFM95_MODE_RXCONTINUOUS 0x05 //!< MODE_RXCONTINUOUS
#define RFM95_MODE_RXSINGLE 0x06 //!< MODE_RXSINGLE
#define RFM95_MODE_CAD 0x07 //!< MODE_CAD
// RFM95_REG_09_PA_CONFIG 0x09
#define RFM95_OUTPUT_POWER 0x0F //!< OUTPUT_POWER
#define RFM95_MAX_POWER 0x70 //!< MAX_POWER
#define RFM95_PA_SELECT 0x80 //!< PA_SELECT
// RFM95_REG_0A_PA_RAMP 0x0a
#define RFM95_PA_RAMP_3_4MS 0x00 //!< PA_RAMP_3_4MS
#define RFM95_PA_RAMP_2MS 0x01 //!< PA_RAMP_2MS
#define RFM95_PA_RAMP_1MS 0x02 //!< PA_RAMP_1MS
#define RFM95_PA_RAMP_500US 0x03 //!< PA_RAMP_500US
#define RFM95_PA_RAMP_250US 0x04 //!< PA_RAMP_250US
#define RFM95_PA_RAMP_125US 0x05 //!< PA_RAMP_125US
#define RFM95_PA_RAMP_100US 0x06 //!< PA_RAMP_100US
#define RFM95_PA_RAMP_62US 0x07 //!< PA_RAMP_62US
#define RFM95_PA_RAMP_50US 0x08 //!< PA_RAMP_50US
#define RFM95_PA_RAMP_40US 0x09 //!< PA_RAMP_40US
#define RFM95_PA_RAMP_31US 0x0A //!< PA_RAMP_31US
#define RFM95_PA_RAMP_25US 0x0B //!< PA_RAMP_25US
#define RFM95_PA_RAMP_20US 0x0C //!< PA_RAMP_20US
#define RFM95_PA_RAMP_15US 0x0D //!< PA_RAMP_15US
#define RFM95_PA_RAMP_12US 0x0E //!< PA_RAMP_12US
#define RFM95_PA_RAMP_10US 0x0F //!< PA_RAMP_10US
#define RFM95_LOW_PN_TX_PLL_OFF 0x10 //!< LOW_PN_TX_PLL_OFF
// RFM95_REG_0B_OCP 0x0b
#define RFM95_OCP_TRIM 0x1f //!< OCP_TRIM
#define RFM95_OCP_ON 0x20 //!< OCP_ON
// RFM95_REG_0C_LNA 0x0c
#define RFM95_LNA_BOOST_DEFAULT 0x20 //!< LNA_BOOST_DEFAULT
#define RFM95_LNA_BOOST 0x03 //!< LNA_BOOST
// RFM95_REG_11_IRQ_FLAGS_MASK 0x11
#define RFM95_CAD_DETECTED_MASK 0x01 //!< CAD_DETECTED_MASK
#define RFM95_FHSS_CHANGE_CHANNEL_MASK 0x02 //!< FHSS_CHANGE_CHANNEL_MASK
#define RFM95_CAD_DONE_MASK 0x04 //!< CAD_DONE_MASK
#define RFM95_TX_DONE_MASK 0x08 //!< TX_DONE_MASK
#define RFM95_VALID_HEADER_MASK 0x10 //!< VALID_HEADER_MASK
#define RFM95_PAYLOAD_CRC_ERROR_MASK 0x20 //!< PAYLOAD_CRC_ERROR_MASK
#define RFM95_RX_DONE_MASK 0x40 //!< RX_DONE_MASK
#define RFM95_RX_TIMEOUT_MASK 0x80 //!< RX_TIMEOUT_MASK
// RFM95_REG_12_IRQ_FLAGS 0x12
#define RFM95_CAD_DETECTED 0x01 //!< CAD_DETECTED
#define RFM95_FHSS_CHANGE_CHANNEL 0x02 //!< FHSS_CHANGE_CHANNEL
#define RFM95_CAD_DONE 0x04 //!< CAD_DONE
#define RFM95_TX_DONE 0x08 //!< TX_DONE
#define RFM95_VALID_HEADER 0x10 //!< VALID_HEADER
#define RFM95_PAYLOAD_CRC_ERROR 0x20 //!< PAYLOAD_CRC_ERROR
#define RFM95_RX_DONE 0x40 //!< RX_DONE
#define RFM95_RX_TIMEOUT 0x80 //!< RX_TIMEOUT
#define RFM95_CLEAR_IRQ 0xFF //<! Clear IRQ
// RFM95_REG_18_MODEM_STAT 0x18
#define RFM95_MODEM_STATUS_SIGNAL_DETECTED 0x01 //!< MODEM_STATUS_SIGNAL_DETECTED
#define RFM95_MODEM_STATUS_SIGNAL_SYNCHRONIZED 0x02 //!< MODEM_STATUS_SIGNAL_SYNCHRONIZED
#define RFM95_MODEM_STATUS_RX_ONGOING 0x04 //!< MODEM_STATUS_RX_ONGOING
#define RFM95_MODEM_STATUS_HEADER_INFO_VALID 0x08 //!< MODEM_STATUS_HEADER_INFO_VALID
#define RFM95_MODEM_STATUS_CLEAR 0x10 //!< MODEM_STATUS_CLEAR
// RFM95_REG_1C_HOP_CHANNEL 0x1c
#define RFM95_RX_PAYLOAD_CRC_IS_ON 0x40 //!< RX_PAYLOAD_CRC_IS_ON
#define RFM95_PLL_TIMEOUT 0x80 //!< PLL_TIMEOUT
// RFM95_REG_1D_MODEM_CONFIG1 0x1d
#define RFM95_BW_7_8KHZ 0x00 //!< BW_7_8KHZ
#define RFM95_BW_10_4KHZ 0x10 //!< BW_10_4KHZ
#define RFM95_BW_15_6KHZ 0x20 //!< BW_15_6KHZ
#define RFM95_BW_20_8KHZ 0x30 //!< BW_20_8KHZ
#define RFM95_BW_31_25KHZ 0x40 //!< BW_31_25KHZ
#define RFM95_BW_41_7KHZ 0x50 //!< BW_41_7KHZ
#define RFM95_BW_62_5KHZ 0x60 //!< BW_62_5KHZ
#define RFM95_BW_125KHZ 0x70 //!< BW_125KHZ
#define RFM95_BW_250KHZ 0x80 //!< BW_250KHZ
#define RFM95_BW_500KHZ 0x90 //!< BW_500KHZ
#define RFM95_IMPLICIT_HEADER_MODE_ON 0x01 //!< IMPLICIT_HEADER_MODE_ON
#define RFM95_CODING_RATE_4_5 0x02 //!< CODING_RATE_4_5
#define RFM95_CODING_RATE_4_6 0x04 //!< CODING_RATE_4_6
#define RFM95_CODING_RATE_4_7 0x06 //!< CODING_RATE_4_7
#define RFM95_CODING_RATE_4_8 0x08 //!< CODING_RATE_4_8
// RFM95_REG_1E_MODEM_CONFIG2 0x1e
#define RFM95_SPREADING_FACTOR_64CPS 0x60 //!< SPREADING_FACTOR_64CPS, SF6
#define RFM95_SPREADING_FACTOR_128CPS 0x70 //!< SPREADING_FACTOR_128CPS, SF7
#define RFM95_SPREADING_FACTOR_256CPS 0x80 //!< SPREADING_FACTOR_256CPS, SF8
#define RFM95_SPREADING_FACTOR_512CPS 0x90 //!< SPREADING_FACTOR_512CPS, SF9
#define RFM95_SPREADING_FACTOR_1024CPS 0xA0 //!< SPREADING_FACTOR_1024CPS, SF10
#define RFM95_SPREADING_FACTOR_2048CPS 0xB0 //!< SPREADING_FACTOR_2048CPS, SF11
#define RFM95_SPREADING_FACTOR_4096CPS 0xC0 //!< SPREADING_FACTOR_4096CPS, SF12
#define RFM95_SYM_TIMEOUT_MSB 0x03 //!< SYM_TIMEOUT_MSB
#define RFM95_RX_PAYLOAD_CRC_ON 0x04 //!< RX_PAYLOAD_CRC_ON
#define RFM95_TX_CONTINUOUS_MOdE 0x08 //!< TX_CONTINUOUS_MODE
// RFM95_REG_26_MODEM_CONFIG3 0x26
#define RFM95_LOW_DATA_RATE_OPTIMIZE 0x08 //!< LOW_DATA_RATE_OPTIMIZE
#define RFM95_AGC_AUTO_ON 0x04 //!< AGC_AUTO_ON
// RFM95_REG_4B_TCXO 0x4b
#define RFM95_TCXO_TCXO_INPUT_ON 0x10 //!< TCXO_TCXO_INPUT_ON
// RFM95_REG_4D_PA_DAC 0x4d
#define RFM95_PA_DAC_DISABLE 0x04 //!< PA_DAC_DISABLE
#define RFM95_PA_DAC_ENABLE 0x07 //!< PA_DAC_ENABLE