00001 // RF22.h 00002 // Author: Mike McCauley (mikem@open.com.au) 00003 // Copyright (C) 2011 Mike McCauley 00004 // $Id: RF22.h,v 1.20 2011/11/24 00:29:58 mikem Exp mikem $ 00005 // 00006 /// \mainpage RF22 library for Arduino 00007 /// 00008 /// This is the Arduino RF22 library. 00009 /// It provides an object-oriented interface for sending and receiving data messages with Hope-RF 00010 /// RF22B based radio modules, and compatible chips and modules, including the RFM22B transceiver module such as 00011 /// this one: http://www.sparkfun.com/products/10153 00012 /// 00013 /// RF22 also supports some of the features of ZigBee and XBee, 00014 /// (such as mesh routing and automatic route discovery), 00015 /// but with a much less complicated system and less expensive radios. 00016 /// 00017 /// The Hope-RF (http://www.hoperf.com) RFM22B (http://www.hoperf.com/rf_fsk/fsk/RFM22B.htm) 00018 /// is a low-cost ISM transceiver module. It supports FSK, GFSK, OOK over a wide 00019 /// range of frequencies and programmable data rates. 00020 /// 00021 /// This library provides functions for sending and receiving messages of up to 255 octets on any 00022 /// frequency supported by the RF22B, in a range of predefined data rates and frequency deviations. 00023 /// Frequency can be set with 312Hz precision to any frequency from 240.0MHz to 960.0MHz. 00024 /// 00025 /// Up to 2 RF22B modules can be connected to an Arduino, permitting the construction of translators 00026 /// and frequency changers, etc. 00027 /// 00028 /// This library provides classes for 00029 /// - RF22: unaddressed, unreliable messages 00030 /// - RF22Datagram: addressed, unreliable messages 00031 /// - RF22ReliableDatagram: addressed, reliable, retransmitted, acknowledged messages. 00032 /// - RF22Router: multi hop delivery from source node to destination node via 0 or more intermediate nodes 00033 /// - RF22Mesh: multi hop delivery with automatic route discovery and rediscovery. 00034 /// 00035 /// The following modulation types are suppported with a range of modem configurations for 00036 /// common data rates and frequency deviations: 00037 /// - GFSK Gaussian Frequency Shift Keying 00038 /// - FSK Frequency Shift Keying 00039 /// - OOK On-Off Keying 00040 /// 00041 /// Support for other RF22B features such as on-chip temperature measurement, analog-digital 00042 /// converter, transmitter power control etc is also provided. 00043 /// 00044 /// The latest version of this documentation can be downloaded from 00045 /// http://www.open.com.au/mikem/arduino/RF22 00046 /// 00047 /// Example Arduino programs are included to show the main modes of use. 00048 /// 00049 /// The version of the package that this documentation refers to can be downloaded 00050 /// from http://www.open.com.au/mikem/arduino/RF22/RF22-1.12.zip 00051 /// You can find the latest version at http://www.open.com.au/mikem/arduino/RF22 00052 /// 00053 /// Tested on Arduino Diecimila and Mega with arduino-0021 00054 /// on OpenSuSE 11.1 and avr-libc-1.6.1-1.15, 00055 /// cross-avr-binutils-2.19-9.1, cross-avr-gcc-4.1.3_20080612-26.5. 00056 /// With HopeRF RFM22 modules that appear to have RF22B chips on board: 00057 /// - Device Type Code = 0x08 (RX/TRX) 00058 /// - Version Code = 0x06 00059 /// It is known not to work on Diecimila. Dont bother trying. 00060 /// 00061 /// \par Packet Format 00062 /// 00063 /// All messages sent and received by this RF22 library must conform to this packet format: 00064 /// 00065 /// - 8 nibbles (4 octets) PREAMBLE 00066 /// - 2 octets SYNC 0x2d, 0xd4 00067 /// - 4 octets HEADER: (TO, FROM, ID, FLAGS) 00068 /// - 1 octet LENGTH (0 to 255), number of octets in DATA 00069 /// - 0 to 255 octets DATA 00070 /// - 2 octets CRC computed with CRC16(IBM), computed on HEADER, LENGTH and DATA 00071 /// 00072 /// For technical reasons, the message format is not compatible with the 00073 /// 'HopeRF Radio Transceiver Message Library for Arduino' http://www.open.com.au/mikem/arduino/HopeRF from the same author. Nor is it compatible with 00074 /// 'Virtual Wire' http://www.open.com.au/mikem/arduino/VirtualWire.pdf also from the same author. 00075 /// 00076 /// \par Connecting RFM-22 to Arduino 00077 /// The physical connection between the RF22B and the Arduino require 3.3V, the 3 x SPI pins (SCK, SDI, SDO), 00078 /// a Slave Select pin and an interrupt pin. 00079 /// Note also that on the RFF22B, it is required to control the TX_ANT and X_ANT pins of the RFM22 in order to enable the 00080 /// antenna connection. The RF22 library is configured so that GPIO0 and GPIO1 outputs can control TX_ANT and RX_ANT input pins 00081 /// automatically. You must connect GPIO0 to TX_ANT and GPIO1 to RX_ANT for this automatic antenna switching to occur. 00082 /// 00083 /// Connect the RFM-22 to most Arduino's like this (Caution, Arduino Mega has different pins for SPI, 00084 /// see below): 00085 /// \code 00086 /// Arduino RFM-22B 00087 /// GND----------GND-\ (ground in) 00088 /// SDN-/ (shutdown in) 00089 /// 3V3----------VCC (3.3V in) 00090 /// interrupt 0 pin D2-----------NIRQ (interrupt request out) 00091 /// SS pin D10----------NSEL (chip select in) 00092 /// SCK pin D13----------SCK (SPI clock in) 00093 /// MOSI pin D11----------SDI (SPI Data in) 00094 /// MISO pin D12----------SDO (SPI data out) 00095 /// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT 00096 /// \--TX_ANT (TX antenna control in) 00097 /// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT 00098 /// \--RX_ANT (RX antenna control in) 00099 /// \endcode 00100 /// For an Arduino Mega: 00101 /// \code 00102 /// Mega RFM-22B 00103 /// GND----------GND-\ (ground in) 00104 /// SDN-/ (shutdown in) 00105 /// 3V3----------VCC (3.3V in) 00106 /// interrupt 0 pin D2-----------NIRQ (interrupt request out) 00107 /// SS pin D10----------NSEL (chip select in) 00108 /// SCK pin D52----------SCK (SPI clock in) 00109 /// MOSI pin D51----------SDI (SPI Data in) 00110 /// MISO pin D50----------SDO (SPI data out) 00111 /// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT 00112 /// \--TX_ANT (TX antenna control in) 00113 /// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT 00114 /// \--RX_ANT (RX antenna control in) 00115 /// \endcode 00116 /// and you can then use the default constructor RF22(). 00117 /// You can override the default settings for the SS pin and the interrupt 00118 /// in the RF22 constructor if you wish to connect the slave select SS to other than pin D10 00119 /// or the interrupt request to other than pin D2. 00120 /// It is possible to have 2 radios conected to one arduino, provided each radio has its own 00121 /// SS and interrupt line (SCK, SDI and SDO are common to both radios) 00122 /// 00123 /// \par Example programs 00124 /// 00125 /// The following example programs are provided: 00126 /// - rf22_client, rf22_server: Simple client/server pair using RF22 class 00127 /// - rf22_datagram_client, rf22_datagram_server: Simple client/server pair using RF22Datagram class 00128 /// - rf22_reliable_datagram_client, rf22_reliable_datagram_server: 00129 /// Simple client/server pair using RF22ReliableDatagram class 00130 /// - rf22_router_client, rf22_router_server1, rf22_router_server2, rf22_router_server3: 00131 /// Simple RF22Router network. Requires Arduino Mega. 00132 /// - rf22_mesh_client, rf22_mesh_server1, rf22_mesh_server2, rf22_mesh_server3: 00133 /// Simple RF22Mesh network. Requires Arduino Mega. 00134 /// - rf22_test: Some test code used during development, shows how to call some support functions 00135 /// - rf22_snoop: Dumps in ASCII the contents of all RF22 messages received 00136 /// - rf22_specan: Simple spectrum analyser using the RSSI measurements of the RF22 00137 /// (see <a href="specan1.png">Sample output</a> showing a plot from 395.0MHz to 396.0MHz of a 00138 /// signal generator at 395.5MHz amplitude modulated at 100% 1kHz) 00139 /// 00140 /// \par Memory 00141 /// 00142 /// The RF22 library requires non-trivial amounts of memory. The sample programs above all compile to 00143 /// about 9 to 14kbytes each, which will fit in the flash proram memory of most Arduinos. However, 00144 /// the RAM requirements are more critical. Most sample programs above will run on Duemilanova, 00145 /// but not on Diecimila. Even on Duemilanova, the RAM requirements are very close to the 00146 /// available memory of 2kbytes. Therefore, you should be vary sparing with RAM use in programs that use 00147 /// the RF22 library on Duemilanova. 00148 /// 00149 /// The sample RF22Router and RF22Mesh programs compile to about 14kbytes, 00150 /// and require more RAM than the others. 00151 /// They will not run on Duemilanova or Diecimila, but will run on Arduino Mega. 00152 /// 00153 /// It is often hard to accurately identify when you are hitting RAM limits on Arduino. 00154 /// The symptoms can include: 00155 /// - Mysterious crashes and restarts 00156 /// - Changes in behaviour when seemingly unrelated changes are made (such as adding print() statements) 00157 /// - Hanging 00158 /// - Output from Serial.print() not appearing 00159 /// 00160 /// With an Arduino Mega, with 8 kbytes of SRAM, there is much more RAM headroom for 00161 /// your own elaborate programs. 00162 /// This library is reported to work with Arduino Pro Mini, but that has not been tested by me. 00163 /// 00164 /// The Arduino UNO is known not to work with RF22. 00165 /// It appears that something in the Uno is interfering with MISO pin, preventing 00166 /// the RFM initialisation completing. Miso is held at 0 when I would expect the 00167 /// RFM22 to output data on MISO. I suspect it is the U8A USP interface chip (its 00168 /// the only other thing connected to MISO. And if I power the Uno + RFM22 from a 00169 /// battery instead of USB, it works fine. rubinoae reports that installing different firmware 00170 /// in the U8A fixes this problem but that has not been tested by me. 00171 /// 00172 /// \par Installation 00173 /// 00174 /// Install in the usual way: unzip the distribution zip file to the libraries 00175 /// sub-folder of your sketchbook. 00176 /// 00177 /// This software is Copyright (C) 2011 Mike McCauley. Use is subject to license 00178 /// conditions. The main licensing options available are GPL V2 or Commercial: 00179 /// 00180 /// \par Open Source Licensing GPL V2 00181 /// 00182 /// This is the appropriate option if you want to share the source code of your 00183 /// application with everyone you distribute it to, and you also want to give them 00184 /// the right to share who uses it. If you wish to use this software under Open 00185 /// Source Licensing, you must contribute all your source code to the open source 00186 /// community in accordance with the GPL Version 2 when your application is 00187 /// distributed. See http://www.gnu.org/copyleft/gpl.html 00188 /// 00189 /// \par Commercial Licensing 00190 /// 00191 /// This is the appropriate option if you are creating proprietary applications 00192 /// and you are not prepared to distribute and share the source code of your 00193 /// application. Contact info@open.com.au for details. 00194 /// 00195 /// \par Revision History 00196 /// 00197 /// \version 1.0 Initial release 00198 /// 00199 /// \version 1.1 Added rf22_snoop and rf22_specan examples 00200 /// 00201 /// \version 1.2 Changed default modulation to FSK_Rb2_4Fd36 00202 /// Some internal reorganisation. 00203 /// Added RF22Router and RF22Mesh classes plus sample programs to support multi-hop and 00204 /// automatic route discovery. 00205 /// \version 1.3 Removed some unnecessary debug messages. Added virtual doArp and isPhysicalAddress 00206 /// functions to RF22Mesh to support other physical address interpretation schemes (IPV4/IPV6?) 00207 /// \version 1.4 RF22Router and RF22Mesh were inadvertently left out of the distro. 00208 /// \version 1.5 Improvements contributed by Peter Mousley: Modem config table is now in flash rather than SRAM, 00209 /// saving 400 bytes of SRAM. Allow a user-defined buffer size. Thanks Peter. 00210 /// \version 1.6 Fixed some minor typos on doc and clarified that this code is for the RF22B. Fixed errors in the 00211 /// definition of the power output constants which were incorrectly set to the values for the RF22. 00212 /// Reported by Fred Slamen. If you were using a previous version of RF22, you probably were not getting the output 00213 /// power you thought. 00214 /// \version 1.7 Added code to initialise GPIO0 and GPIO1 so they can automatically control the TX_ANT and RX_ANT 00215 /// antenna switching inputs. You must connect GPIO0 to TX_ANT and GPIO1 to RX_ANT for this automatic 00216 /// antenna switching to occur. Updated doc to reflect this new connection requirement 00217 /// \version 1.8 Changed the name of RF22_ENLBD in RF22_REG_06_INTERRUPT_ENABLE2 to RF22_ENLBDI because it collided 00218 /// with a define of the same name in RF22_REG_07_OPERATING_MODE. RF22_REG_05_INTERRUPT_ENABLE1 enable mask 00219 /// incorrectly used RF22_IFFERROR instead of RF22_ENFFERR. Reported by Steffan Woltjer. 00220 /// \version 1.9 Fixed typos in RF22_REG_21_CLOCk*. Reported by Steffan Woltjer. 00221 /// \version 1.10 Fixed a problem where a IFFERR during transmission could cause an infinite loop and a hang. 00222 /// Reported by Raymond Gilbert. 00223 /// \version 1.11 Fixed an innocuous typo in RF22::handleInterrupt. Reported by Zhentao. 00224 /// 00225 /// \version 1.12 Improvements to RF22::init from Guy Molinari to improve compatibility with some 00226 /// Arduinos. Now reported to be working with official Mega 2560 and Uno. 00227 /// Updated so compiles on Arduino 1.0. 00228 /// 00229 /// 00230 /// \author Mike McCauley (mikem@open.com.au) 00231 00232 #ifndef RF22_h 00233 #define RF22_h 00234 00235 #if ARDUINO >= 100 00236 #include <Arduino.h> 00237 #else 00238 #include <wiring.h> 00239 #endif 00240 00241 // These defs cause trouble on some versions of Arduino 00242 #undef round 00243 #undef double 00244 00245 // This is the bit in the SPI address that marks it as a write 00246 #define RF22_SPI_WRITE_MASK 0x80 00247 00248 // This is the maximum message length that can be supported by this library. Limited by 00249 // the message length octet in the header. Yes, 255 is correct even though the FIFO size in the RF22 is only 00250 // 64 octets. We use interrupts to refil the Tx FIFO during transmission and to empty the 00251 // Rx FIF during reception 00252 // Can be pre-defined to a smaller size (to save SRAM) prior to including this header 00253 #ifndef RF22_MAX_MESSAGE_LEN 00254 #define RF22_MAX_MESSAGE_LEN 255 00255 #endif 00256 00257 // Max number of octets the RF22 Rx and Tx FIFOs can hold 00258 #define RF22_FIFO_SIZE 64 00259 00260 // Keep track of the mode the RF22 is in 00261 #define RF22_MODE_IDLE 0 00262 #define RF22_MODE_RX 1 00263 #define RF22_MODE_TX 2 00264 00265 // These values we set for FIFO thresholds are actually the same as the POR values 00266 #define RF22_TXFFAEM_THRESHOLD 4 00267 #define RF22_RXFFAFULL_THRESHOLD 55 00268 00269 // This is the default node address, 00270 #define RF22_DEFAULT_NODE_ADDRESS 0 00271 00272 // This address in the TO addreess signifies a broadcast 00273 #define RF22_BROADCAST_ADDRESS 0xff 00274 00275 // Number of registers to be passed to setModemConfig() 00276 #define RF22_NUM_MODEM_CONFIG_REGS 18 00277 00278 // Register names 00279 #define RF22_REG_00_DEVICE_TYPE 0x00 00280 #define RF22_REG_01_VERSION_CODE 0x01 00281 #define RF22_REG_02_DEVICE_STATUS 0x02 00282 #define RF22_REG_03_INTERRUPT_STATUS1 0x03 00283 #define RF22_REG_04_INTERRUPT_STATUS2 0x04 00284 #define RF22_REG_05_INTERRUPT_ENABLE1 0x05 00285 #define RF22_REG_06_INTERRUPT_ENABLE2 0x06 00286 #define RF22_REG_07_OPERATING_MODE1 0x07 00287 #define RF22_REG_08_OPERATING_MODE2 0x08 00288 #define RF22_REG_09_OSCILLATOR_LOAD_CAPACITANCE 0x09 00289 #define RF22_REG_0A_UC_OUTPUT_CLOCK 0x0a 00290 #define RF22_REG_0B_GPIO_CONFIGURATION0 0x0b 00291 #define RF22_REG_0C_GPIO_CONFIGURATION1 0x0c 00292 #define RF22_REG_0D_GPIO_CONFIGURATION2 0x0d 00293 #define RF22_REG_0E_IO_PORT_CONFIGURATION 0x0e 00294 #define RF22_REG_0F_ADC_CONFIGURATION 0x0f 00295 #define RF22_REG_10_ADC_SENSOR_AMP_OFFSET 0x10 00296 #define RF22_REG_11_ADC_VALUE 0x11 00297 #define RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION 0x12 00298 #define RF22_REG_13_TEMPERATURE_VALUE_OFFSET 0x13 00299 #define RF22_REG_14_WAKEUP_TIMER_PERIOD1 0x14 00300 #define RF22_REG_15_WAKEUP_TIMER_PERIOD2 0x15 00301 #define RF22_REG_16_WAKEUP_TIMER_PERIOD3 0x16 00302 #define RF22_REG_17_WAKEUP_TIMER_VALUE1 0x17 00303 #define RF22_REG_18_WAKEUP_TIMER_VALUE2 0x18 00304 #define RF22_REG_19_LDC_MODE_DURATION 0x19 00305 #define RF22_REG_1A_LOW_BATTERY_DETECTOR_THRESHOLD 0x1a 00306 #define RF22_REG_1B_BATTERY_VOLTAGE_LEVEL 0x1b 00307 #define RF22_REG_1C_IF_FILTER_BANDWIDTH 0x1c 00308 #define RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE 0x1d 00309 #define RF22_REG_1E_AFC_TIMING_CONTROL 0x1e 00310 #define RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE 0x1f 00311 #define RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE 0x20 00312 #define RF22_REG_21_CLOCK_RECOVERY_OFFSET2 0x21 00313 #define RF22_REG_22_CLOCK_RECOVERY_OFFSET1 0x22 00314 #define RF22_REG_23_CLOCK_RECOVERY_OFFSET0 0x23 00315 #define RF22_REG_24_CLOCK_RECOVERY_TIMING_LOOP_GAIN1 0x24 00316 #define RF22_REG_25_CLOCK_RECOVERY_TIMING_LOOP_GAIN0 0x25 00317 #define RF22_REG_26_RSSI 0x26 00318 #define RF22_REG_27_RSSI_THRESHOLD 0x27 00319 #define RF22_REG_28_ANTENNA_DIVERSITY1 0x28 00320 #define RF22_REG_29_ANTENNA_DIVERSITY2 0x29 00321 #define RF22_REG_2A_AFC_LIMITER 0x2a 00322 #define RF22_REG_2B_AFC_CORRECTION_READ 0x2b 00323 #define RF22_REG_2C_OOK_COUNTER_VALUE_1 0x2c 00324 #define RF22_REG_2D_OOK_COUNTER_VALUE_2 0x2d 00325 #define RF22_REG_2E_SLICER_PEAK_HOLD 0x2e 00326 #define RF22_REG_30_DATA_ACCESS_CONTROL 0x30 00327 #define RF22_REG_31_EZMAC_STATUS 0x31 00328 #define RF22_REG_32_HEADER_CONTROL1 0x32 00329 #define RF22_REG_33_HEADER_CONTROL2 0x33 00330 #define RF22_REG_34_PREAMBLE_LENGTH 0x34 00331 #define RF22_REG_35_PREAMBLE_DETECTION_CONTROL1 0x35 00332 #define RF22_REG_36_SYNC_WORD3 0x36 00333 #define RF22_REG_37_SYNC_WORD2 0x37 00334 #define RF22_REG_38_SYNC_WORD1 0x38 00335 #define RF22_REG_39_SYNC_WORD0 0x39 00336 #define RF22_REG_3A_TRANSMIT_HEADER3 0x3a 00337 #define RF22_REG_3B_TRANSMIT_HEADER2 0x3b 00338 #define RF22_REG_3C_TRANSMIT_HEADER1 0x3c 00339 #define RF22_REG_3D_TRANSMIT_HEADER0 0x3d 00340 #define RF22_REG_3E_PACKET_LENGTH 0x3e 00341 #define RF22_REG_3F_CHECK_HEADER3 0x3f 00342 #define RF22_REG_40_CHECK_HEADER2 0x40 00343 #define RF22_REG_41_CHECK_HEADER1 0x41 00344 #define RF22_REG_42_CHECK_HEADER0 0x42 00345 #define RF22_REG_43_HEADER_ENABLE3 0x43 00346 #define RF22_REG_44_HEADER_ENABLE2 0x44 00347 #define RF22_REG_45_HEADER_ENABLE1 0x45 00348 #define RF22_REG_46_HEADER_ENABLE0 0x46 00349 #define RF22_REG_47_RECEIVED_HEADER3 0x47 00350 #define RF22_REG_48_RECEIVED_HEADER2 0x48 00351 #define RF22_REG_49_RECEIVED_HEADER1 0x49 00352 #define RF22_REG_4A_RECEIVED_HEADER0 0x4a 00353 #define RF22_REG_4B_RECEIVED_PACKET_LENGTH 0x4b 00354 #define RF22_REG_50_ANALOG_TEST_BUS_SELECT 0x50 00355 #define RF22_REG_51_DIGITAL_TEST_BUS_SELECT 0x51 00356 #define RF22_REG_52_TX_RAMP_CONTROL 0x52 00357 #define RF22_REG_53_PLL_TUNE_TIME 0x53 00358 #define RF22_REG_55_CALIBRATION_CONTROL 0x55 00359 #define RF22_REG_56_MODEM_TEST 0x56 00360 #define RF22_REG_57_CHARGE_PUMP_TEST 0x57 00361 #define RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING 0x58 00362 #define RF22_REG_59_DIVIDER_CURRENT_TRIMMING 0x59 00363 #define RF22_REG_5A_VCO_CURRENT_TRIMMING 0x5a 00364 #define RF22_REG_5B_VCO_CALIBRATION 0x5b 00365 #define RF22_REG_5C_SYNTHESIZER_TEST 0x5c 00366 #define RF22_REG_5D_BLOCK_ENABLE_OVERRIDE1 0x5d 00367 #define RF22_REG_5E_BLOCK_ENABLE_OVERRIDE2 0x5e 00368 #define RF22_REG_5F_BLOCK_ENABLE_OVERRIDE3 0x5f 00369 #define RF22_REG_60_CHANNEL_FILTER_COEFFICIENT_ADDRESS 0x60 00370 #define RF22_REG_61_CHANNEL_FILTER_COEFFICIENT_VALUE 0x61 00371 #define RF22_REG_62_CRYSTAL_OSCILLATOR_POR_CONTROL 0x62 00372 #define RF22_REG_63_RC_OSCILLATOR_COARSE_CALIBRATION 0x63 00373 #define RF22_REG_64_RC_OSCILLATOR_FINE_CALIBRATION 0x64 00374 #define RF22_REG_65_LDO_CONTROL_OVERRIDE 0x65 00375 #define RF22_REG_66_LDO_LEVEL_SETTINGS 0x66 00376 #define RF22_REG_67_DELTA_SIGMA_ADC_TUNING1 0x67 00377 #define RF22_REG_68_DELTA_SIGMA_ADC_TUNING2 0x68 00378 #define RF22_REG_69_AGC_OVERRIDE1 0x69 00379 #define RF22_REG_6A_AGC_OVERRIDE2 0x6a 00380 #define RF22_REG_6B_GFSK_FIR_FILTER_COEFFICIENT_ADDRESS 0x6b 00381 #define RF22_REG_6C_GFSK_FIR_FILTER_COEFFICIENT_VALUE 0x6c 00382 #define RF22_REG_6D_TX_POWER 0x6d 00383 #define RF22_REG_6E_TX_DATA_RATE1 0x6e 00384 #define RF22_REG_6F_TX_DATA_RATE0 0x6f 00385 #define RF22_REG_70_MODULATION_CONTROL1 0x70 00386 #define RF22_REG_71_MODULATION_CONTROL2 0x71 00387 #define RF22_REG_72_FREQUENCY_DEVIATION 0x72 00388 #define RF22_REG_73_FREQUENCY_OFFSET1 0x73 00389 #define RF22_REG_74_FREQUENCY_OFFSET2 0x74 00390 #define RF22_REG_75_FREQUENCY_BAND_SELECT 0x75 00391 #define RF22_REG_76_NOMINAL_CARRIER_FREQUENCY1 0x76 00392 #define RF22_REG_77_NOMINAL_CARRIER_FREQUENCY0 0x77 00393 #define RF22_REG_79_FREQUENCY_HOPPING_CHANNEL_SELECT 0x79 00394 #define RF22_REG_7A_FREQUENCY_HOPPING_STEP_SIZE 0x7a 00395 #define RF22_REG_7C_TX_FIFO_CONTROL1 0x7c 00396 #define RF22_REG_7D_TX_FIFO_CONTROL2 0x7d 00397 #define RF22_REG_7E_RX_FIFO_CONTROL 0x7e 00398 #define RF22_REG_7F_FIFO_ACCESS 0x7f 00399 00400 // These register masks etc are named wherever possible 00401 // corresponding to the bit and field names in the RF-22 Manual 00402 // RF22_REG_00_DEVICE_TYPE 0x00 00403 #define RF22_DEVICE_TYPE_RX_TRX 0x08 00404 #define RF22_DEVICE_TYPE_TX 0x07 00405 00406 // RF22_REG_02_DEVICE_STATUS 0x02 00407 #define RF22_FFOVL 0x80 00408 #define RF22_FFUNFL 0x40 00409 #define RF22_RXFFEM 0x20 00410 #define RF22_HEADERR 0x10 00411 #define RF22_FREQERR 0x08 00412 #define RF22_LOCKDET 0x04 00413 #define RF22_CPS 0x03 00414 #define RF22_CPS_IDLE 0x00 00415 #define RF22_CPS_RX 0x01 00416 #define RF22_CPS_TX 0x10 00417 00418 // RF22_REG_03_INTERRUPT_STATUS1 0x03 00419 #define RF22_IFFERROR 0x80 00420 #define RF22_ITXFFAFULL 0x40 00421 #define RF22_ITXFFAEM 0x20 00422 #define RF22_IRXFFAFULL 0x10 00423 #define RF22_IEXT 0x08 00424 #define RF22_IPKSENT 0x04 00425 #define RF22_IPKVALID 0x02 00426 #define RF22_ICRCERROR 0x01 00427 00428 // RF22_REG_04_INTERRUPT_STATUS2 0x04 00429 #define RF22_ISWDET 0x80 00430 #define RF22_IPREAVAL 0x40 00431 #define RF22_IPREAINVAL 0x20 00432 #define RF22_IRSSI 0x10 00433 #define RF22_IWUT 0x08 00434 #define RF22_ILBD 0x04 00435 #define RF22_ICHIPRDY 0x02 00436 #define RF22_IPOR 0x01 00437 00438 // RF22_REG_05_INTERRUPT_ENABLE1 0x05 00439 #define RF22_ENFFERR 0x80 00440 #define RF22_ENTXFFAFULL 0x40 00441 #define RF22_ENTXFFAEM 0x20 00442 #define RF22_ENRXFFAFULL 0x10 00443 #define RF22_ENEXT 0x08 00444 #define RF22_ENPKSENT 0x04 00445 #define RF22_ENPKVALID 0x02 00446 #define RF22_ENCRCERROR 0x01 00447 00448 // RF22_REG_06_INTERRUPT_ENABLE2 0x06 00449 #define RF22_ENSWDET 0x80 00450 #define RF22_ENPREAVAL 0x40 00451 #define RF22_ENPREAINVAL 0x20 00452 #define RF22_ENRSSI 0x10 00453 #define RF22_ENWUT 0x08 00454 #define RF22_ENLBDI 0x04 00455 #define RF22_ENCHIPRDY 0x02 00456 #define RF22_ENPOR 0x01 00457 00458 // RF22_REG_07_OPERATING_MODE 0x07 00459 #define RF22_SWRES 0x80 00460 #define RF22_ENLBD 0x40 00461 #define RF22_ENWT 0x20 00462 #define RF22_X32KSEL 0x10 00463 #define RF22_TXON 0x08 00464 #define RF22_RXON 0x04 00465 #define RF22_PLLON 0x02 00466 #define RF22_XTON 0x01 00467 00468 // RF22_REG_08_OPERATING_MODE2 0x08 00469 #define RF22_ANTDIV 0xc0 00470 #define RF22_RXMPK 0x10 00471 #define RF22_AUTOTX 0x08 00472 #define RF22_ENLDM 0x04 00473 #define RF22_FFCLRRX 0x02 00474 #define RF22_FFCLRTX 0x01 00475 00476 // RF22_REG_0F_ADC_CONFIGURATION 0x0f 00477 #define RF22_ADCSTART 0x80 00478 #define RF22_ADCDONE 0x80 00479 #define RF22_ADCSEL 0x70 00480 #define RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR 0x00 00481 #define RF22_ADCSEL_GPIO0_SINGLE_ENDED 0x10 00482 #define RF22_ADCSEL_GPIO1_SINGLE_ENDED 0x20 00483 #define RF22_ADCSEL_GPIO2_SINGLE_ENDED 0x30 00484 #define RF22_ADCSEL_GPIO0_GPIO1_DIFFERENTIAL 0x40 00485 #define RF22_ADCSEL_GPIO1_GPIO2_DIFFERENTIAL 0x50 00486 #define RF22_ADCSEL_GPIO0_GPIO2_DIFFERENTIAL 0x60 00487 #define RF22_ADCSEL_GND 0x70 00488 #define RF22_ADCREF 0x0c 00489 #define RF22_ADCREF_BANDGAP_VOLTAGE 0x00 00490 #define RF22_ADCREF_VDD_ON_3 0x08 00491 #define RF22_ADCREF_VDD_ON_2 0x0c 00492 #define RF22_ADCGAIN 0x03 00493 00494 // RF22_REG_10_ADC_SENSOR_AMP_OFFSET 0x10 00495 #define RF22_ADCOFFS 0x0f 00496 00497 // RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION 0x12 00498 #define RF22_TSRANGE 0xc0 00499 #define RF22_TSRANGE_M64_64C 0x00 00500 #define RF22_TSRANGE_M64_192C 0x40 00501 #define RF22_TSRANGE_0_128C 0x80 00502 #define RF22_TSRANGE_M40_216F 0xc0 00503 #define RF22_ENTSOFFS 0x20 00504 #define RF22_ENTSTRIM 0x10 00505 #define RF22_TSTRIM 0x0f 00506 00507 // RF22_REG_14_WAKEUP_TIMER_PERIOD1 0x14 00508 #define RF22_WTR 0x3c 00509 #define RF22_WTD 0x03 00510 00511 // RF22_REG_30_DATA_ACCESS_CONTROL 0x30 00512 #define RF22_ENPACRX 0x80 00513 #define RF22_LSBFRST 0x40 00514 #define RF22_CRCDONLY 0x20 00515 #define RF22_ENPACTX 0x08 00516 #define RF22_ENCRC 0x04 00517 #define RF22_CRC 0x03 00518 #define RF22_CRC_CCITT 0x00 00519 #define RF22_CRC_CRC_16_IBM 0x01 00520 #define RF22_CRC_IEC_16 0x02 00521 #define RF22_CRC_BIACHEVA 0x03 00522 00523 // RF22_REG_32_HEADER_CONTROL1 0x32 00524 #define RF22_BCEN 0xf0 00525 #define RF22_BCEN_NONE 0x00 00526 #define RF22_BCEN_HEADER0 0x10 00527 #define RF22_BCEN_HEADER1 0x20 00528 #define RF22_BCEN_HEADER2 0x40 00529 #define RF22_BCEN_HEADER3 0x80 00530 #define RF22_HDCH 0x0f 00531 #define RF22_HDCH_NONE 0x00 00532 #define RF22_HDCH_HEADER0 0x01 00533 #define RF22_HDCH_HEADER1 0x02 00534 #define RF22_HDCH_HEADER2 0x04 00535 #define RF22_HDCH_HEADER3 0x08 00536 00537 // RF22_REG_33_HEADER_CONTROL2 0x33 00538 #define RF22_HDLEN 0x70 00539 #define RF22_HDLEN_0 0x00 00540 #define RF22_HDLEN_1 0x10 00541 #define RF22_HDLEN_2 0x20 00542 #define RF22_HDLEN_3 0x30 00543 #define RF22_HDLEN_4 0x40 00544 #define RF22_FIXPKLEN 0x08 00545 #define RF22_SYNCLEN 0x06 00546 #define RF22_SYNCLEN_1 0x00 00547 #define RF22_SYNCLEN_2 0x02 00548 #define RF22_SYNCLEN_3 0x04 00549 #define RF22_SYNCLEN_4 0x06 00550 #define RF22_PREALEN8 0x01 00551 00552 // RF22_REG_6D_TX_POWER 0x6d 00553 #define RF22_TXPOW 0x07 00554 #define RF22_TXPOW_4X31 0x08 // Not used in RFM22B 00555 #define RF22_TXPOW_1DBM 0x00 00556 #define RF22_TXPOW_2DBM 0x01 00557 #define RF22_TXPOW_5DBM 0x02 00558 #define RF22_TXPOW_8DBM 0x03 00559 #define RF22_TXPOW_11DBM 0x04 00560 #define RF22_TXPOW_14DBM 0x05 00561 #define RF22_TXPOW_17DBM 0x06 00562 #define RF22_TXPOW_20DBM 0x07 00563 // IN RFM23B 00564 #define RF22_TXPOW_LNA_SW 0x08 00565 00566 // RF22_REG_71_MODULATION_CONTROL2 0x71 00567 #define RF22_TRCLK 0xc0 00568 #define RF22_TRCLK_NONE 0x00 00569 #define RF22_TRCLK_GPIO 0x40 00570 #define RF22_TRCLK_SDO 0x80 00571 #define RF22_TRCLK_NIRQ 0xc0 00572 #define RF22_DTMOD 0x30 00573 #define RF22_DTMOD_DIRECT_GPIO 0x00 00574 #define RF22_DTMOD_DIRECT_SDI 0x10 00575 #define RF22_DTMOD_FIFO 0x20 00576 #define RF22_DTMOD_PN9 0x30 00577 #define RF22_ENINV 0x08 00578 #define RF22_FD8 0x04 00579 #define RF22_MODTYP 0x30 00580 #define RF22_MODTYP_UNMODULATED 0x00 00581 #define RF22_MODTYP_OOK 0x01 00582 #define RF22_MODTYP_FSK 0x02 00583 #define RF22_MODTYP_GFSK 0x03 00584 00585 // RF22_REG_75_FREQUENCY_BAND_SELECT 0x75 00586 #define RF22_SBSEL 0x40 00587 #define RF22_HBSEL 0x20 00588 #define RF22_FB 0x1f 00589 00590 ///////////////////////////////////////////////////////////////////// 00591 /// \class RF22 RF22.h <RF22.h> 00592 /// \brief Send and receive unaddressed, unreliable datagrams. 00593 /// 00594 /// This base class provides basic functions for sending and receiving unaddressed, 00595 /// unreliable datagrams of arbitrary length to 255 octets per packet. 00596 /// 00597 /// Subclasses may use this class to implement reliable, addressed datagrams and streams, 00598 /// mesh routers, repeaters, translators etc. 00599 /// 00600 /// On transmission, the TO and FROM addresses default to 0x00, unless changed by a subclass. 00601 /// On reception the TO addressed is checked against the node address (defaults to 0x00) or the 00602 /// broadcast address (which is 0xff). The ID and FLAGS are set to 0, and not checked by this class. 00603 /// This permits use of the this base RF22 class as an 00604 /// unaddresed, unreliable datagram service. Subclasses are expected to change this behaviour to 00605 /// add node address, ids, retransmission etc 00606 /// 00607 /// Naturally, for any 2 radios to communicate that must be configured to use the same frequence and 00608 /// modulation scheme. 00609 class RF22 00610 { 00611 public: 00612 00613 /// \brief Defines register values for a set of modem configuration registers 00614 /// 00615 /// Defines register values for a set of modem configuration registers 00616 /// that can be passed to setModemConfig() 00617 /// if none of the choices in ModemConfigChoice suit your need 00618 /// setModemConfig() writes the register values to the appropriate RF22 registers 00619 /// to set the desired modulation type, data rate and deviation/bandwidth. 00620 /// Suitable values for these registers can be computed using the register calculator at 00621 /// "http://www.hoperf.com/upfile/RF22B 23B 31B 42B 43B Register Settings_RevB1-v5.xls" 00622 typedef struct 00623 { 00624 uint8_t reg_1c; ///< Value for register RF22_REG_1C_IF_FILTER_BANDWIDTH 00625 uint8_t reg_1f; ///< Value for register RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE 00626 uint8_t reg_20; ///< Value for register RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE 00627 uint8_t reg_21; ///< Value for register RF22_REG_21_CLOCK_RECOVERY_OFFSET2 00628 uint8_t reg_22; ///< Value for register RF22_REG_22_CLOCK_RECOVERY_OFFSET1 00629 uint8_t reg_23; ///< Value for register RF22_REG_23_CLOCK_RECOVERY_OFFSET0 00630 uint8_t reg_24; ///< Value for register RF22_REG_24_CLOCK_RECOVERY_TIMING_LOOP_GAIN1 00631 uint8_t reg_25; ///< Value for register RF22_REG_25_CLOCK_RECOVERY_TIMING_LOOP_GAIN0 00632 uint8_t reg_2c; ///< Value for register RF22_REG_2C_OOK_COUNTER_VALUE_1 00633 uint8_t reg_2d; ///< Value for register RF22_REG_2D_OOK_COUNTER_VALUE_2 00634 uint8_t reg_2e; ///< Value for register RF22_REG_2E_SLICER_PEAK_HOLD 00635 uint8_t reg_58; ///< Value for register RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING 00636 uint8_t reg_69; ///< Value for register RF22_REG_69_AGC_OVERRIDE1 00637 uint8_t reg_6e; ///< Value for register RF22_REG_6E_TX_DATA_RATE1 00638 uint8_t reg_6f; ///< Value for register RF22_REG_6F_TX_DATA_RATE0 00639 uint8_t reg_70; ///< Value for register RF22_REG_70_MODULATION_CONTROL1 00640 uint8_t reg_71; ///< Value for register RF22_REG_71_MODULATION_CONTROL2 00641 uint8_t reg_72; ///< Value for register RF22_REG_72_FREQUENCY_DEVIATION 00642 } ModemConfig; 00643 00644 /// Choices for setModemConfig() for a selected subset of common modulation types, 00645 /// and data rates. If you need another configuration, use the register calculator at 00646 /// "http://www.hoperf.com/upfile/RF22B 23B 31B 42B 43B Register Settings_RevB1-v5.xls" 00647 /// and call setModemRegisters() with your desired settings 00648 /// These are indexes into _modemConfig 00649 typedef enum 00650 { 00651 UnmodulatedCarrier = 0, ///< Unmodulated carrier for testing 00652 FSK_PN9_Rb2Fd5, ///< FSK, No Manchester, Rb = 2kbs, Fd = 5kHz, PN9 random modulation for testing 00653 00654 FSK_Rb2Fd5, ///< FSK, No Manchester, Rb = 2kbs, Fd = 5kHz 00655 FSK_Rb2_4Fd36, ///< FSK, No Manchester, Rb = 2.4kbs, Fd = 36kHz 00656 FSK_Rb4_8Fd45, ///< FSK, No Manchester, Rb = 4.8kbs, Fd = 45kHz 00657 FSK_Rb9_6Fd45, ///< FSK, No Manchester, Rb = 9.6kbs, Fd = 45kHz 00658 FSK_Rb19_2Fd9_6, ///< FSK, No Manchester, Rb = 19.2kbs, Fd = 9.6kHz 00659 FSK_Rb38_4Fd19_6, ///< FSK, No Manchester, Rb = 38.4kbs, Fd = 19.6kHz 00660 FSK_Rb57_6Fd28_8, ///< FSK, No Manchester, Rb = 57.6kbs, Fd = 28.8kHz 00661 FSK_Rb125Fd125, ///< FSK, No Manchester, Rb = 125kbs, Fd = 125kHz 00662 00663 GFSK_Rb2Fd5, ///< GFSK, No Manchester, Rb = 2kbs, Fd = 5kHz 00664 GFSK_Rb2_4Fd36, ///< GFSK, No Manchester, Rb = 2.4kbs, Fd = 36kHz 00665 GFSK_Rb4_8Fd45, ///< GFSK, No Manchester, Rb = 4.8kbs, Fd = 45kHz 00666 GFSK_Rb9_6Fd45, ///< GFSK, No Manchester, Rb = 9.6kbs, Fd = 45kHz 00667 GFSK_Rb19_2Fd9_6, ///< GFSK, No Manchester, Rb = 19.2kbs, Fd = 9.6kHz 00668 GFSK_Rb38_4Fd19_6, ///< GFSK, No Manchester, Rb = 38.4kbs, Fd = 19.6kHz 00669 GFSK_Rb57_6Fd28_8, ///< GFSK, No Manchester, Rb = 57.6kbs, Fd = 28.8kHz 00670 GFSK_Rb125Fd125, ///< GFSK, No Manchester, Rb = 125kbs, Fd = 125kHz 00671 00672 OOK_Rb1_2Bw75, ///< OOK, No Manchester, Rb = 1.2kbs, Rx Bandwidth = 75kHz 00673 OOK_Rb2_4Bw335, ///< OOK, No Manchester, Rb = 2.4kbs, Rx Bandwidth = 335kHz 00674 OOK_Rb4_8Bw335, ///< OOK, No Manchester, Rb = 4.8kbs, Rx Bandwidth = 335kHz 00675 OOK_Rb9_6Bw335, ///< OOK, No Manchester, Rb = 9.6kbs, Rx Bandwidth = 335kHz 00676 OOK_Rb19_2Bw335, ///< OOK, No Manchester, Rb = 19.2kbs, Rx Bandwidth = 335kHz 00677 OOK_Rb38_4Bw335, ///< OOK, No Manchester, Rb = 38.4kbs, Rx Bandwidth = 335kHz 00678 OOK_Rb40Bw335 ///< OOK, No Manchester, Rb = 40kbs, Rx Bandwidth = 335kHz 00679 } ModemConfigChoice; 00680 00681 /// Constructor. You can have multiple instances, but each instance must have its own 00682 /// interrupt and slave select pin. After constructing, you must call init() to initialise the intnerface 00683 /// and the radio module 00684 /// \param[in] slaveSelectPin the Arduino pin number of the output to use to select the RF22 before 00685 /// accessing it 00686 /// \param[in] interrupt The interrupt number to use. Default is interrupt 0 (Arduino input pin 2) 00687 RF22(uint8_t slaveSelectPin = 10, uint8_t interrupt = 0); 00688 00689 /// Initialises this instance and the radio module connected to it. 00690 /// The following steps are taken: 00691 /// - Initialise the slave select pin and the SPI interface library 00692 /// - Software reset the RF22 module 00693 /// - Checks the connected RF22 module is either a RF22_DEVICE_TYPE_RX_TRX or a RF22_DEVICE_TYPE_TX 00694 /// - Attaches an interrupt handler 00695 /// - Configures the RF22 module 00696 /// - Sets the frequncy to 434.0 MHz 00697 /// - Sets the modem data rate to FSK_Rb2_4Fd36 00698 /// \return true if everything was successful 00699 boolean init(); 00700 00701 /// Issues a software reset to the 00702 /// RF22 module. Blocks for 1ms to ensure the reset is complete. 00703 void reset(); 00704 00705 /// Reads a single register from the RF22 00706 /// \param[in] reg Register number, one of RF22_REG_* 00707 /// \return The value of the register 00708 uint8_t spiRead(uint8_t reg); 00709 00710 /// Writes a single byte to the RF22 00711 /// \param[in] reg Register number, one of RF22_REG_* 00712 /// \param[in] val The value to write 00713 void spiWrite(uint8_t reg, uint8_t val); 00714 00715 /// Reads a number of consecutive registers from the RF22 using burst read mode 00716 /// \param[in] reg Register number of the first register, one of RF22_REG_* 00717 /// \param[in] dest Array to write the register values to. Must be at least len bytes 00718 /// \param[in] len Number of bytes to read 00719 void spiBurstRead(uint8_t reg, uint8_t* dest, uint8_t len); 00720 00721 /// Write a number of consecutive registers using burst write mode 00722 /// \param[in] reg Register number of the first register, one of RF22_REG_* 00723 /// \param[in] src Array of new register values to write. Must be at least len bytes 00724 /// \param[in] len Number of bytes to write 00725 void spiBurstWrite(uint8_t reg, uint8_t* src, uint8_t len); 00726 00727 /// Reads and returns the device status register RF22_REG_02_DEVICE_STATUS 00728 /// \return The value of the device status register 00729 uint8_t statusRead(); 00730 00731 /// Reads a value from the on-chip analog-digital converter 00732 /// \param[in] adcsel Selects the ADC input to measure. One of RF22_ADCSEL_*. Defaults to the 00733 /// internal temperature sensor 00734 /// \param[in] adcref Specifies the refernce voltage to use. One of RF22_ADCREF_*. 00735 /// Defaults to the internal bandgap voltage. 00736 /// \param[in] adcgain Amplifier gain selection. 00737 /// \param[in] adcoffs Amplifier offseet (0 to 15). 00738 /// \return The analog value. 0 to 255. 00739 uint8_t adcRead(uint8_t adcsel = RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR, 00740 uint8_t adcref = RF22_ADCREF_BANDGAP_VOLTAGE, 00741 uint8_t adcgain = 0, 00742 uint8_t adcoffs = 0); 00743 00744 /// Reads the on-chip temperature sensoer 00745 /// \param[in] tsrange Specifies the temperature range to use. One of RF22_TSRANGE_* 00746 /// \param[in] tvoffs Specifies the temperature value offset. This is actually signed value 00747 /// added to the measured temperature value 00748 /// \return The measured temperature. 00749 uint8_t temperatureRead(uint8_t tsrange = RF22_TSRANGE_M64_64C, uint8_t tvoffs = 0); 00750 00751 /// Reads the wakeup timer value in registers RF22_REG_17_WAKEUP_TIMER_VALUE1 00752 /// and RF22_REG_18_WAKEUP_TIMER_VALUE2 00753 /// \return The wakeup timer value 00754 uint16_t wutRead(); 00755 00756 /// Sets the wakeup timer period registers RF22_REG_14_WAKEUP_TIMER_PERIOD1, 00757 /// RF22_REG_15_WAKEUP_TIMER_PERIOD2 and RF22_REG_16_WAKEUP_TIMER_PERIOD3 00758 /// \param[in] wtm Wakeup timer mantissa value 00759 /// \param[in] wtr Wakeup timer exponent R value 00760 /// \param[in] wtd Wakeup timer exponent D value 00761 void setWutPeriod(uint16_t wtm, uint8_t wtr = 0, uint8_t wtd = 0); 00762 00763 /// Sets the transmitter and receiver centre frequency 00764 /// \param[in] centre Frequency in MHz. 240.0 to 960.0. Caution, some versions of RF22 and derivatives 00765 /// implemented more restricted frequency ranges. 00766 /// \return true if the selected frquency centre + (fhch * fhs) is within range 00767 boolean setFrequency(float centre); 00768 00769 /// Sets the frequency hopping step size. 00770 /// \param[in] fhs Frequency Hopping step size in 10kHz increments 00771 /// \return true if centre + (fhch * fhs) is within limits 00772 boolean setFHStepSize(uint8_t fhs); 00773 00774 /// Sets the frequncy hopping channel. Adds fhch * fhs to centre frequency 00775 /// \param[in] fhch The channel number 00776 /// \return true if the selected frquency centre + (fhch * fhs) is within range 00777 boolean setFHChannel(uint8_t fhch); 00778 00779 /// Reads and returns the current RSSI value from register RF22_REG_26_RSSI 00780 /// \return The current RSSI value 00781 uint8_t rssiRead(); 00782 00783 /// Reads and returns the current EZMAC value from register RF22_REG_31_EZMAC_STATUS 00784 /// \return The current EZMAC value 00785 uint8_t ezmacStatusRead(); 00786 00787 /// Sets the parameters for the RF22 Idle mode in register RF22_REG_07_OPERATING_MODE. 00788 /// Idle mode is the mode the RF22 wil be in when not transmitting or receiving. The default idle mode 00789 /// is RF22_XTON ie READY mode. 00790 /// \param[in] mode MAsk of mode bits, using RF22_SWRES, RF22_ENLBD, RF22_ENWT, 00791 /// RF22_X32KSEL, RF22_PLLON, RF22_XTON. 00792 void setMode(uint8_t mode); 00793 00794 /// If current mode is Rx or Tx changes it to Idle. If the transmitter or receiver is running, 00795 /// disables them. 00796 void setModeIdle(); 00797 00798 /// If current mode is Tx or Idle, changes it to Rx. 00799 /// Starts the receiver in the RF22. 00800 void setModeRx(); 00801 00802 /// If current mode is Rx or Idle, changes it to Rx. 00803 /// Starts the transmitter in the RF22. 00804 void setModeTx(); 00805 00806 /// Sets the transmitter power output level in register RF22_REG_6D_TX_POWER. 00807 /// Be a good neighbour and set the lowest power level you need. 00808 /// After init(), the power wil be set to RF22_TXPOW_8DBM. 00809 /// Caution: In some countries you may only select RF22_TXPOW_17DBM if you 00810 /// are also using frequency hopping. 00811 /// \param[in] power Transmitter power level, one of RF22_TXPOW_* 00812 void setTxPower(uint8_t power); 00813 00814 /// Sets all the registered required to configure the data modem in the RF22, including the data rate, 00815 /// bandwidths etc. You cas use this to configure the modem with custom configuraitons if none of the 00816 /// canned configurations in ModemConfigChoice suit you. 00817 /// \param[in] config A ModemConfig structure containing values for the modem configuration registers. 00818 void setModemRegisters(ModemConfig* config); 00819 00820 /// Select one of the predefined modem configurations. If you need a modem configuration not provided 00821 /// here, use setModemRegisters() with your own ModemConfig. 00822 /// \param[in] index The configuration choice. 00823 /// \return true if index is a valid choice. 00824 boolean setModemConfig(ModemConfigChoice index); 00825 00826 /// Starts the receiver and checks whether a received message is available. 00827 /// This can be called multiple times in a timeout loop 00828 /// \return true if a complete, valid message has been received and is able to be retrieved by 00829 /// recv() 00830 boolean available(); 00831 00832 /// Starts the receiver and blocks until a valid received 00833 /// message is available. 00834 void waitAvailable(); 00835 00836 /// Starts the receiver and blocks until a received message is available or a timeout 00837 /// \param[in] timeout Maximum time to wait in milliseconds. 00838 /// \return true if a message is available 00839 bool waitAvailableTimeout(uint16_t timeout); 00840 00841 /// Turns the receiver on if it not already on. 00842 /// If there is a valid message available, copy it to buf and return true 00843 /// else return false. 00844 /// If a message is copied, *len is set to the length (Caution, 0 length messages are permitted). 00845 /// You should be sure to call this function frequently enough to not miss any messages 00846 /// It is recommended that you call it in your main loop. 00847 /// \param[in] buf Location to copy the received message 00848 /// \param[in,out] len Pointer to available space in buf. Set to the actual number of octets copied. 00849 /// \return true if a valid message was copied to buf 00850 boolean recv(uint8_t* buf, uint8_t* len); 00851 00852 /// Loads a message into the transmitter and starts the transmitter. Note that a message length 00853 /// of 0 is permitted, in which case data may be NULL. 00854 /// \param[in] data Array of data to be sent 00855 /// \param[in] len Number of bytes of data to send. 00856 /// \return true 00857 boolean send(uint8_t* data, uint8_t len); 00858 00859 /// Blocks until the current message 00860 /// (if any) has been completely sent 00861 void waitPacketSent(); 00862 00863 /// Tells the receiver to accept messages with any TO address, not just messages 00864 /// addressed to this node or the broadcast address 00865 /// \param[in] promiscuous true if you wish to receive messages with any TO address 00866 void setPromiscuous(boolean promiscuous); 00867 00868 /// Returns the TO header of the last received message 00869 /// \return The TO header 00870 uint8_t headerTo(); 00871 00872 /// Returns the FROM header of the last received message 00873 /// \return The FROM header 00874 uint8_t headerFrom(); 00875 00876 /// Returns the ID header of the last received message 00877 /// \return The ID header 00878 uint8_t headerId(); 00879 00880 /// Returns the FLAGS header of the last received message 00881 /// \return The FLAGS header 00882 uint8_t headerFlags(); 00883 00884 /// Returns the RSSI (Receiver Signal Strength Indicator) 00885 /// of the last received message. This measurement is taken when 00886 /// the preamble has been received. It is a (non-linear) measure of the received signal strength. 00887 /// \return The RSSI 00888 uint8_t lastRssi(); 00889 00890 protected: 00891 /// Sets the message preamble length in RF22_REG_34_PREAMBLE_LENGTH 00892 /// \param[in] nibbles Preamble length in nibbles of 4 bits each. 00893 void setPreambleLength(uint8_t nibbles); 00894 00895 /// Sets the sync words for transmit and receive in registers RF22_REG_36_SYNC_WORD3 00896 /// to RF22_REG_39_SYNC_WORD0 00897 /// \param[in] syncWords Array of sync words 00898 /// \param[in] len Number of sync words to set 00899 void setSyncWords(uint8_t* syncWords, uint8_t len); 00900 00901 /// This is a low level function to handle the interrupts for one instance of RF22. 00902 /// Called automatically by isr0() and isr1() 00903 /// Should not need to be called. 00904 void handleInterrupt(); 00905 00906 /// Clears the receiver buffer. 00907 /// Internal use only 00908 void clearRxBuf(); 00909 00910 /// Clears the transmitter buffer 00911 /// Internal use only 00912 void clearTxBuf(); 00913 00914 /// Fills the transmitter buffer with the data of a mesage to be sent 00915 /// \param[in] data Array of data bytes to be sent (0 to 255) 00916 /// \param[in] len Number of data bytes in data 00917 /// \return true 00918 boolean fillTxBuf(uint8_t* data, uint8_t len); 00919 00920 /// Appends the transmitter buffer with the data of a mesage to be sent 00921 /// \param[in] data Array of data bytes to be sent (0 to 255) 00922 /// \param[in] len Number of data bytes in data 00923 /// \return false if the resulting message would exceed RF22_MAX_MESSAGE_LEN, else true 00924 boolean appendTxBuf(uint8_t* data, uint8_t len); 00925 00926 /// Internal function to load the next fragment of 00927 /// the current message into the transmitter FIFO 00928 /// Internal use only 00929 void sendNextFragment(); 00930 00931 /// function to copy the next fragment from 00932 /// the receiver FIF) into the receiver buffer 00933 void readNextFragment(); 00934 00935 /// Clears the RF22 Rx and Tx FIFOs 00936 /// Internal use only 00937 void resetFifos(); 00938 00939 /// Clears the RF22 Rx FIFO 00940 /// Internal use only 00941 void resetRxFifo(); 00942 00943 /// Clears the RF22 Tx FIFO 00944 /// Internal use only 00945 void resetTxFifo(); 00946 00947 /// This function will be called by handleInterrupt() if an RF22 external interrupt occurs. 00948 /// This can only happen if external interrupts are enabled in the RF22 00949 /// (which they are not by default). 00950 /// Subclasses may override this function to get control when an RF22 external interrupt occurs. 00951 virtual void handleExternalInterrupt(); 00952 00953 /// This function will be called by handleInterrupt() if an RF22 wakeup timer interrupt occurs. 00954 /// This can only happen if wakeup timer interrupts are enabled in the RF22 00955 /// (which they are not by default). 00956 /// Subclasses may override this function to get control when an RF22 wakeup timer interrupt occurs. 00957 virtual void handleWakeupTimerInterrupt(); 00958 00959 /// Sets the TO header to be sent in all subsequent messages 00960 /// \param[in] to The new TO header value 00961 void setHeaderTo(uint8_t to); 00962 00963 /// Sets the FROM header to be sent in all subsequent messages 00964 /// \param[in] from The new FROM header value 00965 void setHeaderFrom(uint8_t from); 00966 00967 /// Sets the ID header to be sent in all subsequent messages 00968 /// \param[in] id The new ID header value 00969 void setHeaderId(uint8_t id); 00970 00971 /// Sets the FLAGS header to be sent in all subsequent messages 00972 /// \param[in] flags The new FLAGS header value 00973 void setHeaderFlags(uint8_t flags); 00974 00975 /// Start the transmission of the contents 00976 /// of the Tx buffer 00977 void startTransmit(); 00978 00979 /// ReStart the transmission of the contents 00980 /// of the Tx buffer after a atransmission failure 00981 void restartTransmit(); 00982 00983 private: 00984 /// Low level interrupt service routine for RF22 connected to interrupt 0 00985 static void isr0(); 00986 00987 /// Low level interrupt service routine for RF22 connected to interrupt 1 00988 static void isr1(); 00989 00990 /// Array of instances connected to interrupts 0 and 1 00991 static RF22* _RF22ForInterrupt[]; 00992 00993 uint8_t _mode; // One of RF22_MODE_* 00994 00995 uint8_t _idleMode; 00996 uint8_t _slaveSelectPin; 00997 uint8_t _interrupt; 00998 uint8_t _deviceType; 00999 01000 // These volatile members may get changed in the interrupt service routine 01001 uint8_t _buf[RF22_MAX_MESSAGE_LEN]; 01002 volatile uint8_t _bufLen; 01003 01004 volatile boolean _rxBufValid; 01005 01006 volatile boolean _txPacketSent; 01007 volatile uint8_t _txBufSentIndex; 01008 01009 volatile uint16_t _rxBad; 01010 volatile uint16_t _rxGood; 01011 volatile uint16_t _txGood; 01012 01013 volatile uint8_t _lastRssi; 01014 }; 01015 01016 01017 #endif
1.5.6