Dan Julio
Quick & dirty port of the RadioHead library with minimal support for the RF95 radio. It is designed to be used with the swspi library which in turn is designed to be used on the MAX32630FTHR board.
Revision 0:e69d086cb053, committed 2017-06-11
- Comitter:
- danjulio
- Date:
- Sun Jun 11 04:05:05 2017 +0000
- Commit message:
- Initial commit of minimally ported Radiohead library using swspi
Changed in this revision
diff -r 000000000000 -r e69d086cb053 RHGenericDriver.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RHGenericDriver.cpp Sun Jun 11 04:05:05 2017 +0000
@@ -0,0 +1,225 @@
+// RHGenericDriver.cpp
+//
+// Copyright (C) 2014 Mike McCauley
+// $Id: RHGenericDriver.cpp,v 1.21 2017/03/04 00:59:41 mikem Exp $
+//
+// Ported to mbed - support only a single radio - Dan Julio - 5/2017
+//
+
+#include <RHGenericDriver.h>
+
+RHGenericDriver::RHGenericDriver()
+ :
+ _mode(RHModeInitialising),
+ _thisAddress(RH_BROADCAST_ADDRESS),
+ _txHeaderTo(RH_BROADCAST_ADDRESS),
+ _txHeaderFrom(RH_BROADCAST_ADDRESS),
+ _txHeaderId(0),
+ _txHeaderFlags(0),
+ _rxBad(0),
+ _rxGood(0),
+ _txGood(0),
+ _cad_timeout(0)
+{
+}
+
+bool RHGenericDriver::init()
+{
+ return true;
+}
+
+// Blocks until a valid message is received
+void RHGenericDriver::waitAvailable()
+{
+ while (!available())
+ Thread::yield();
+}
+
+// Blocks until a valid message is received or timeout expires
+// Return true if there is a message available
+// Works correctly even on millis() rollover
+bool RHGenericDriver::waitAvailableTimeout(uint16_t timeout)
+{
+ _waitTimer.reset();
+ _waitTimer.start();
+
+ while (_waitTimer.read_ms() < timeout)
+ {
+ if (available())
+ {
+ _waitTimer.stop();
+ return true;
+ }
+ Thread::yield();
+ }
+ _waitTimer.stop();
+ return false;
+}
+
+bool RHGenericDriver::waitPacketSent()
+{
+ while (_mode == RHModeTx)
+ Thread::yield(); // Wait for any previous transmit to finish
+ return true;
+}
+
+bool RHGenericDriver::waitPacketSent(uint16_t timeout)
+{
+ _waitTimer.reset();
+ _waitTimer.start();
+ while (_waitTimer.read_ms() < timeout)
+ {
+ if (_mode != RHModeTx) // Any previous transmit finished?
+ {
+ _waitTimer.stop();
+ return true;
+ }
+ Thread::yield();
+ }
+ _waitTimer.stop();
+ return false;
+}
+
+// Wait until no channel activity detected or timeout
+bool RHGenericDriver::waitCAD()
+{
+ if (!_cad_timeout)
+ return true;
+
+ // Wait for any channel activity to finish or timeout
+ // Sophisticated DCF function...
+ // DCF : BackoffTime = random() x aSlotTime
+ // 100 - 1000 ms
+ // 10 sec timeout
+ _waitTimer.reset();
+ _waitTimer.start();
+ while (isChannelActive())
+ {
+ if (_waitTimer.read_ms() > _cad_timeout)
+ {
+ _waitTimer.stop();
+ return false;
+ }
+
+ wait_ms(100);
+ }
+
+ _waitTimer.stop();
+ return true;
+}
+
+// subclasses are expected to override if CAD is available for that radio
+bool RHGenericDriver::isChannelActive()
+{
+ return false;
+}
+
+void RHGenericDriver::setPromiscuous(bool promiscuous)
+{
+ _promiscuous = promiscuous;
+}
+
+void RHGenericDriver::setThisAddress(uint8_t address)
+{
+ _thisAddress = address;
+}
+
+void RHGenericDriver::setHeaderTo(uint8_t to)
+{
+ _txHeaderTo = to;
+}
+
+void RHGenericDriver::setHeaderFrom(uint8_t from)
+{
+ _txHeaderFrom = from;
+}
+
+void RHGenericDriver::setHeaderId(uint8_t id)
+{
+ _txHeaderId = id;
+}
+
+void RHGenericDriver::setHeaderFlags(uint8_t set, uint8_t clear)
+{
+ _txHeaderFlags &= ~clear;
+ _txHeaderFlags |= set;
+}
+
+uint8_t RHGenericDriver::headerTo()
+{
+ return _rxHeaderTo;
+}
+
+uint8_t RHGenericDriver::headerFrom()
+{
+ return _rxHeaderFrom;
+}
+
+uint8_t RHGenericDriver::headerId()
+{
+ return _rxHeaderId;
+}
+
+uint8_t RHGenericDriver::headerFlags()
+{
+ return _rxHeaderFlags;
+}
+
+int8_t RHGenericDriver::lastRssi()
+{
+ return _lastRssi;
+}
+
+RHGenericDriver::RHMode RHGenericDriver::mode()
+{
+ return _mode;
+}
+
+void RHGenericDriver::setMode(RHMode mode)
+{
+ _mode = mode;
+}
+
+bool RHGenericDriver::sleep()
+{
+ return false;
+}
+
+// Diagnostic help
+void RHGenericDriver::printBuffer(const char* prompt, const uint8_t* buf, uint8_t len)
+{
+ uint8_t i;
+
+ printf("%s", prompt);
+ for (i = 0; i < len; i++)
+ {
+ if (i % 16 == 15)
+ printf("0x%x\n", buf[i]);
+ else
+ {
+ printf("0x%x ", buf[i]);
+ }
+ }
+ printf("\n");
+}
+
+uint16_t RHGenericDriver::rxBad()
+{
+ return _rxBad;
+}
+
+uint16_t RHGenericDriver::rxGood()
+{
+ return _rxGood;
+}
+
+uint16_t RHGenericDriver::txGood()
+{
+ return _txGood;
+}
+
+void RHGenericDriver::setCADTimeout(unsigned long cad_timeout)
+{
+ _cad_timeout = cad_timeout;
+}
+
diff -r 000000000000 -r e69d086cb053 RHGenericDriver.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RHGenericDriver.h Sun Jun 11 04:05:05 2017 +0000
@@ -0,0 +1,316 @@
+// RHGenericDriver.h
+// Author: Mike McCauley (mikem@airspayce.com)
+// Copyright (C) 2014 Mike McCauley
+// $Id: RHGenericDriver.h,v 1.19 2017/03/08 09:30:47 mikem Exp mikem $
+//
+// Ported to mbed - support only a single radio - Dan Julio - 5/2017
+//
+
+#ifndef RHGenericDriver_h
+#define RHGenericDriver_h
+
+#include "RadioHead.h"
+#include "mbed.h"
+#include "max32630fthr.h"
+#include <stdint.h>
+
+// Defines bits of the FLAGS header reserved for use by the RadioHead library and
+// the flags available for use by applications
+#define RH_FLAGS_RESERVED 0xf0
+#define RH_FLAGS_APPLICATION_SPECIFIC 0x0f
+#define RH_FLAGS_NONE 0
+
+// Default timeout for waitCAD() in ms
+#define RH_CAD_DEFAULT_TIMEOUT 10000
+
+/////////////////////////////////////////////////////////////////////
+/// \class RHGenericDriver RHGenericDriver.h <RHGenericDriver.h>
+/// \brief Abstract base class for a RadioHead driver.
+///
+/// This class defines the functions that must be provided by any RadioHead driver.
+/// Different types of driver will implement all the abstract functions, and will perhaps override
+/// other functions in this subclass, or perhaps add new functions specifically required by that driver.
+/// Do not directly instantiate this class: it is only to be subclassed by driver classes.
+///
+/// Subclasses are expected to implement a half-duplex, unreliable, error checked, unaddressed packet transport.
+/// They are expected to carry a message payload with an appropriate maximum length for the transport hardware
+/// and to also carry unaltered 4 message headers: TO, FROM, ID, FLAGS
+///
+/// \par Headers
+///
+/// Each message sent and received by a RadioHead driver includes 4 headers:
+/// -TO The node address that the message is being sent to (broadcast RH_BROADCAST_ADDRESS (255) is permitted)
+/// -FROM The node address of the sending node
+/// -ID A message ID, distinct (over short time scales) for each message sent by a particilar node
+/// -FLAGS A bitmask of flags. The most significant 4 bits are reserved for use by RadioHead. The least
+/// significant 4 bits are reserved for applications.
+class RHGenericDriver
+{
+public:
+ /// \brief Defines different operating modes for the transport hardware
+ ///
+ /// These are the different values that can be adopted by the _mode variable and
+ /// returned by the mode() member function,
+ typedef enum
+ {
+ RHModeInitialising = 0, ///< Transport is initialising. Initial default value until init() is called..
+ RHModeSleep, ///< Transport hardware is in low power sleep mode (if supported)
+ RHModeIdle, ///< Transport is idle.
+ RHModeTx, ///< Transport is in the process of transmitting a message.
+ RHModeRx, ///< Transport is in the process of receiving a message.
+ RHModeCad ///< Transport is in the process of detecting channel activity (if supported)
+ } RHMode;
+
+ /// Constructor
+ RHGenericDriver();
+
+ /// Initialise the Driver transport hardware and software.
+ /// Make sure the Driver is properly configured before calling init().
+ /// \return true if initialisation succeeded.
+ virtual bool init();
+
+ /// Tests whether a new message is available
+ /// from the Driver.
+ /// On most drivers, if there is an uncollected received message, and there is no message
+ /// currently bing transmitted, this will also put the Driver into RHModeRx mode until
+ /// a message is actually received by the transport, when it will be returned to RHModeIdle.
+ /// This can be called multiple times in a timeout loop.
+ /// \return true if a new, complete, error-free uncollected message is available to be retreived by recv().
+ virtual bool available() = 0;
+
+ /// Turns the receiver on if it not already on.
+ /// If there is a valid message available, copy it to buf and return true
+ /// else return false.
+ /// If a message is copied, *len is set to the length (Caution, 0 length messages are permitted).
+ /// You should be sure to call this function frequently enough to not miss any messages
+ /// It is recommended that you call it in your main loop.
+ /// \param[in] buf Location to copy the received message
+ /// \param[in,out] len Pointer to available space in buf. Set to the actual number of octets copied.
+ /// \return true if a valid message was copied to buf
+ virtual bool recv(uint8_t* buf, uint8_t* len) = 0;
+
+ /// Waits until any previous transmit packet is finished being transmitted with waitPacketSent().
+ /// Then optionally waits for Channel Activity Detection (CAD)
+ /// to show the channnel is clear (if the radio supports CAD) by calling waitCAD().
+ /// Then loads a message into the transmitter and starts the transmitter. Note that a message length
+ /// of 0 is NOT permitted. If the message is too long for the underlying radio technology, send() will
+ /// return false and will not send the message.
+ /// \param[in] data Array of data to be sent
+ /// \param[in] len Number of bytes of data to send (> 0)
+ /// specify the maximum time in ms to wait. If 0 (the default) do not wait for CAD before transmitting.
+ /// \return true if the message length was valid and it was correctly queued for transmit. Return false
+ /// if CAD was requested and the CAD timeout timed out before clear channel was detected.
+ virtual bool send(const uint8_t* data, uint8_t len) = 0;
+
+ /// Returns the maximum message length
+ /// available in this Driver.
+ /// \return The maximum legal message length
+ virtual uint8_t maxMessageLength() = 0;
+
+ /// Starts the receiver and blocks until a valid received
+ /// message is available.
+ virtual void waitAvailable();
+
+ /// Blocks until the transmitter
+ /// is no longer transmitting.
+ virtual bool waitPacketSent();
+
+ /// Blocks until the transmitter is no longer transmitting.
+ /// or until the timeout occuers, whichever happens first
+ /// \param[in] timeout Maximum time to wait in milliseconds.
+ /// \return true if the radio completed transmission within the timeout period. False if it timed out.
+ virtual bool waitPacketSent(uint16_t timeout);
+
+ /// Starts the receiver and blocks until a received message is available or a timeout
+ /// \param[in] timeout Maximum time to wait in milliseconds.
+ /// \return true if a message is available
+ virtual bool waitAvailableTimeout(uint16_t timeout);
+
+ // Bent G Christensen (bentor@gmail.com), 08/15/2016
+ /// Channel Activity Detection (CAD).
+ /// Blocks until channel activity is finished or CAD timeout occurs.
+ /// Uses the radio's CAD function (if supported) to detect channel activity.
+ /// Implements random delays of 100 to 1000ms while activity is detected and until timeout.
+ /// Caution: the random() function is not seeded. If you want non-deterministic behaviour, consider
+ /// using something like randomSeed(analogRead(A0)); in your sketch.
+ /// Permits the implementation of listen-before-talk mechanism (Collision Avoidance).
+ /// Calls the isChannelActive() member function for the radio (if supported)
+ /// to determine if the channel is active. If the radio does not support isChannelActive(),
+ /// always returns true immediately
+ /// \return true if the radio-specific CAD (as returned by isChannelActive())
+ /// shows the channel is clear within the timeout period (or the timeout period is 0), else returns false.
+ virtual bool waitCAD();
+
+ /// Sets the Channel Activity Detection timeout in milliseconds to be used by waitCAD().
+ /// The default is 0, which means do not wait for CAD detection.
+ /// CAD detection depends on support for isChannelActive() by your particular radio.
+ void setCADTimeout(unsigned long cad_timeout);
+
+ /// Determine if the currently selected radio channel is active.
+ /// This is expected to be subclassed by specific radios to implement their Channel Activity Detection
+ /// if supported. If the radio does not support CAD, returns true immediately. If a RadioHead radio
+ /// supports isChannelActive() it will be documented in the radio specific documentation.
+ /// This is called automatically by waitCAD().
+ /// \return true if the radio-specific CAD (as returned by override of isChannelActive()) shows the
+ /// current radio channel as active, else false. If there is no radio-specific CAD, returns false.
+ virtual bool isChannelActive();
+
+ /// Sets the address of this node. Defaults to 0xFF. Subclasses or the user may want to change this.
+ /// This will be used to test the adddress in incoming messages. In non-promiscuous mode,
+ /// only messages with a TO header the same as thisAddress or the broadcast addess (0xFF) will be accepted.
+ /// In promiscuous mode, all messages will be accepted regardless of the TO header.
+ /// In a conventional multinode system, all nodes will have a unique address
+ /// (which you could store in EEPROM).
+ /// You would normally set the header FROM address to be the same as thisAddress (though you dont have to,
+ /// allowing the possibilty of address spoofing).
+ /// \param[in] thisAddress The address of this node.
+ virtual void setThisAddress(uint8_t thisAddress);
+
+ /// Sets the TO header to be sent in all subsequent messages
+ /// \param[in] to The new TO header value
+ virtual void setHeaderTo(uint8_t to);
+
+ /// Sets the FROM header to be sent in all subsequent messages
+ /// \param[in] from The new FROM header value
+ virtual void setHeaderFrom(uint8_t from);
+
+ /// Sets the ID header to be sent in all subsequent messages
+ /// \param[in] id The new ID header value
+ virtual void setHeaderId(uint8_t id);
+
+ /// Sets and clears bits in the FLAGS header to be sent in all subsequent messages
+ /// First it clears he FLAGS according to the clear argument, then sets the flags according to the
+ /// set argument. The default for clear always clears the application specific flags.
+ /// \param[in] set bitmask of bits to be set. Flags are cleared with the clear mask before being set.
+ /// \param[in] clear bitmask of flags to clear. Defaults to RH_FLAGS_APPLICATION_SPECIFIC
+ /// which clears the application specific flags, resulting in new application specific flags
+ /// identical to the set.
+ virtual void setHeaderFlags(uint8_t set, uint8_t clear = RH_FLAGS_APPLICATION_SPECIFIC);
+
+ /// Tells the receiver to accept messages with any TO address, not just messages
+ /// addressed to thisAddress or the broadcast address
+ /// \param[in] promiscuous true if you wish to receive messages with any TO address
+ virtual void setPromiscuous(bool promiscuous);
+
+ /// Returns the TO header of the last received message
+ /// \return The TO header
+ virtual uint8_t headerTo();
+
+ /// Returns the FROM header of the last received message
+ /// \return The FROM header
+ virtual uint8_t headerFrom();
+
+ /// Returns the ID header of the last received message
+ /// \return The ID header
+ virtual uint8_t headerId();
+
+ /// Returns the FLAGS header of the last received message
+ /// \return The FLAGS header
+ virtual uint8_t headerFlags();
+
+ /// Returns the most recent RSSI (Receiver Signal Strength Indicator).
+ /// Usually it is the RSSI of the last received message, which is measured when the preamble is received.
+ /// If you called readRssi() more recently, it will return that more recent value.
+ /// \return The most recent RSSI measurement in dBm.
+ int8_t lastRssi();
+
+ /// Returns the operating mode of the library.
+ /// \return the current mode, one of RF69_MODE_*
+ RHMode mode();
+
+ /// Sets the operating mode of the transport.
+ void setMode(RHMode mode);
+
+ /// Sets the transport hardware into low-power sleep mode
+ /// (if supported). May be overridden by specific drivers to initialte sleep mode.
+ /// If successful, the transport will stay in sleep mode until woken by
+ /// changing mode it idle, transmit or receive (eg by calling send(), recv(), available() etc)
+ /// \return true if sleep mode is supported by transport hardware and the RadioHead driver, and if sleep mode
+ /// was successfully entered. If sleep mode is not suported, return false.
+ virtual bool sleep();
+
+ /// Prints a data buffer in HEX.
+ /// For diagnostic use
+ /// \param[in] prompt string to preface the print
+ /// \param[in] buf Location of the buffer to print
+ /// \param[in] len Length of the buffer in octets.
+ static void printBuffer(const char* prompt, const uint8_t* buf, uint8_t len);
+
+ /// Returns the count of the number of bad received packets (ie packets with bad lengths, checksum etc)
+ /// which were rejected and not delivered to the application.
+ /// Caution: not all drivers can correctly report this count. Some underlying hardware only report
+ /// good packets.
+ /// \return The number of bad packets received.
+ uint16_t rxBad();
+
+ /// Returns the count of the number of
+ /// good received packets
+ /// \return The number of good packets received.
+ uint16_t rxGood();
+
+ /// Returns the count of the number of
+ /// packets successfully transmitted (though not necessarily received by the destination)
+ /// \return The number of packets successfully transmitted
+ uint16_t txGood();
+
+protected:
+
+ /// The current transport operating mode
+ volatile RHMode _mode;
+
+ /// This node id
+ uint8_t _thisAddress;
+
+ /// Whether the transport is in promiscuous mode
+ bool _promiscuous;
+
+ /// TO header in the last received mesasge
+ volatile uint8_t _rxHeaderTo;
+
+ /// FROM header in the last received mesasge
+ volatile uint8_t _rxHeaderFrom;
+
+ /// ID header in the last received mesasge
+ volatile uint8_t _rxHeaderId;
+
+ /// FLAGS header in the last received mesasge
+ volatile uint8_t _rxHeaderFlags;
+
+ /// TO header to send in all messages
+ uint8_t _txHeaderTo;
+
+ /// FROM header to send in all messages
+ uint8_t _txHeaderFrom;
+
+ /// ID header to send in all messages
+ uint8_t _txHeaderId;
+
+ /// FLAGS header to send in all messages
+ uint8_t _txHeaderFlags;
+
+ /// The value of the last received RSSI value, in some transport specific units
+ volatile int8_t _lastRssi;
+
+ /// Count of the number of bad messages (eg bad checksum etc) received
+ volatile uint16_t _rxBad;
+
+ /// Count of the number of successfully transmitted messaged
+ volatile uint16_t _rxGood;
+
+ /// Count of the number of bad messages (correct checksum etc) received
+ volatile uint16_t _txGood;
+
+ /// Channel activity detected
+ volatile bool _cad;
+
+ /// Channel activity timeout in ms
+ unsigned int _cad_timeout;
+
+private:
+
+ Timer _waitTimer;
+
+};
+
+
+#endif
diff -r 000000000000 -r e69d086cb053 RH_RF95.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RH_RF95.cpp Sun Jun 11 04:05:05 2017 +0000
@@ -0,0 +1,399 @@
+// RH_RF95.cpp
+//
+// Copyright (C) 2011 Mike McCauley
+// $Id: RH_RF95.cpp,v 1.14 2017/03/04 00:59:41 mikem Exp $
+//
+// Ported to mbed - support only a single radio - Dan Julio - 5/2017
+//
+
+#include <RH_RF95.h>
+
+// These are indexed by the values of ModemConfigChoice
+// Stored in flash (program) memory to save SRAM
+static const RH_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
+
+};
+
+RH_RF95::RH_RF95(swspi& spi, int ssNum)
+ :
+ _spi(spi),
+ _ssn(ssNum),
+ _rxBufValid(0)
+{
+}
+
+bool RH_RF95::init()
+{
+ // Set sleep mode, so we can also set LORA mode:
+ _spi.spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE, 0, _ssn);
+ wait_ms(10); // Wait for sleep mode to take over from say, CAD
+ // Check we are in sleep mode, with LORA set
+ if (_spi.spiRead(RH_RF95_REG_01_OP_MODE, 0, _ssn) != (RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE))
+ {
+// printf("REG_01_OP_MODE: 0x%2x\n", _spi.spiRead(RH_RF95_REG_01_OP_MODE, 0, _ssn));
+ return false; // No device present?
+ }
+
+ // 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
+ _spi.spiWrite(RH_RF95_REG_0E_FIFO_TX_BASE_ADDR, 0, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_0F_FIFO_RX_BASE_ADDR, 0, 0, _ssn);
+
+ // 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(434.0);
+ // Lowish power
+ setTxPower(13);
+
+ return true;
+}
+
+// C++ level interrupt handler for this instance
+// LORA is unusual in that it has several interrupt lines, and not a single, combined one.
+// 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 RH_RF95::handleInterrupt()
+{
+ // Read the interrupt register
+ uint8_t irq_flags = _spi.spiRead(RH_RF95_REG_12_IRQ_FLAGS, 0, _ssn);
+ if (_mode == RHModeRx && irq_flags & (RH_RF95_RX_TIMEOUT | RH_RF95_PAYLOAD_CRC_ERROR))
+ {
+ _rxBad++;
+ }
+ else if (_mode == RHModeRx && irq_flags & RH_RF95_RX_DONE)
+ {
+ // Have received a packet
+ uint8_t len = _spi.spiRead(RH_RF95_REG_13_RX_NB_BYTES, 0, _ssn);
+
+ // Reset the fifo read ptr to the beginning of the packet
+ _spi.spiWrite(RH_RF95_REG_0D_FIFO_ADDR_PTR, _spi.spiRead(RH_RF95_REG_10_FIFO_RX_CURRENT_ADDR, 0, _ssn), 0, _ssn);
+ _spi.spiBurstRead(RH_RF95_REG_00_FIFO, _buf, len, 0, _ssn);
+ _bufLen = len;
+ _spi.spiWrite(RH_RF95_REG_12_IRQ_FLAGS, 0xff, 0, _ssn); // Clear all IRQ flags
+
+ // Remember the last signal to noise ratio, LORA mode
+ // Per page 111, SX1276/77/78/79 datasheet
+ _lastSNR = (int8_t)_spi.spiRead(RH_RF95_REG_19_PKT_SNR_VALUE, 0, _ssn) / 4;
+
+ // Remember the RSSI of this packet, LORA mode
+ // this is according to the doc, but is it really correct?
+ // weakest receiveable signals are reported RSSI at about -66
+ _lastRssi = _spi.spiRead(RH_RF95_REG_1A_PKT_RSSI_VALUE, 0, _ssn);
+ // Adjust the RSSI, datasheet page 87
+ if (_lastSNR < 0)
+ _lastRssi = _lastRssi + _lastSNR;
+ else
+ _lastRssi = (int)_lastRssi * 16 / 15;
+ if (_usingHFport)
+ _lastRssi -= 157;
+ else
+ _lastRssi -= 164;
+
+ // We have received a message.
+ validateRxBuf();
+ if (_rxBufValid)
+ setModeIdle(); // Got one
+ }
+ else if (_mode == RHModeTx && irq_flags & RH_RF95_TX_DONE)
+ {
+ _txGood++;
+ setModeIdle();
+ }
+ else if (_mode == RHModeCad && irq_flags & RH_RF95_CAD_DONE)
+ {
+ _cad = irq_flags & RH_RF95_CAD_DETECTED;
+ setModeIdle();
+ }
+
+ _spi.spiWrite(RH_RF95_REG_12_IRQ_FLAGS, 0xff, 0, _ssn); // Clear all IRQ flags
+}
+
+// Check whether the latest received message is complete and uncorrupted
+void RH_RF95::validateRxBuf()
+{
+ if (_bufLen < 4)
+ return; // Too short to be a real message
+
+ // Extract the 4 headers
+ _rxHeaderTo = _buf[0];
+ _rxHeaderFrom = _buf[1];
+ _rxHeaderId = _buf[2];
+ _rxHeaderFlags = _buf[3];
+ if (_promiscuous ||
+ _rxHeaderTo == _thisAddress ||
+ _rxHeaderTo == RH_BROADCAST_ADDRESS)
+ {
+ _rxGood++;
+ _rxBufValid = true;
+ }
+}
+
+bool RH_RF95::available()
+{
+ if (_mode == RHModeTx)
+ return false;
+
+ setModeRx();
+ return _rxBufValid; // Will be set by the interrupt handler when a good message is received
+}
+
+void RH_RF95::clearRxBuf()
+{
+ _rxBufValid = false;
+ _bufLen = 0;
+}
+
+bool RH_RF95::recv(uint8_t* buf, uint8_t* len)
+{
+ if (!available())
+ return false;
+
+ if (buf && len)
+ {
+ // Skip the 4 headers that are at the beginning of the rxBuf
+ if (*len > _bufLen-RH_RF95_HEADER_LEN)
+ *len = _bufLen-RH_RF95_HEADER_LEN;
+ memcpy(buf, _buf+RH_RF95_HEADER_LEN, *len);
+ }
+ clearRxBuf(); // This message accepted and cleared
+ return true;
+}
+
+bool RH_RF95::send(const uint8_t* data, uint8_t len)
+{
+ if (len > RH_RF95_MAX_MESSAGE_LEN)
+ return false;
+
+ waitPacketSent(); // Make sure we dont interrupt an outgoing message
+ setModeIdle();
+
+ if (!waitCAD())
+ return false; // Check channel activity
+
+ // Position at the beginning of the FIFO
+ _spi.spiWrite(RH_RF95_REG_0D_FIFO_ADDR_PTR, 0, 0, _ssn);
+ // The headers
+ _spi.spiWrite(RH_RF95_REG_00_FIFO, _txHeaderTo, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_00_FIFO, _txHeaderFrom, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_00_FIFO, _txHeaderId, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_00_FIFO, _txHeaderFlags, 0, _ssn);
+ // The message data
+ _spi.spiBurstWrite(RH_RF95_REG_00_FIFO, data, len, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_22_PAYLOAD_LENGTH, len + RH_RF95_HEADER_LEN, 0, _ssn);
+
+ setModeTx(); // Start the transmitter
+ // when Tx is done, interruptHandler will fire and radio mode will return to STANDBY
+ return true;
+}
+
+bool RH_RF95::printRegisters()
+{
+ 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};
+
+ uint8_t i;
+ for (i = 0; i < sizeof(registers); i++)
+ {
+ printf("0x%x: 0x%x\n\r", registers[i], _spi.spiRead(registers[i], 0, _ssn));
+ }
+ return true;
+}
+
+uint8_t RH_RF95::maxMessageLength()
+{
+ return RH_RF95_MAX_MESSAGE_LEN;
+}
+
+bool RH_RF95::setFrequency(float centre)
+{
+ // Frf = FRF / FSTEP
+ uint32_t frf = (centre * 1000000.0f) / RH_RF95_FSTEP;
+ _spi.spiWrite(RH_RF95_REG_06_FRF_MSB, (frf >> 16) & 0xff, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_07_FRF_MID, (frf >> 8) & 0xff, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_08_FRF_LSB, frf & 0xff, 0, _ssn);
+ _usingHFport = (centre >= 779.0f);
+
+ return true;
+}
+
+void RH_RF95::setModeIdle()
+{
+ if (_mode != RHModeIdle)
+ {
+ _spi.spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_STDBY, 0, _ssn);
+ _mode = RHModeIdle;
+ }
+}
+
+bool RH_RF95::sleep()
+{
+ if (_mode != RHModeSleep)
+ {
+ _spi.spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_SLEEP, 0, _ssn);
+ _mode = RHModeSleep;
+ }
+ return true;
+}
+
+void RH_RF95::setModeRx()
+{
+ if (_mode != RHModeRx)
+ {
+ _spi.spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_RXCONTINUOUS, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_40_DIO_MAPPING1, 0x00, 0, _ssn); // Interrupt on RxDone
+ _mode = RHModeRx;
+ }
+}
+
+void RH_RF95::setModeTx()
+{
+ if (_mode != RHModeTx)
+ {
+ _spi.spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_TX, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_40_DIO_MAPPING1, 0x40, 0, _ssn); // Interrupt on TxDone
+ _mode = RHModeTx;
+ }
+}
+
+void RH_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 > 14)
+ power = 14;
+ if (power < -1)
+ power = -1;
+ _spi.spiWrite(RH_RF95_REG_09_PA_CONFIG, RH_RF95_MAX_POWER | (power + 1), 0, _ssn);
+ }
+ else
+ {
+ if (power > 23)
+ power = 23;
+ if (power < 5)
+ power = 5;
+
+ // For RH_RF95_PA_DAC_ENABLE, manual says '+20dBm on PA_BOOST when OutputPower=0xf'
+ // RH_RF95_PA_DAC_ENABLE actually adds about 3dBm to all power levels. We will us it
+ // for 21, 22 and 23dBm
+ if (power > 20)
+ {
+ _spi.spiWrite(RH_RF95_REG_4D_PA_DAC, RH_RF95_PA_DAC_ENABLE, 0, _ssn);
+ power -= 3;
+ }
+ else
+ {
+ _spi.spiWrite(RH_RF95_REG_4D_PA_DAC, RH_RF95_PA_DAC_DISABLE, 0, _ssn);
+ }
+
+ // 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
+ _spi.spiWrite(RH_RF95_REG_09_PA_CONFIG, RH_RF95_PA_SELECT | (power-5), 0, _ssn);
+ }
+}
+
+// Sets registers from a canned modem configuration structure
+void RH_RF95::setModemRegisters(const ModemConfig* config)
+{
+ _spi.spiWrite(RH_RF95_REG_1D_MODEM_CONFIG1, config->reg_1d, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_1E_MODEM_CONFIG2, config->reg_1e, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_26_MODEM_CONFIG3, config->reg_26, 0, _ssn);
+}
+
+// Set one of the canned FSK Modem configs
+// Returns true if its a valid choice
+bool RH_RF95::setModemConfig(ModemConfigChoice index)
+{
+ if (index > (signed int)(sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig)))
+ return false;
+
+ ModemConfig cfg;
+ memcpy(&cfg, &MODEM_CONFIG_TABLE[index], sizeof(RH_RF95::ModemConfig));
+ setModemRegisters(&cfg);
+
+ return true;
+}
+
+void RH_RF95::setPreambleLength(uint16_t bytes)
+{
+ _spi.spiWrite(RH_RF95_REG_20_PREAMBLE_MSB, bytes >> 8, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_21_PREAMBLE_LSB, bytes & 0xff, 0, _ssn);
+}
+
+bool RH_RF95::isChannelActive()
+{
+ // Set mode RHModeCad
+ if (_mode != RHModeCad)
+ {
+ _spi.spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_CAD, 0, _ssn);
+ _spi.spiWrite(RH_RF95_REG_40_DIO_MAPPING1, 0x80, 0, _ssn); // Interrupt on CadDone
+ _mode = RHModeCad;
+ }
+
+ while (_mode == RHModeCad)
+ Thread::yield();
+
+ return _cad;
+}
+
+void RH_RF95::enableTCXO()
+{
+ while ((_spi.spiRead(RH_RF95_REG_4B_TCXO, 0, _ssn) & RH_RF95_TCXO_TCXO_INPUT_ON) != RH_RF95_TCXO_TCXO_INPUT_ON)
+ {
+ sleep();
+ _spi.spiWrite(RH_RF95_REG_4B_TCXO, (_spi.spiRead(RH_RF95_REG_4B_TCXO, 0, _ssn) | RH_RF95_TCXO_TCXO_INPUT_ON), 0, _ssn);
+ }
+}
+
+// From section 4.1.5 of SX1276/77/78/79
+// Ferror = FreqError * 2**24 * BW / Fxtal / 500
+int RH_RF95::frequencyError()
+{
+ int32_t freqerror = 0;
+
+ // Convert 2.5 bytes (5 nibbles, 20 bits) to 32 bit signed int
+ freqerror = _spi.spiRead(RH_RF95_REG_28_FEI_MSB, 0, _ssn) << 16;
+ freqerror |= _spi.spiRead(RH_RF95_REG_29_FEI_MID, 0, _ssn) << 8;
+ freqerror |= _spi.spiRead(RH_RF95_REG_2A_FEI_LSB, 0, _ssn);
+ // Sign extension into top 3 nibbles
+ if (freqerror & 0x80000)
+ freqerror |= 0xfff00000;
+
+ int error = 0; // In hertz
+ float bw_tab[] = {7.8, 10.4, 15.6, 20.8, 31.25, 41.7, 62.5, 125, 250, 500};
+ uint8_t bwindex = _spi.spiRead(RH_RF95_REG_1D_MODEM_CONFIG1, 0, _ssn) >> 4;
+ if (bwindex < (sizeof(bw_tab) / sizeof(float)))
+ error = (float)freqerror * bw_tab[bwindex] * ((float)(1L << 24) / (float)RH_RF95_FXOSC / 500.0f);
+ // else not defined
+
+ return error;
+}
+
+int RH_RF95::lastSNR()
+{
+ return _lastSNR;
+}
diff -r 000000000000 -r e69d086cb053 RH_RF95.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RH_RF95.h Sun Jun 11 04:05:05 2017 +0000
@@ -0,0 +1,792 @@
+// RH_RF95.h
+//
+// Definitions for HopeRF LoRa radios per:
+// http://www.hoperf.com/upload/rf/RFM95_96_97_98W.pdf
+// http://www.hoperf.cn/upload/rfchip/RF96_97_98.pdf
+//
+// Author: Mike McCauley (mikem@airspayce.com)
+// Copyright (C) 2014 Mike McCauley
+// $Id: RH_RF95.h,v 1.16 2017/03/04 00:59:41 mikem Exp $
+//
+// Ported to mbed - support only a single radio - Dan Julio - 5/2017
+//
+
+#ifndef RH_RF95_h
+#define RH_RF95_h
+
+#include <RHGenericDriver.h>
+#include "swspi.h"
+
+// Max number of octets the LORA Rx/Tx FIFO can hold
+#define RH_RF95_FIFO_SIZE 255
+
+// This is the maximum number of bytes that can be carried by the LORA.
+// We use some for headers, keeping fewer for RadioHead messages
+#define RH_RF95_MAX_PAYLOAD_LEN RH_RF95_FIFO_SIZE
+
+// The length of the headers we add.
+// The headers are inside the LORA's payload
+#define RH_RF95_HEADER_LEN 4
+
+// This is the maximum message length that can be supported by this driver.
+// Can be pre-defined to a smaller size (to save SRAM) prior to including this header
+// Here we allow for 1 byte message length, 4 bytes headers, user data and 2 bytes of FCS
+#ifndef RH_RF95_MAX_MESSAGE_LEN
+ #define RH_RF95_MAX_MESSAGE_LEN (RH_RF95_MAX_PAYLOAD_LEN - RH_RF95_HEADER_LEN)
+#endif
+
+// The crystal oscillator frequency of the module
+#define RH_RF95_FXOSC 32000000.0
+
+// The Frequency Synthesizer step = RH_RF95_FXOSC / 2^^19
+#define RH_RF95_FSTEP (RH_RF95_FXOSC / 524288)
+
+
+// Register names (LoRa Mode, from table 85)
+#define RH_RF95_REG_00_FIFO 0x00
+#define RH_RF95_REG_01_OP_MODE 0x01
+#define RH_RF95_REG_02_RESERVED 0x02
+#define RH_RF95_REG_03_RESERVED 0x03
+#define RH_RF95_REG_04_RESERVED 0x04
+#define RH_RF95_REG_05_RESERVED 0x05
+#define RH_RF95_REG_06_FRF_MSB 0x06
+#define RH_RF95_REG_07_FRF_MID 0x07
+#define RH_RF95_REG_08_FRF_LSB 0x08
+#define RH_RF95_REG_09_PA_CONFIG 0x09
+#define RH_RF95_REG_0A_PA_RAMP 0x0a
+#define RH_RF95_REG_0B_OCP 0x0b
+#define RH_RF95_REG_0C_LNA 0x0c
+#define RH_RF95_REG_0D_FIFO_ADDR_PTR 0x0d
+#define RH_RF95_REG_0E_FIFO_TX_BASE_ADDR 0x0e
+#define RH_RF95_REG_0F_FIFO_RX_BASE_ADDR 0x0f
+#define RH_RF95_REG_10_FIFO_RX_CURRENT_ADDR 0x10
+#define RH_RF95_REG_11_IRQ_FLAGS_MASK 0x11
+#define RH_RF95_REG_12_IRQ_FLAGS 0x12
+#define RH_RF95_REG_13_RX_NB_BYTES 0x13
+#define RH_RF95_REG_14_RX_HEADER_CNT_VALUE_MSB 0x14
+#define RH_RF95_REG_15_RX_HEADER_CNT_VALUE_LSB 0x15
+#define RH_RF95_REG_16_RX_PACKET_CNT_VALUE_MSB 0x16
+#define RH_RF95_REG_17_RX_PACKET_CNT_VALUE_LSB 0x17
+#define RH_RF95_REG_18_MODEM_STAT 0x18
+#define RH_RF95_REG_19_PKT_SNR_VALUE 0x19
+#define RH_RF95_REG_1A_PKT_RSSI_VALUE 0x1a
+#define RH_RF95_REG_1B_RSSI_VALUE 0x1b
+#define RH_RF95_REG_1C_HOP_CHANNEL 0x1c
+#define RH_RF95_REG_1D_MODEM_CONFIG1 0x1d
+#define RH_RF95_REG_1E_MODEM_CONFIG2 0x1e
+#define RH_RF95_REG_1F_SYMB_TIMEOUT_LSB 0x1f
+#define RH_RF95_REG_20_PREAMBLE_MSB 0x20
+#define RH_RF95_REG_21_PREAMBLE_LSB 0x21
+#define RH_RF95_REG_22_PAYLOAD_LENGTH 0x22
+#define RH_RF95_REG_23_MAX_PAYLOAD_LENGTH 0x23
+#define RH_RF95_REG_24_HOP_PERIOD 0x24
+#define RH_RF95_REG_25_FIFO_RX_BYTE_ADDR 0x25
+#define RH_RF95_REG_26_MODEM_CONFIG3 0x26
+
+#define RH_RF95_REG_27_PPM_CORRECTION 0x27
+#define RH_RF95_REG_28_FEI_MSB 0x28
+#define RH_RF95_REG_29_FEI_MID 0x29
+#define RH_RF95_REG_2A_FEI_LSB 0x2a
+#define RH_RF95_REG_2C_RSSI_WIDEBAND 0x2c
+#define RH_RF95_REG_31_DETECT_OPTIMIZ 0x31
+#define RH_RF95_REG_33_INVERT_IQ 0x33
+#define RH_RF95_REG_37_DETECTION_THRESHOLD 0x37
+#define RH_RF95_REG_39_SYNC_WORD 0x39
+
+#define RH_RF95_REG_40_DIO_MAPPING1 0x40
+#define RH_RF95_REG_41_DIO_MAPPING2 0x41
+#define RH_RF95_REG_42_VERSION 0x42
+
+#define RH_RF95_REG_4B_TCXO 0x4b
+#define RH_RF95_REG_4D_PA_DAC 0x4d
+#define RH_RF95_REG_5B_FORMER_TEMP 0x5b
+#define RH_RF95_REG_61_AGC_REF 0x61
+#define RH_RF95_REG_62_AGC_THRESH1 0x62
+#define RH_RF95_REG_63_AGC_THRESH2 0x63
+#define RH_RF95_REG_64_AGC_THRESH3 0x64
+
+// RH_RF95_REG_01_OP_MODE 0x01
+#define RH_RF95_LONG_RANGE_MODE 0x80
+#define RH_RF95_ACCESS_SHARED_REG 0x40
+#define RH_RF95_LOW_FREQUENCY_MODE 0x08
+#define RH_RF95_MODE 0x07
+#define RH_RF95_MODE_SLEEP 0x00
+#define RH_RF95_MODE_STDBY 0x01
+#define RH_RF95_MODE_FSTX 0x02
+#define RH_RF95_MODE_TX 0x03
+#define RH_RF95_MODE_FSRX 0x04
+#define RH_RF95_MODE_RXCONTINUOUS 0x05
+#define RH_RF95_MODE_RXSINGLE 0x06
+#define RH_RF95_MODE_CAD 0x07
+
+// RH_RF95_REG_09_PA_CONFIG 0x09
+#define RH_RF95_PA_SELECT 0x80
+#define RH_RF95_MAX_POWER 0x70
+#define RH_RF95_OUTPUT_POWER 0x0f
+
+// RH_RF95_REG_0A_PA_RAMP 0x0a
+#define RH_RF95_LOW_PN_TX_PLL_OFF 0x10
+#define RH_RF95_PA_RAMP 0x0f
+#define RH_RF95_PA_RAMP_3_4MS 0x00
+#define RH_RF95_PA_RAMP_2MS 0x01
+#define RH_RF95_PA_RAMP_1MS 0x02
+#define RH_RF95_PA_RAMP_500US 0x03
+#define RH_RF95_PA_RAMP_250US 0x0
+#define RH_RF95_PA_RAMP_125US 0x05
+#define RH_RF95_PA_RAMP_100US 0x06
+#define RH_RF95_PA_RAMP_62US 0x07
+#define RH_RF95_PA_RAMP_50US 0x08
+#define RH_RF95_PA_RAMP_40US 0x09
+#define RH_RF95_PA_RAMP_31US 0x0a
+#define RH_RF95_PA_RAMP_25US 0x0b
+#define RH_RF95_PA_RAMP_20US 0x0c
+#define RH_RF95_PA_RAMP_15US 0x0d
+#define RH_RF95_PA_RAMP_12US 0x0e
+#define RH_RF95_PA_RAMP_10US 0x0f
+
+// RH_RF95_REG_0B_OCP 0x0b
+#define RH_RF95_OCP_ON 0x20
+#define RH_RF95_OCP_TRIM 0x1f
+
+// RH_RF95_REG_0C_LNA 0x0c
+#define RH_RF95_LNA_GAIN 0xe0
+#define RH_RF95_LNA_GAIN_G1 0x20
+#define RH_RF95_LNA_GAIN_G2 0x40
+#define RH_RF95_LNA_GAIN_G3 0x60
+#define RH_RF95_LNA_GAIN_G4 0x80
+#define RH_RF95_LNA_GAIN_G5 0xa0
+#define RH_RF95_LNA_GAIN_G6 0xc0
+#define RH_RF95_LNA_BOOST_LF 0x18
+#define RH_RF95_LNA_BOOST_LF_DEFAULT 0x00
+#define RH_RF95_LNA_BOOST_HF 0x03
+#define RH_RF95_LNA_BOOST_HF_DEFAULT 0x00
+#define RH_RF95_LNA_BOOST_HF_150PC 0x11
+
+// RH_RF95_REG_11_IRQ_FLAGS_MASK 0x11
+#define RH_RF95_RX_TIMEOUT_MASK 0x80
+#define RH_RF95_RX_DONE_MASK 0x40
+#define RH_RF95_PAYLOAD_CRC_ERROR_MASK 0x20
+#define RH_RF95_VALID_HEADER_MASK 0x10
+#define RH_RF95_TX_DONE_MASK 0x08
+#define RH_RF95_CAD_DONE_MASK 0x04
+#define RH_RF95_FHSS_CHANGE_CHANNEL_MASK 0x02
+#define RH_RF95_CAD_DETECTED_MASK 0x01
+
+// RH_RF95_REG_12_IRQ_FLAGS 0x12
+#define RH_RF95_RX_TIMEOUT 0x80
+#define RH_RF95_RX_DONE 0x40
+#define RH_RF95_PAYLOAD_CRC_ERROR 0x20
+#define RH_RF95_VALID_HEADER 0x10
+#define RH_RF95_TX_DONE 0x08
+#define RH_RF95_CAD_DONE 0x04
+#define RH_RF95_FHSS_CHANGE_CHANNEL 0x02
+#define RH_RF95_CAD_DETECTED 0x01
+
+// RH_RF95_REG_18_MODEM_STAT 0x18
+#define RH_RF95_RX_CODING_RATE 0xe0
+#define RH_RF95_MODEM_STATUS_CLEAR 0x10
+#define RH_RF95_MODEM_STATUS_HEADER_INFO_VALID 0x08
+#define RH_RF95_MODEM_STATUS_RX_ONGOING 0x04
+#define RH_RF95_MODEM_STATUS_SIGNAL_SYNCHRONIZED 0x02
+#define RH_RF95_MODEM_STATUS_SIGNAL_DETECTED 0x01
+
+// RH_RF95_REG_1C_HOP_CHANNEL 0x1c
+#define RH_RF95_PLL_TIMEOUT 0x80
+#define RH_RF95_RX_PAYLOAD_CRC_IS_ON 0x40
+#define RH_RF95_FHSS_PRESENT_CHANNEL 0x3f
+
+// RH_RF95_REG_1D_MODEM_CONFIG1 0x1d
+#define RH_RF95_BW 0xf0
+
+#define RH_RF95_BW_7_8KHZ 0x00
+#define RH_RF95_BW_10_4KHZ 0x10
+#define RH_RF95_BW_15_6KHZ 0x20
+#define RH_RF95_BW_20_8KHZ 0x30
+#define RH_RF95_BW_31_25KHZ 0x40
+#define RH_RF95_BW_41_7KHZ 0x50
+#define RH_RF95_BW_62_5KHZ 0x60
+#define RH_RF95_BW_125KHZ 0x70
+#define RH_RF95_BW_250KHZ 0x80
+#define RH_RF95_BW_500KHZ 0x90
+#define RH_RF95_CODING_RATE 0x0e
+#define RH_RF95_CODING_RATE_4_5 0x02
+#define RH_RF95_CODING_RATE_4_6 0x04
+#define RH_RF95_CODING_RATE_4_7 0x06
+#define RH_RF95_CODING_RATE_4_8 0x08
+#define RH_RF95_IMPLICIT_HEADER_MODE_ON 0x01
+
+// RH_RF95_REG_1E_MODEM_CONFIG2 0x1e
+#define RH_RF95_SPREADING_FACTOR 0xf0
+#define RH_RF95_SPREADING_FACTOR_64CPS 0x60
+#define RH_RF95_SPREADING_FACTOR_128CPS 0x70
+#define RH_RF95_SPREADING_FACTOR_256CPS 0x80
+#define RH_RF95_SPREADING_FACTOR_512CPS 0x90
+#define RH_RF95_SPREADING_FACTOR_1024CPS 0xa0
+#define RH_RF95_SPREADING_FACTOR_2048CPS 0xb0
+#define RH_RF95_SPREADING_FACTOR_4096CPS 0xc0
+#define RH_RF95_TX_CONTINUOUS_MOE 0x08
+
+#define RH_RF95_PAYLOAD_CRC_ON 0x04
+#define RH_RF95_SYM_TIMEOUT_MSB 0x03
+
+// RH_RF95_REG_4B_TCXO 0x4b
+#define RH_RF95_TCXO_TCXO_INPUT_ON 0x10
+
+// RH_RF95_REG_4D_PA_DAC 0x4d
+#define RH_RF95_PA_DAC_DISABLE 0x04
+#define RH_RF95_PA_DAC_ENABLE 0x07
+
+/////////////////////////////////////////////////////////////////////
+/// \class RH_RF95 RH_RF95.h <RH_RF95.h>
+/// \brief Driver to send and receive unaddressed, unreliable datagrams via a LoRa
+/// capable radio transceiver.
+///
+/// For Semtech SX1276/77/78/79 and HopeRF RF95/96/97/98 and other similar LoRa capable radios.
+/// Based on http://www.hoperf.com/upload/rf/RFM95_96_97_98W.pdf
+/// and http://www.hoperf.cn/upload/rfchip/RF96_97_98.pdf
+/// and http://www.semtech.com/images/datasheet/LoraDesignGuide_STD.pdf
+/// and http://www.semtech.com/images/datasheet/sx1276.pdf
+/// and http://www.semtech.com/images/datasheet/sx1276_77_78_79.pdf
+/// FSK/GFSK/OOK modes are not (yet) supported.
+///
+/// Works with
+/// - the excellent MiniWirelessLoRa from Anarduino http://www.anarduino.com/miniwireless
+/// - The excellent Modtronix inAir4 http://modtronix.com/inair4.html
+/// and inAir9 modules http://modtronix.com/inair9.html.
+/// - the excellent Rocket Scream Mini Ultra Pro with the RFM95W
+/// http://www.rocketscream.com/blog/product/mini-ultra-pro-with-radio/
+/// - Lora1276 module from NiceRF http://www.nicerf.com/product_view.aspx?id=99
+/// - Adafruit Feather M0 with RFM95
+///
+/// \par Overview
+///
+/// This class provides basic functions for sending and receiving unaddressed,
+/// unreliable datagrams of arbitrary length to 251 octets per packet.
+///
+/// Manager classes may use this class to implement reliable, addressed datagrams and streams,
+/// mesh routers, repeaters, translators etc.
+///
+/// Naturally, for any 2 radios to communicate that must be configured to use the same frequency and
+/// modulation scheme.
+///
+/// This Driver provides an object-oriented interface for sending and receiving data messages with Hope-RF
+/// RFM95/96/97/98(W), Semtech SX1276/77/78/79 and compatible radio modules in LoRa mode.
+///
+/// The Hope-RF (http://www.hoperf.com) RFM95/96/97/98(W) and Semtech SX1276/77/78/79 is a low-cost ISM transceiver
+/// chip. It supports FSK, GFSK, OOK over a wide range of frequencies and
+/// programmable data rates, and it also supports the proprietary LoRA (Long Range) mode, which
+/// is the only mode supported in this RadioHead driver.
+///
+/// This Driver provides functions for sending and receiving messages of up
+/// to 251 octets on any frequency supported by the radio, in a range of
+/// predefined Bandwidths, Spreading Factors and Coding Rates. Frequency can be set with
+/// 61Hz precision to any frequency from 240.0MHz to 960.0MHz. Caution: most modules only support a more limited
+/// range of frequencies due to antenna tuning.
+///
+/// Up to 2 modules can be connected to an Arduino (3 on a Mega),
+/// permitting the construction of translators and frequency changers, etc.
+///
+/// Support for other features such as transmitter power control etc is
+/// also provided.
+///
+/// Tested on MinWirelessLoRa with arduino-1.0.5
+/// on OpenSuSE 13.1.
+/// Also tested with Teensy3.1, Modtronix inAir4 and Arduino 1.6.5 on OpenSuSE 13.1
+///
+/// \par Packet Format
+///
+/// All messages sent and received by this RH_RF95 Driver conform to this packet format:
+///
+/// - LoRa mode:
+/// - 8 symbol PREAMBLE
+/// - Explicit header with header CRC (handled internally by the radio)
+/// - 4 octets HEADER: (TO, FROM, ID, FLAGS)
+/// - 0 to 251 octets DATA
+/// - CRC (handled internally by the radio)
+///
+/// \par Connecting RFM95/96/97/98 and Semtech SX1276/77/78/79 to Arduino
+///
+/// We tested with Anarduino MiniWirelessLoRA, which is an Arduino Duemilanove compatible with a RFM96W
+/// module on-board. Therefore it needs no connections other than the USB
+/// programming connection and an antenna to make it work.
+///
+/// If you have a bare RFM95/96/97/98 that you want to connect to an Arduino, you
+/// might use these connections (untested): CAUTION: you must use a 3.3V type
+/// Arduino, otherwise you will also need voltage level shifters between the
+/// Arduino and the RFM95. CAUTION, you must also ensure you connect an
+/// antenna.
+///
+/// \code
+/// Arduino RFM95/96/97/98
+/// GND----------GND (ground in)
+/// 3V3----------3.3V (3.3V in)
+/// interrupt 0 pin D2-----------DIO0 (interrupt request out)
+/// SS pin D10----------NSS (CS chip select in)
+/// SCK pin D13----------SCK (SPI clock in)
+/// MOSI pin D11----------MOSI (SPI Data in)
+/// MISO pin D12----------MISO (SPI Data out)
+/// \endcode
+/// With these connections, you can then use the default constructor RH_RF95().
+/// You can override the default settings for the SS pin and the interrupt in
+/// the RH_RF95 constructor if you wish to connect the slave select SS to other
+/// than the normal one for your Arduino (D10 for Diecimila, Uno etc and D53
+/// for Mega) or the interrupt request to other than pin D2 (Caution,
+/// different processors have different constraints as to the pins available
+/// for interrupts).
+///
+/// You can connect a Modtronix inAir4 or inAir9 directly to a 3.3V part such as a Teensy 3.1 like
+/// this (tested).
+/// \code
+/// Teensy inAir4 inAir9
+/// GND----------GND (ground in)
+/// 3V3----------3.3V (3.3V in)
+/// interrupt 0 pin D2-----------D00 (interrupt request out)
+/// SS pin D10----------CS (CS chip select in)
+/// SCK pin D13----------CK (SPI clock in)
+/// MOSI pin D11----------SI (SPI Data in)
+/// MISO pin D12----------SO (SPI Data out)
+/// \endcode
+/// With these connections, you can then use the default constructor RH_RF95().
+/// you must also set the transmitter power with useRFO:
+/// driver.setTxPower(13, true);
+///
+/// Note that if you are using Modtronix inAir4 or inAir9,or any other module which uses the
+/// transmitter RFO pins and not the PA_BOOST pins
+/// that you must configure the power transmitter power for -1 to 14 dBm and with useRFO true.
+/// Failure to do that will result in extremely low transmit powers.
+///
+/// If you have an Arduino M0 Pro from arduino.org,
+/// you should note that you cannot use Pin 2 for the interrupt line
+/// (Pin 2 is for the NMI only). The same comments apply to Pin 4 on Arduino Zero from arduino.cc.
+/// Instead you can use any other pin (we use Pin 3) and initialise RH_RF69 like this:
+/// \code
+/// // Slave Select is pin 10, interrupt is Pin 3
+/// RH_RF95 driver(10, 3);
+/// \endcode
+///
+/// If you have a Rocket Scream Mini Ultra Pro with the RFM95W:
+/// - Ensure you have Arduino SAMD board support 1.6.5 or later in Arduino IDE 1.6.8 or later.
+/// - The radio SS is hardwired to pin D5 and the DIO0 interrupt to pin D2,
+/// so you need to initialise the radio like this:
+/// \code
+/// RH_RF95 driver(5, 2);
+/// \endcode
+/// - The name of the serial port on that board is 'SerialUSB', not 'Serial', so this may be helpful at the top of our
+/// sample sketches:
+/// \code
+/// #define Serial SerialUSB
+/// \endcode
+/// - You also need this in setup before radio initialisation
+/// \code
+/// // Ensure serial flash is not interfering with radio communication on SPI bus
+/// pinMode(4, OUTPUT);
+/// digitalWrite(4, HIGH);
+/// \endcode
+/// - and if you have a 915MHz part, you need this after driver/manager intitalisation:
+/// \code
+/// rf95.setFrequency(915.0);
+/// \endcode
+/// which adds up to modifying sample sketches something like:
+/// \code
+/// #include <SPI.h>
+/// #include <RH_RF95.h>
+/// RH_RF95 rf95(5, 2); // Rocket Scream Mini Ultra Pro with the RFM95W
+/// #define Serial SerialUSB
+///
+/// void setup()
+/// {
+/// // Ensure serial flash is not interfering with radio communication on SPI bus
+/// pinMode(4, OUTPUT);
+/// digitalWrite(4, HIGH);
+///
+/// Serial.begin(9600);
+/// while (!Serial) ; // Wait for serial port to be available
+/// if (!rf95.init())
+/// Serial.println("init failed");
+/// rf95.setFrequency(915.0);
+/// }
+/// ...
+/// \endcode
+///
+/// For Adafruit Feather M0 with RFM95, construct the driver like this:
+/// \code
+/// RH_RF95 rf95(8, 3);
+/// \endcode
+///
+/// It is possible to have 2 or more radios connected to one Arduino, provided
+/// each radio has its own SS and interrupt line (SCK, SDI and SDO are common
+/// to all radios)
+///
+/// Caution: on some Arduinos such as the Mega 2560, if you set the slave
+/// select pin to be other than the usual SS pin (D53 on Mega 2560), you may
+/// need to set the usual SS pin to be an output to force the Arduino into SPI
+/// master mode.
+///
+/// Caution: Power supply requirements of the RFM module may be relevant in some circumstances:
+/// RFM95/96/97/98 modules are capable of pulling 120mA+ at full power, where Arduino's 3.3V line can
+/// give 50mA. You may need to make provision for alternate power supply for
+/// the RFM module, especially if you wish to use full transmit power, and/or you have
+/// other shields demanding power. Inadequate power for the RFM is likely to cause symptoms such as:
+/// - reset's/bootups terminate with "init failed" messages
+/// - random termination of communication after 5-30 packets sent/received
+/// - "fake ok" state, where initialization passes fluently, but communication doesn't happen
+/// - shields hang Arduino boards, especially during the flashing
+///
+/// \par Interrupts
+///
+/// The RH_RF95 driver uses interrupts to react to events in the RFM module,
+/// such as the reception of a new packet, or the completion of transmission
+/// of a packet. The RH_RF95 driver interrupt service routine reads status from
+/// and writes data to the the RFM module via the SPI interface. It is very
+/// important therefore, that if you are using the RH_RF95 driver with another
+/// SPI based deviced, that you disable interrupts while you transfer data to
+/// and from that other device. Use cli() to disable interrupts and sei() to
+/// reenable them.
+///
+/// \par Memory
+///
+/// The RH_RF95 driver requires non-trivial amounts of memory. The sample
+/// programs all compile to about 8kbytes each, which will fit in the
+/// flash proram memory of most Arduinos. However, the RAM requirements are
+/// more critical. Therefore, you should be vary sparing with RAM use in
+/// programs that use the RH_RF95 driver.
+///
+/// It is often hard to accurately identify when you are hitting RAM limits on Arduino.
+/// The symptoms can include:
+/// - Mysterious crashes and restarts
+/// - Changes in behaviour when seemingly unrelated changes are made (such as adding print() statements)
+/// - Hanging
+/// - Output from Serial.print() not appearing
+///
+/// \par Range
+///
+/// We have made some simple range tests under the following conditions:
+/// - rf95_client base station connected to a VHF discone antenna at 8m height above ground
+/// - rf95_server mobile connected to 17.3cm 1/4 wavelength antenna at 1m height, no ground plane.
+/// - Both configured for 13dBm, 434MHz, Bw = 125 kHz, Cr = 4/8, Sf = 4096chips/symbol, CRC on. Slow+long range
+/// - Minimum reported RSSI seen for successful comms was about -91
+/// - Range over flat ground through heavy trees and vegetation approx 2km.
+/// - At 20dBm (100mW) otherwise identical conditions approx 3km.
+/// - At 20dBm, along salt water flat sandy beach, 3.2km.
+///
+/// It should be noted that at this data rate, a 12 octet message takes 2 seconds to transmit.
+///
+/// At 20dBm (100mW) with Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on.
+/// (Default medium range) in the conditions described above.
+/// - Range over flat ground through heavy trees and vegetation approx 2km.
+///
+/// Caution: the performance of this radio, especially with narrow bandwidths is strongly dependent on the
+/// accuracy and stability of the chip clock. HopeRF and Semtech do not appear to
+/// recommend bandwidths of less than 62.5 kHz
+/// unless you have the optional Temperature Compensated Crystal Oscillator (TCXO) installed and
+/// enabled on your radio module. See the refernece manual for more data.
+/// Also https://lowpowerlab.com/forum/rf-range-antennas-rfm69-library/lora-library-experiences-range/15/
+/// and http://www.semtech.com/images/datasheet/an120014-xo-guidance-lora-modulation.pdf
+///
+/// \par Transmitter Power
+///
+/// You can control the transmitter power on the RF transceiver
+/// with the RH_RF95::setTxPower() function. The argument can be any of
+/// +5 to +23 (for modules that use PA_BOOST)
+/// -1 to +14 (for modules that use RFO transmitter pin)
+/// The default is 13. Eg:
+/// \code
+/// driver.setTxPower(10); // use PA_BOOST transmitter pin
+/// driver.setTxPower(10, true); // use PA_RFO pin transmitter pin
+/// \endcode
+///
+/// We have made some actual power measurements against
+/// programmed power for Anarduino MiniWirelessLoRa (which has RFM96W-433Mhz installed)
+/// - MiniWirelessLoRa RFM96W-433Mhz, USB power
+/// - 30cm RG316 soldered direct to RFM96W module ANT and GND
+/// - SMA connector
+/// - 12db attenuator
+/// - SMA connector
+/// - MiniKits AD8307 HF/VHF Power Head (calibrated against Rohde&Schwartz 806.2020 test set)
+/// - Tektronix TDS220 scope to measure the Vout from power head
+/// \code
+/// Program power Measured Power
+/// dBm dBm
+/// 5 5
+/// 7 7
+/// 9 8
+/// 11 11
+/// 13 13
+/// 15 15
+/// 17 16
+/// 19 18
+/// 20 20
+/// 21 21
+/// 22 22
+/// 23 23
+/// \endcode
+///
+/// We have also measured the actual power output from a Modtronix inAir4 http://modtronix.com/inair4.html
+/// connected to a Teensy 3.1:
+/// Teensy 3.1 this is a 3.3V part, connected directly to:
+/// Modtronix inAir4 with SMA antenna connector, connected as above:
+/// 10cm SMA-SMA cable
+/// - MiniKits AD8307 HF/VHF Power Head (calibrated against Rohde&Schwartz 806.2020 test set)
+/// - Tektronix TDS220 scope to measure the Vout from power head
+/// \code
+/// Program power Measured Power
+/// dBm dBm
+/// -1 0
+/// 1 2
+/// 3 4
+/// 5 7
+/// 7 10
+/// 9 13
+/// 11 14.2
+/// 13 15
+/// 14 16
+/// \endcode
+/// (Caution: we dont claim laboratory accuracy for these power measurements)
+/// You would not expect to get anywhere near these powers to air with a simple 1/4 wavelength wire antenna.
+class RH_RF95 : public RHGenericDriver
+{
+public:
+ /// \brief Defines register values for a set of modem configuration registers
+ ///
+ /// Defines register values for a set of modem configuration registers
+ /// that can be passed to setModemRegisters() if none of the choices in
+ /// ModemConfigChoice suit your need setModemRegisters() writes the
+ /// register values from this structure to the appropriate registers
+ /// to set the desired spreading factor, coding rate and bandwidth
+ typedef struct
+ {
+ uint8_t reg_1d; ///< Value for register RH_RF95_REG_1D_MODEM_CONFIG1
+ uint8_t reg_1e; ///< Value for register RH_RF95_REG_1E_MODEM_CONFIG2
+ uint8_t reg_26; ///< Value for register RH_RF95_REG_26_MODEM_CONFIG3
+ } ModemConfig;
+
+ /// Choices for setModemConfig() for a selected subset of common
+ /// data rates. If you need another configuration,
+ /// determine the necessary settings and call setModemRegisters() with your
+ /// desired settings. It might be helpful to use the LoRa calculator mentioned in
+ /// http://www.semtech.com/images/datasheet/LoraDesignGuide_STD.pdf
+ /// These are indexes into MODEM_CONFIG_TABLE. We strongly recommend you use these symbolic
+ /// definitions and not their integer equivalents: its possible that new values will be
+ /// introduced in later versions (though we will try to avoid it).
+ /// Caution: if you are using slow packet rates and long packets with RHReliableDatagram or subclasses
+ /// you may need to change the RHReliableDatagram timeout for reliable operations.
+ /// Caution: for some slow rates nad with ReliableDatagrams youi may need to increase the reply timeout
+ /// with manager.setTimeout() to
+ /// deal with the long transmission times.
+ 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
+ } ModemConfigChoice;
+
+ /// Constructor. You can have multiple instances, but each instance must have its own
+ /// interrupt and slave select pin. After constructing, you must call init() to initialise the interface
+ /// and the radio module. A maximum of 3 instances can co-exist on one processor, provided there are sufficient
+ /// distinct interrupt lines, one for each instance.
+ /// \param[in] slaveSelectPin the Arduino pin number of the output to use to select the RH_RF22 before
+ /// accessing it. Defaults to the normal SS pin for your Arduino (D10 for Diecimila, Uno etc, D53 for Mega, D10 for Maple)
+ /// \param[in] interruptPin The interrupt Pin number that is connected to the RFM DIO0 interrupt line.
+ /// Defaults to pin 2, as required by Anarduino MinWirelessLoRa module.
+ /// Caution: You must specify an interrupt capable pin.
+ /// On many Arduino boards, there are limitations as to which pins may be used as interrupts.
+ /// On Leonardo pins 0, 1, 2 or 3. On Mega2560 pins 2, 3, 18, 19, 20, 21. On Due and Teensy, any digital pin.
+ /// On Arduino Zero from arduino.cc, any digital pin other than 4.
+ /// On Arduino M0 Pro from arduino.org, any digital pin other than 2.
+ /// On other Arduinos pins 2 or 3.
+ /// See http://arduino.cc/en/Reference/attachInterrupt for more details.
+ /// On Chipkit Uno32, pins 38, 2, 7, 8, 35.
+ /// On other boards, any digital pin may be used.
+ /// \param[in] spi Pointer to the SPI interface object to use.
+ /// \param[in] ssNum the swspi slave select number to use
+ RH_RF95(swspi& spi, int ssNum);
+
+ /// Initialise the Driver transport hardware and software.
+ /// Make sure the Driver is properly configured before calling init().
+ /// \return true if initialisation succeeded.
+ virtual bool init();
+
+ /// Prints the value of all chip registers
+ /// to the Serial device if RH_HAVE_SERIAL is defined for the current platform
+ /// For debugging purposes only.
+ /// \return true on success
+ bool printRegisters();
+
+ /// Sets all the registered required to configure the data modem in the RF95/96/97/98, including the bandwidth,
+ /// spreading factor etc. You can use this to configure the modem with custom configurations if none of the
+ /// canned configurations in ModemConfigChoice suit you.
+ /// \param[in] config A ModemConfig structure containing values for the modem configuration registers.
+ void setModemRegisters(const ModemConfig* config);
+
+ /// Select one of the predefined modem configurations. If you need a modem configuration not provided
+ /// here, use setModemRegisters() with your own ModemConfig.
+ /// \param[in] index The configuration choice.
+ /// \return true if index is a valid choice.
+ bool setModemConfig(ModemConfigChoice index);
+
+ /// Tests whether a new message is available
+ /// from the Driver.
+ /// On most drivers, this will also put the Driver into RHModeRx mode until
+ /// a message is actually received by the transport, when it wil be returned to RHModeIdle.
+ /// This can be called multiple times in a timeout loop
+ /// \return true if a new, complete, error-free uncollected message is available to be retreived by recv()
+ virtual bool available();
+
+ /// Turns the receiver on if it not already on.
+ /// If there is a valid message available, copy it to buf and return true
+ /// else return false.
+ /// If a message is copied, *len is set to the length (Caution, 0 length messages are permitted).
+ /// You should be sure to call this function frequently enough to not miss any messages
+ /// It is recommended that you call it in your main loop.
+ /// \param[in] buf Location to copy the received message
+ /// \param[in,out] len Pointer to available space in buf. Set to the actual number of octets copied.
+ /// \return true if a valid message was copied to buf
+ virtual bool recv(uint8_t* buf, uint8_t* len);
+
+ /// Waits until any previous transmit packet is finished being transmitted with waitPacketSent().
+ /// Then optionally waits for Channel Activity Detection (CAD)
+ /// to show the channnel is clear (if the radio supports CAD) by calling waitCAD().
+ /// Then loads a message into the transmitter and starts the transmitter. Note that a message length
+ /// of 0 is permitted.
+ /// \param[in] data Array of data to be sent
+ /// \param[in] len Number of bytes of data to send
+ /// specify the maximum time in ms to wait. If 0 (the default) do not wait for CAD before transmitting.
+ /// \return true if the message length was valid and it was correctly queued for transmit. Return false
+ /// if CAD was requested and the CAD timeout timed out before clear channel was detected.
+ virtual bool send(const uint8_t* data, uint8_t len);
+
+ /// Sets the length of the preamble
+ /// in bytes.
+ /// Caution: this should be set to the same
+ /// value on all nodes in your network. Default is 8.
+ /// Sets the message preamble length in RH_RF95_REG_??_PREAMBLE_?SB
+ /// \param[in] bytes Preamble length in bytes.
+ void setPreambleLength(uint16_t bytes);
+
+ /// Returns the maximum message length
+ /// available in this Driver.
+ /// \return The maximum legal message length
+ virtual uint8_t maxMessageLength();
+
+ /// Sets the transmitter and receiver
+ /// centre frequency.
+ /// \param[in] centre Frequency in MHz. 137.0 to 1020.0. Caution: RFM95/96/97/98 comes in several
+ /// different frequency ranges, and setting a frequency outside that range of your radio will probably not work
+ /// \return true if the selected frquency centre is within range
+ bool setFrequency(float centre);
+
+ /// If current mode is Rx or Tx changes it to Idle. If the transmitter or receiver is running,
+ /// disables them.
+ void setModeIdle();
+
+ /// If current mode is Tx or Idle, changes it to Rx.
+ /// Starts the receiver in the RF95/96/97/98.
+ void setModeRx();
+
+ /// If current mode is Rx or Idle, changes it to Rx. F
+ /// Starts the transmitter in the RF95/96/97/98.
+ void setModeTx();
+
+ /// Sets the transmitter power output level, and configures the transmitter pin.
+ /// Be a good neighbour and set the lowest power level you need.
+ /// Some SX1276/77/78/79 and compatible modules (such as RFM95/96/97/98)
+ /// use the PA_BOOST transmitter pin for high power output (and optionally the PA_DAC)
+ /// while some (such as the Modtronix inAir4 and inAir9)
+ /// use the RFO transmitter pin for lower power but higher efficiency.
+ /// You must set the appropriate power level and useRFO argument for your module.
+ /// Check with your module manufacturer which transmtter pin is used on your module
+ /// to ensure you are setting useRFO correctly.
+ /// Failure to do so will result in very low
+ /// transmitter power output.
+ /// Caution: legal power limits may apply in certain countries.
+ /// After init(), the power will be set to 13dBm, with useRFO false (ie PA_BOOST enabled).
+ /// \param[in] power Transmitter power level in dBm. For RFM95/96/97/98 LORA with useRFO false,
+ /// valid values are from +5 to +23.
+ /// For Modtronix inAir4 and inAir9 with useRFO true (ie RFO pins in use),
+ /// valid values are from -1 to 14.
+ /// \param[in] useRFO If true, enables the use of the RFO transmitter pins instead of
+ /// the PA_BOOST pin (false). Choose the correct setting for your module.
+ void setTxPower(int8_t power, bool useRFO = false);
+
+ /// Sets the radio into low-power sleep mode.
+ /// If successful, the transport will stay in sleep mode until woken by
+ /// changing mode it idle, transmit or receive (eg by calling send(), recv(), available() etc)
+ /// Caution: there is a time penalty as the radio takes a finite time to wake from sleep mode.
+ /// \return true if sleep mode was successfully entered.
+ virtual bool sleep();
+
+ // Bent G Christensen (bentor@gmail.com), 08/15/2016
+ /// Use the radio's Channel Activity Detect (CAD) function to detect channel activity.
+ /// Sets the RF95 radio into CAD mode and waits until CAD detection is complete.
+ /// To be used in a listen-before-talk mechanism (Collision Avoidance)
+ /// with a reasonable time backoff algorithm.
+ /// This is called automatically by waitCAD().
+ /// \return true if channel is in use.
+ virtual bool isChannelActive();
+
+ /// 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.
+ /// Leaves the module in sleep mode.
+ /// Caution, this function has not been tested by us.
+ void enableTCXO();
+
+ /// Returns the last measured frequency error.
+ /// The LoRa receiver estimates the frequency offset between the receiver centre frequency
+ /// and that of the received LoRa signal. This function returns the estimates offset (in Hz)
+ /// of the last received message. Caution: this measurement is not absolute, but is measured
+ /// relative to the local receiver's oscillator.
+ /// Apparent errors may be due to the transmitter, the receiver or both.
+ /// \return The estimated centre frequency offset in Hz of the last received message.
+ /// If the modem bandwidth selector in
+ /// register RH_RF95_REG_1D_MODEM_CONFIG1 is invalid, returns 0.
+ int frequencyError();
+
+ /// Returns the Signal-to-noise ratio (SNR) of the last received message, as measured
+ /// by the receiver.
+ /// \return SNR of the last received message in dB
+ int lastSNR();
+
+ /// This is a low level function to handle the interrupts for one instance of RH_RF95.
+ /// Must be called from user code in mbed because the swspi library mutex cannot be
+ /// executed in an ISR. It should be executed when the ISR pin is seen low.
+ void handleInterrupt();
+
+protected:
+ /// Examine the revceive buffer to determine whether the message is for this node
+ void validateRxBuf();
+
+ /// Clear our local receive buffer
+ void clearRxBuf();
+
+private:
+ /// SPI
+ swspi& _spi;
+ int _ssn;
+
+ /// Number of octets in the buffer
+ volatile uint8_t _bufLen;
+
+ /// The receiver/transmitter buffer
+ uint8_t _buf[RH_RF95_MAX_PAYLOAD_LEN];
+
+ /// True when there is a valid message in the buffer
+ volatile bool _rxBufValid;
+
+ // True if we are using the HF port (779.0 MHz and above)
+ bool _usingHFport;
+
+ // Last measured SNR, dB
+ int8_t _lastSNR;
+};
+
+/// @example rf95_client.pde
+/// @example rf95_server.pde
+/// @example rf95_reliable_datagram_client.pde
+/// @example rf95_reliable_datagram_server.pde
+
+#endif
+
diff -r 000000000000 -r e69d086cb053 RadioHead.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/RadioHead.h Sun Jun 11 04:05:05 2017 +0000 @@ -0,0 +1,2 @@ +// This is the address that indicates a broadcast +#define RH_BROADCAST_ADDRESS 0xff \ No newline at end of file