Dan Julio / RadioHead

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.

Dependents:   Rocket

RHGenericDriver.h@0:e69d086cb053, 2017-06-11 (annotated)

Committer:
danjulio
Date:
Sun Jun 11 04:05:05 2017 +0000
Revision:
0:e69d086cb053
Initial commit of minimally ported Radiohead library using swspi

Who changed what in which revision?

UserRevisionLine numberNew contents of line
danjulio 0:e69d086cb053 1 // RHGenericDriver.h
danjulio 0:e69d086cb053 2 // Author: Mike McCauley (mikem@airspayce.com)
danjulio 0:e69d086cb053 3 // Copyright (C) 2014 Mike McCauley
danjulio 0:e69d086cb053 4 // $Id: RHGenericDriver.h,v 1.19 2017/03/08 09:30:47 mikem Exp mikem $
danjulio 0:e69d086cb053 5 //
danjulio 0:e69d086cb053 6 // Ported to mbed - support only a single radio - Dan Julio - 5/2017
danjulio 0:e69d086cb053 7 //
danjulio 0:e69d086cb053 8
danjulio 0:e69d086cb053 9 #ifndef RHGenericDriver_h
danjulio 0:e69d086cb053 10 #define RHGenericDriver_h
danjulio 0:e69d086cb053 11
danjulio 0:e69d086cb053 12 #include "RadioHead.h"
danjulio 0:e69d086cb053 13 #include "mbed.h"
danjulio 0:e69d086cb053 14 #include "max32630fthr.h"
danjulio 0:e69d086cb053 15 #include <stdint.h>
danjulio 0:e69d086cb053 16
danjulio 0:e69d086cb053 17 // Defines bits of the FLAGS header reserved for use by the RadioHead library and
danjulio 0:e69d086cb053 18 // the flags available for use by applications
danjulio 0:e69d086cb053 19 #define RH_FLAGS_RESERVED 0xf0
danjulio 0:e69d086cb053 20 #define RH_FLAGS_APPLICATION_SPECIFIC 0x0f
danjulio 0:e69d086cb053 21 #define RH_FLAGS_NONE 0
danjulio 0:e69d086cb053 22
danjulio 0:e69d086cb053 23 // Default timeout for waitCAD() in ms
danjulio 0:e69d086cb053 24 #define RH_CAD_DEFAULT_TIMEOUT 10000
danjulio 0:e69d086cb053 25
danjulio 0:e69d086cb053 26 /////////////////////////////////////////////////////////////////////
danjulio 0:e69d086cb053 27 /// \class RHGenericDriver RHGenericDriver.h <RHGenericDriver.h>
danjulio 0:e69d086cb053 28 /// \brief Abstract base class for a RadioHead driver.
danjulio 0:e69d086cb053 29 ///
danjulio 0:e69d086cb053 30 /// This class defines the functions that must be provided by any RadioHead driver.
danjulio 0:e69d086cb053 31 /// Different types of driver will implement all the abstract functions, and will perhaps override
danjulio 0:e69d086cb053 32 /// other functions in this subclass, or perhaps add new functions specifically required by that driver.
danjulio 0:e69d086cb053 33 /// Do not directly instantiate this class: it is only to be subclassed by driver classes.
danjulio 0:e69d086cb053 34 ///
danjulio 0:e69d086cb053 35 /// Subclasses are expected to implement a half-duplex, unreliable, error checked, unaddressed packet transport.
danjulio 0:e69d086cb053 36 /// They are expected to carry a message payload with an appropriate maximum length for the transport hardware
danjulio 0:e69d086cb053 37 /// and to also carry unaltered 4 message headers: TO, FROM, ID, FLAGS
danjulio 0:e69d086cb053 38 ///
danjulio 0:e69d086cb053 39 /// \par Headers
danjulio 0:e69d086cb053 40 ///
danjulio 0:e69d086cb053 41 /// Each message sent and received by a RadioHead driver includes 4 headers:
danjulio 0:e69d086cb053 42 /// -TO The node address that the message is being sent to (broadcast RH_BROADCAST_ADDRESS (255) is permitted)
danjulio 0:e69d086cb053 43 /// -FROM The node address of the sending node
danjulio 0:e69d086cb053 44 /// -ID A message ID, distinct (over short time scales) for each message sent by a particilar node
danjulio 0:e69d086cb053 45 /// -FLAGS A bitmask of flags. The most significant 4 bits are reserved for use by RadioHead. The least
danjulio 0:e69d086cb053 46 /// significant 4 bits are reserved for applications.
danjulio 0:e69d086cb053 47 class RHGenericDriver
danjulio 0:e69d086cb053 48 {
danjulio 0:e69d086cb053 49 public:
danjulio 0:e69d086cb053 50 /// \brief Defines different operating modes for the transport hardware
danjulio 0:e69d086cb053 51 ///
danjulio 0:e69d086cb053 52 /// These are the different values that can be adopted by the _mode variable and
danjulio 0:e69d086cb053 53 /// returned by the mode() member function,
danjulio 0:e69d086cb053 54 typedef enum
danjulio 0:e69d086cb053 55 {
danjulio 0:e69d086cb053 56 RHModeInitialising = 0, ///< Transport is initialising. Initial default value until init() is called..
danjulio 0:e69d086cb053 57 RHModeSleep, ///< Transport hardware is in low power sleep mode (if supported)
danjulio 0:e69d086cb053 58 RHModeIdle, ///< Transport is idle.
danjulio 0:e69d086cb053 59 RHModeTx, ///< Transport is in the process of transmitting a message.
danjulio 0:e69d086cb053 60 RHModeRx, ///< Transport is in the process of receiving a message.
danjulio 0:e69d086cb053 61 RHModeCad ///< Transport is in the process of detecting channel activity (if supported)
danjulio 0:e69d086cb053 62 } RHMode;
danjulio 0:e69d086cb053 63
danjulio 0:e69d086cb053 64 /// Constructor
danjulio 0:e69d086cb053 65 RHGenericDriver();
danjulio 0:e69d086cb053 66
danjulio 0:e69d086cb053 67 /// Initialise the Driver transport hardware and software.
danjulio 0:e69d086cb053 68 /// Make sure the Driver is properly configured before calling init().
danjulio 0:e69d086cb053 69 /// \return true if initialisation succeeded.
danjulio 0:e69d086cb053 70 virtual bool init();
danjulio 0:e69d086cb053 71
danjulio 0:e69d086cb053 72 /// Tests whether a new message is available
danjulio 0:e69d086cb053 73 /// from the Driver.
danjulio 0:e69d086cb053 74 /// On most drivers, if there is an uncollected received message, and there is no message
danjulio 0:e69d086cb053 75 /// currently bing transmitted, this will also put the Driver into RHModeRx mode until
danjulio 0:e69d086cb053 76 /// a message is actually received by the transport, when it will be returned to RHModeIdle.
danjulio 0:e69d086cb053 77 /// This can be called multiple times in a timeout loop.
danjulio 0:e69d086cb053 78 /// \return true if a new, complete, error-free uncollected message is available to be retreived by recv().
danjulio 0:e69d086cb053 79 virtual bool available() = 0;
danjulio 0:e69d086cb053 80
danjulio 0:e69d086cb053 81 /// Turns the receiver on if it not already on.
danjulio 0:e69d086cb053 82 /// If there is a valid message available, copy it to buf and return true
danjulio 0:e69d086cb053 83 /// else return false.
danjulio 0:e69d086cb053 84 /// If a message is copied, *len is set to the length (Caution, 0 length messages are permitted).
danjulio 0:e69d086cb053 85 /// You should be sure to call this function frequently enough to not miss any messages
danjulio 0:e69d086cb053 86 /// It is recommended that you call it in your main loop.
danjulio 0:e69d086cb053 87 /// \param[in] buf Location to copy the received message
danjulio 0:e69d086cb053 88 /// \param[in,out] len Pointer to available space in buf. Set to the actual number of octets copied.
danjulio 0:e69d086cb053 89 /// \return true if a valid message was copied to buf
danjulio 0:e69d086cb053 90 virtual bool recv(uint8_t* buf, uint8_t* len) = 0;
danjulio 0:e69d086cb053 91
danjulio 0:e69d086cb053 92 /// Waits until any previous transmit packet is finished being transmitted with waitPacketSent().
danjulio 0:e69d086cb053 93 /// Then optionally waits for Channel Activity Detection (CAD)
danjulio 0:e69d086cb053 94 /// to show the channnel is clear (if the radio supports CAD) by calling waitCAD().
danjulio 0:e69d086cb053 95 /// Then loads a message into the transmitter and starts the transmitter. Note that a message length
danjulio 0:e69d086cb053 96 /// of 0 is NOT permitted. If the message is too long for the underlying radio technology, send() will
danjulio 0:e69d086cb053 97 /// return false and will not send the message.
danjulio 0:e69d086cb053 98 /// \param[in] data Array of data to be sent
danjulio 0:e69d086cb053 99 /// \param[in] len Number of bytes of data to send (> 0)
danjulio 0:e69d086cb053 100 /// specify the maximum time in ms to wait. If 0 (the default) do not wait for CAD before transmitting.
danjulio 0:e69d086cb053 101 /// \return true if the message length was valid and it was correctly queued for transmit. Return false
danjulio 0:e69d086cb053 102 /// if CAD was requested and the CAD timeout timed out before clear channel was detected.
danjulio 0:e69d086cb053 103 virtual bool send(const uint8_t* data, uint8_t len) = 0;
danjulio 0:e69d086cb053 104
danjulio 0:e69d086cb053 105 /// Returns the maximum message length
danjulio 0:e69d086cb053 106 /// available in this Driver.
danjulio 0:e69d086cb053 107 /// \return The maximum legal message length
danjulio 0:e69d086cb053 108 virtual uint8_t maxMessageLength() = 0;
danjulio 0:e69d086cb053 109
danjulio 0:e69d086cb053 110 /// Starts the receiver and blocks until a valid received
danjulio 0:e69d086cb053 111 /// message is available.
danjulio 0:e69d086cb053 112 virtual void waitAvailable();
danjulio 0:e69d086cb053 113
danjulio 0:e69d086cb053 114 /// Blocks until the transmitter
danjulio 0:e69d086cb053 115 /// is no longer transmitting.
danjulio 0:e69d086cb053 116 virtual bool waitPacketSent();
danjulio 0:e69d086cb053 117
danjulio 0:e69d086cb053 118 /// Blocks until the transmitter is no longer transmitting.
danjulio 0:e69d086cb053 119 /// or until the timeout occuers, whichever happens first
danjulio 0:e69d086cb053 120 /// \param[in] timeout Maximum time to wait in milliseconds.
danjulio 0:e69d086cb053 121 /// \return true if the radio completed transmission within the timeout period. False if it timed out.
danjulio 0:e69d086cb053 122 virtual bool waitPacketSent(uint16_t timeout);
danjulio 0:e69d086cb053 123
danjulio 0:e69d086cb053 124 /// Starts the receiver and blocks until a received message is available or a timeout
danjulio 0:e69d086cb053 125 /// \param[in] timeout Maximum time to wait in milliseconds.
danjulio 0:e69d086cb053 126 /// \return true if a message is available
danjulio 0:e69d086cb053 127 virtual bool waitAvailableTimeout(uint16_t timeout);
danjulio 0:e69d086cb053 128
danjulio 0:e69d086cb053 129 // Bent G Christensen (bentor@gmail.com), 08/15/2016
danjulio 0:e69d086cb053 130 /// Channel Activity Detection (CAD).
danjulio 0:e69d086cb053 131 /// Blocks until channel activity is finished or CAD timeout occurs.
danjulio 0:e69d086cb053 132 /// Uses the radio's CAD function (if supported) to detect channel activity.
danjulio 0:e69d086cb053 133 /// Implements random delays of 100 to 1000ms while activity is detected and until timeout.
danjulio 0:e69d086cb053 134 /// Caution: the random() function is not seeded. If you want non-deterministic behaviour, consider
danjulio 0:e69d086cb053 135 /// using something like randomSeed(analogRead(A0)); in your sketch.
danjulio 0:e69d086cb053 136 /// Permits the implementation of listen-before-talk mechanism (Collision Avoidance).
danjulio 0:e69d086cb053 137 /// Calls the isChannelActive() member function for the radio (if supported)
danjulio 0:e69d086cb053 138 /// to determine if the channel is active. If the radio does not support isChannelActive(),
danjulio 0:e69d086cb053 139 /// always returns true immediately
danjulio 0:e69d086cb053 140 /// \return true if the radio-specific CAD (as returned by isChannelActive())
danjulio 0:e69d086cb053 141 /// shows the channel is clear within the timeout period (or the timeout period is 0), else returns false.
danjulio 0:e69d086cb053 142 virtual bool waitCAD();
danjulio 0:e69d086cb053 143
danjulio 0:e69d086cb053 144 /// Sets the Channel Activity Detection timeout in milliseconds to be used by waitCAD().
danjulio 0:e69d086cb053 145 /// The default is 0, which means do not wait for CAD detection.
danjulio 0:e69d086cb053 146 /// CAD detection depends on support for isChannelActive() by your particular radio.
danjulio 0:e69d086cb053 147 void setCADTimeout(unsigned long cad_timeout);
danjulio 0:e69d086cb053 148
danjulio 0:e69d086cb053 149 /// Determine if the currently selected radio channel is active.
danjulio 0:e69d086cb053 150 /// This is expected to be subclassed by specific radios to implement their Channel Activity Detection
danjulio 0:e69d086cb053 151 /// if supported. If the radio does not support CAD, returns true immediately. If a RadioHead radio
danjulio 0:e69d086cb053 152 /// supports isChannelActive() it will be documented in the radio specific documentation.
danjulio 0:e69d086cb053 153 /// This is called automatically by waitCAD().
danjulio 0:e69d086cb053 154 /// \return true if the radio-specific CAD (as returned by override of isChannelActive()) shows the
danjulio 0:e69d086cb053 155 /// current radio channel as active, else false. If there is no radio-specific CAD, returns false.
danjulio 0:e69d086cb053 156 virtual bool isChannelActive();
danjulio 0:e69d086cb053 157
danjulio 0:e69d086cb053 158 /// Sets the address of this node. Defaults to 0xFF. Subclasses or the user may want to change this.
danjulio 0:e69d086cb053 159 /// This will be used to test the adddress in incoming messages. In non-promiscuous mode,
danjulio 0:e69d086cb053 160 /// only messages with a TO header the same as thisAddress or the broadcast addess (0xFF) will be accepted.
danjulio 0:e69d086cb053 161 /// In promiscuous mode, all messages will be accepted regardless of the TO header.
danjulio 0:e69d086cb053 162 /// In a conventional multinode system, all nodes will have a unique address
danjulio 0:e69d086cb053 163 /// (which you could store in EEPROM).
danjulio 0:e69d086cb053 164 /// You would normally set the header FROM address to be the same as thisAddress (though you dont have to,
danjulio 0:e69d086cb053 165 /// allowing the possibilty of address spoofing).
danjulio 0:e69d086cb053 166 /// \param[in] thisAddress The address of this node.
danjulio 0:e69d086cb053 167 virtual void setThisAddress(uint8_t thisAddress);
danjulio 0:e69d086cb053 168
danjulio 0:e69d086cb053 169 /// Sets the TO header to be sent in all subsequent messages
danjulio 0:e69d086cb053 170 /// \param[in] to The new TO header value
danjulio 0:e69d086cb053 171 virtual void setHeaderTo(uint8_t to);
danjulio 0:e69d086cb053 172
danjulio 0:e69d086cb053 173 /// Sets the FROM header to be sent in all subsequent messages
danjulio 0:e69d086cb053 174 /// \param[in] from The new FROM header value
danjulio 0:e69d086cb053 175 virtual void setHeaderFrom(uint8_t from);
danjulio 0:e69d086cb053 176
danjulio 0:e69d086cb053 177 /// Sets the ID header to be sent in all subsequent messages
danjulio 0:e69d086cb053 178 /// \param[in] id The new ID header value
danjulio 0:e69d086cb053 179 virtual void setHeaderId(uint8_t id);
danjulio 0:e69d086cb053 180
danjulio 0:e69d086cb053 181 /// Sets and clears bits in the FLAGS header to be sent in all subsequent messages
danjulio 0:e69d086cb053 182 /// First it clears he FLAGS according to the clear argument, then sets the flags according to the
danjulio 0:e69d086cb053 183 /// set argument. The default for clear always clears the application specific flags.
danjulio 0:e69d086cb053 184 /// \param[in] set bitmask of bits to be set. Flags are cleared with the clear mask before being set.
danjulio 0:e69d086cb053 185 /// \param[in] clear bitmask of flags to clear. Defaults to RH_FLAGS_APPLICATION_SPECIFIC
danjulio 0:e69d086cb053 186 /// which clears the application specific flags, resulting in new application specific flags
danjulio 0:e69d086cb053 187 /// identical to the set.
danjulio 0:e69d086cb053 188 virtual void setHeaderFlags(uint8_t set, uint8_t clear = RH_FLAGS_APPLICATION_SPECIFIC);
danjulio 0:e69d086cb053 189
danjulio 0:e69d086cb053 190 /// Tells the receiver to accept messages with any TO address, not just messages
danjulio 0:e69d086cb053 191 /// addressed to thisAddress or the broadcast address
danjulio 0:e69d086cb053 192 /// \param[in] promiscuous true if you wish to receive messages with any TO address
danjulio 0:e69d086cb053 193 virtual void setPromiscuous(bool promiscuous);
danjulio 0:e69d086cb053 194
danjulio 0:e69d086cb053 195 /// Returns the TO header of the last received message
danjulio 0:e69d086cb053 196 /// \return The TO header
danjulio 0:e69d086cb053 197 virtual uint8_t headerTo();
danjulio 0:e69d086cb053 198
danjulio 0:e69d086cb053 199 /// Returns the FROM header of the last received message
danjulio 0:e69d086cb053 200 /// \return The FROM header
danjulio 0:e69d086cb053 201 virtual uint8_t headerFrom();
danjulio 0:e69d086cb053 202
danjulio 0:e69d086cb053 203 /// Returns the ID header of the last received message
danjulio 0:e69d086cb053 204 /// \return The ID header
danjulio 0:e69d086cb053 205 virtual uint8_t headerId();
danjulio 0:e69d086cb053 206
danjulio 0:e69d086cb053 207 /// Returns the FLAGS header of the last received message
danjulio 0:e69d086cb053 208 /// \return The FLAGS header
danjulio 0:e69d086cb053 209 virtual uint8_t headerFlags();
danjulio 0:e69d086cb053 210
danjulio 0:e69d086cb053 211 /// Returns the most recent RSSI (Receiver Signal Strength Indicator).
danjulio 0:e69d086cb053 212 /// Usually it is the RSSI of the last received message, which is measured when the preamble is received.
danjulio 0:e69d086cb053 213 /// If you called readRssi() more recently, it will return that more recent value.
danjulio 0:e69d086cb053 214 /// \return The most recent RSSI measurement in dBm.
danjulio 0:e69d086cb053 215 int8_t lastRssi();
danjulio 0:e69d086cb053 216
danjulio 0:e69d086cb053 217 /// Returns the operating mode of the library.
danjulio 0:e69d086cb053 218 /// \return the current mode, one of RF69_MODE_*
danjulio 0:e69d086cb053 219 RHMode mode();
danjulio 0:e69d086cb053 220
danjulio 0:e69d086cb053 221 /// Sets the operating mode of the transport.
danjulio 0:e69d086cb053 222 void setMode(RHMode mode);
danjulio 0:e69d086cb053 223
danjulio 0:e69d086cb053 224 /// Sets the transport hardware into low-power sleep mode
danjulio 0:e69d086cb053 225 /// (if supported). May be overridden by specific drivers to initialte sleep mode.
danjulio 0:e69d086cb053 226 /// If successful, the transport will stay in sleep mode until woken by
danjulio 0:e69d086cb053 227 /// changing mode it idle, transmit or receive (eg by calling send(), recv(), available() etc)
danjulio 0:e69d086cb053 228 /// \return true if sleep mode is supported by transport hardware and the RadioHead driver, and if sleep mode
danjulio 0:e69d086cb053 229 /// was successfully entered. If sleep mode is not suported, return false.
danjulio 0:e69d086cb053 230 virtual bool sleep();
danjulio 0:e69d086cb053 231
danjulio 0:e69d086cb053 232 /// Prints a data buffer in HEX.
danjulio 0:e69d086cb053 233 /// For diagnostic use
danjulio 0:e69d086cb053 234 /// \param[in] prompt string to preface the print
danjulio 0:e69d086cb053 235 /// \param[in] buf Location of the buffer to print
danjulio 0:e69d086cb053 236 /// \param[in] len Length of the buffer in octets.
danjulio 0:e69d086cb053 237 static void printBuffer(const char* prompt, const uint8_t* buf, uint8_t len);
danjulio 0:e69d086cb053 238
danjulio 0:e69d086cb053 239 /// Returns the count of the number of bad received packets (ie packets with bad lengths, checksum etc)
danjulio 0:e69d086cb053 240 /// which were rejected and not delivered to the application.
danjulio 0:e69d086cb053 241 /// Caution: not all drivers can correctly report this count. Some underlying hardware only report
danjulio 0:e69d086cb053 242 /// good packets.
danjulio 0:e69d086cb053 243 /// \return The number of bad packets received.
danjulio 0:e69d086cb053 244 uint16_t rxBad();
danjulio 0:e69d086cb053 245
danjulio 0:e69d086cb053 246 /// Returns the count of the number of
danjulio 0:e69d086cb053 247 /// good received packets
danjulio 0:e69d086cb053 248 /// \return The number of good packets received.
danjulio 0:e69d086cb053 249 uint16_t rxGood();
danjulio 0:e69d086cb053 250
danjulio 0:e69d086cb053 251 /// Returns the count of the number of
danjulio 0:e69d086cb053 252 /// packets successfully transmitted (though not necessarily received by the destination)
danjulio 0:e69d086cb053 253 /// \return The number of packets successfully transmitted
danjulio 0:e69d086cb053 254 uint16_t txGood();
danjulio 0:e69d086cb053 255
danjulio 0:e69d086cb053 256 protected:
danjulio 0:e69d086cb053 257
danjulio 0:e69d086cb053 258 /// The current transport operating mode
danjulio 0:e69d086cb053 259 volatile RHMode _mode;
danjulio 0:e69d086cb053 260
danjulio 0:e69d086cb053 261 /// This node id
danjulio 0:e69d086cb053 262 uint8_t _thisAddress;
danjulio 0:e69d086cb053 263
danjulio 0:e69d086cb053 264 /// Whether the transport is in promiscuous mode
danjulio 0:e69d086cb053 265 bool _promiscuous;
danjulio 0:e69d086cb053 266
danjulio 0:e69d086cb053 267 /// TO header in the last received mesasge
danjulio 0:e69d086cb053 268 volatile uint8_t _rxHeaderTo;
danjulio 0:e69d086cb053 269
danjulio 0:e69d086cb053 270 /// FROM header in the last received mesasge
danjulio 0:e69d086cb053 271 volatile uint8_t _rxHeaderFrom;
danjulio 0:e69d086cb053 272
danjulio 0:e69d086cb053 273 /// ID header in the last received mesasge
danjulio 0:e69d086cb053 274 volatile uint8_t _rxHeaderId;
danjulio 0:e69d086cb053 275
danjulio 0:e69d086cb053 276 /// FLAGS header in the last received mesasge
danjulio 0:e69d086cb053 277 volatile uint8_t _rxHeaderFlags;
danjulio 0:e69d086cb053 278
danjulio 0:e69d086cb053 279 /// TO header to send in all messages
danjulio 0:e69d086cb053 280 uint8_t _txHeaderTo;
danjulio 0:e69d086cb053 281
danjulio 0:e69d086cb053 282 /// FROM header to send in all messages
danjulio 0:e69d086cb053 283 uint8_t _txHeaderFrom;
danjulio 0:e69d086cb053 284
danjulio 0:e69d086cb053 285 /// ID header to send in all messages
danjulio 0:e69d086cb053 286 uint8_t _txHeaderId;
danjulio 0:e69d086cb053 287
danjulio 0:e69d086cb053 288 /// FLAGS header to send in all messages
danjulio 0:e69d086cb053 289 uint8_t _txHeaderFlags;
danjulio 0:e69d086cb053 290
danjulio 0:e69d086cb053 291 /// The value of the last received RSSI value, in some transport specific units
danjulio 0:e69d086cb053 292 volatile int8_t _lastRssi;
danjulio 0:e69d086cb053 293
danjulio 0:e69d086cb053 294 /// Count of the number of bad messages (eg bad checksum etc) received
danjulio 0:e69d086cb053 295 volatile uint16_t _rxBad;
danjulio 0:e69d086cb053 296
danjulio 0:e69d086cb053 297 /// Count of the number of successfully transmitted messaged
danjulio 0:e69d086cb053 298 volatile uint16_t _rxGood;
danjulio 0:e69d086cb053 299
danjulio 0:e69d086cb053 300 /// Count of the number of bad messages (correct checksum etc) received
danjulio 0:e69d086cb053 301 volatile uint16_t _txGood;
danjulio 0:e69d086cb053 302
danjulio 0:e69d086cb053 303 /// Channel activity detected
danjulio 0:e69d086cb053 304 volatile bool _cad;
danjulio 0:e69d086cb053 305
danjulio 0:e69d086cb053 306 /// Channel activity timeout in ms
danjulio 0:e69d086cb053 307 unsigned int _cad_timeout;
danjulio 0:e69d086cb053 308
danjulio 0:e69d086cb053 309 private:
danjulio 0:e69d086cb053 310
danjulio 0:e69d086cb053 311 Timer _waitTimer;
danjulio 0:e69d086cb053 312
danjulio 0:e69d086cb053 313 };
danjulio 0:e69d086cb053 314
danjulio 0:e69d086cb053 315
danjulio 0:e69d086cb053 316 #endif