Point Labs / RadioHeadLite

This driver is a stripped down version of the Radiohead 1.45 driver, and covers fewer radios. Threading and an event queue have been added to make the ISR's more stable across architectures. Specifically The STM32L4 parts

Dependents:   Threaded_LoRa_Modem

RH_RF22.h@7:250d1c72df36, 2021-06-23 (annotated)

Committer:
rlanders73
Date:
Wed Jun 23 15:53:12 2021 +0000
Revision:
7:250d1c72df36
Parent:
0:ab4e012489ef 
explicitly not disabling interrupts for mbed

Who changed what in which revision?

UserRevisionLine numberNew contents of line
davidr99 0:ab4e012489ef 1 // RH_RF22.h
davidr99 0:ab4e012489ef 2 // Author: Mike McCauley (mikem@airspayce.com)
davidr99 0:ab4e012489ef 3 // Copyright (C) 2011 Mike McCauley
davidr99 0:ab4e012489ef 4 // $Id: RH_RF22.h,v 1.27 2015/05/17 00:11:26 mikem Exp $
davidr99 0:ab4e012489ef 5 //
davidr99 0:ab4e012489ef 6
davidr99 0:ab4e012489ef 7 #ifndef RH_RF22_h
davidr99 0:ab4e012489ef 8 #define RH_RF22_h
davidr99 0:ab4e012489ef 9
davidr99 0:ab4e012489ef 10 #include <RHGenericSPI.h>
davidr99 0:ab4e012489ef 11 #include <RHSPIDriver.h>
davidr99 0:ab4e012489ef 12
davidr99 0:ab4e012489ef 13 // This is the maximum number of interrupts the library can support
davidr99 0:ab4e012489ef 14 // Most Arduinos can handle 2, Megas can handle more
davidr99 0:ab4e012489ef 15 #define RH_RF22_NUM_INTERRUPTS 3
davidr99 0:ab4e012489ef 16
davidr99 0:ab4e012489ef 17 // This is the bit in the SPI address that marks it as a write
davidr99 0:ab4e012489ef 18 #define RH_RF22_SPI_WRITE_MASK 0x80
davidr99 0:ab4e012489ef 19
davidr99 0:ab4e012489ef 20 // This is the maximum message length that can be supported by this library. Limited by
davidr99 0:ab4e012489ef 21 // the single message length octet in the header.
davidr99 0:ab4e012489ef 22 // Yes, 255 is correct even though the FIFO size in the RF22 is only
davidr99 0:ab4e012489ef 23 // 64 octets. We use interrupts to refill the Tx FIFO during transmission and to empty the
davidr99 0:ab4e012489ef 24 // Rx FIFO during reception
davidr99 0:ab4e012489ef 25 // Can be pre-defined to a smaller size (to save SRAM) prior to including this header
davidr99 0:ab4e012489ef 26 #ifndef RH_RF22_MAX_MESSAGE_LEN
davidr99 0:ab4e012489ef 27 //#define RH_RF22_MAX_MESSAGE_LEN 255
davidr99 0:ab4e012489ef 28 #define RH_RF22_MAX_MESSAGE_LEN 50
davidr99 0:ab4e012489ef 29 #endif
davidr99 0:ab4e012489ef 30
davidr99 0:ab4e012489ef 31 // Max number of octets the RF22 Rx and Tx FIFOs can hold
davidr99 0:ab4e012489ef 32 #define RH_RF22_FIFO_SIZE 64
davidr99 0:ab4e012489ef 33
davidr99 0:ab4e012489ef 34 // These values we set for FIFO thresholds (4, 55) are actually the same as the POR values
davidr99 0:ab4e012489ef 35 #define RH_RF22_TXFFAEM_THRESHOLD 4
davidr99 0:ab4e012489ef 36 #define RH_RF22_RXFFAFULL_THRESHOLD 55
davidr99 0:ab4e012489ef 37
davidr99 0:ab4e012489ef 38 // Number of registers to be passed to setModemConfig(). Obsolete.
davidr99 0:ab4e012489ef 39 #define RH_RF22_NUM_MODEM_CONFIG_REGS 18
davidr99 0:ab4e012489ef 40
davidr99 0:ab4e012489ef 41 // Register names
davidr99 0:ab4e012489ef 42 #define RH_RF22_REG_00_DEVICE_TYPE 0x00
davidr99 0:ab4e012489ef 43 #define RH_RF22_REG_01_VERSION_CODE 0x01
davidr99 0:ab4e012489ef 44 #define RH_RF22_REG_02_DEVICE_STATUS 0x02
davidr99 0:ab4e012489ef 45 #define RH_RF22_REG_03_INTERRUPT_STATUS1 0x03
davidr99 0:ab4e012489ef 46 #define RH_RF22_REG_04_INTERRUPT_STATUS2 0x04
davidr99 0:ab4e012489ef 47 #define RH_RF22_REG_05_INTERRUPT_ENABLE1 0x05
davidr99 0:ab4e012489ef 48 #define RH_RF22_REG_06_INTERRUPT_ENABLE2 0x06
davidr99 0:ab4e012489ef 49 #define RH_RF22_REG_07_OPERATING_MODE1 0x07
davidr99 0:ab4e012489ef 50 #define RH_RF22_REG_08_OPERATING_MODE2 0x08
davidr99 0:ab4e012489ef 51 #define RH_RF22_REG_09_OSCILLATOR_LOAD_CAPACITANCE 0x09
davidr99 0:ab4e012489ef 52 #define RH_RF22_REG_0A_UC_OUTPUT_CLOCK 0x0a
davidr99 0:ab4e012489ef 53 #define RH_RF22_REG_0B_GPIO_CONFIGURATION0 0x0b
davidr99 0:ab4e012489ef 54 #define RH_RF22_REG_0C_GPIO_CONFIGURATION1 0x0c
davidr99 0:ab4e012489ef 55 #define RH_RF22_REG_0D_GPIO_CONFIGURATION2 0x0d
davidr99 0:ab4e012489ef 56 #define RH_RF22_REG_0E_IO_PORT_CONFIGURATION 0x0e
davidr99 0:ab4e012489ef 57 #define RH_RF22_REG_0F_ADC_CONFIGURATION 0x0f
davidr99 0:ab4e012489ef 58 #define RH_RF22_REG_10_ADC_SENSOR_AMP_OFFSET 0x10
davidr99 0:ab4e012489ef 59 #define RH_RF22_REG_11_ADC_VALUE 0x11
davidr99 0:ab4e012489ef 60 #define RH_RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION 0x12
davidr99 0:ab4e012489ef 61 #define RH_RF22_REG_13_TEMPERATURE_VALUE_OFFSET 0x13
davidr99 0:ab4e012489ef 62 #define RH_RF22_REG_14_WAKEUP_TIMER_PERIOD1 0x14
davidr99 0:ab4e012489ef 63 #define RH_RF22_REG_15_WAKEUP_TIMER_PERIOD2 0x15
davidr99 0:ab4e012489ef 64 #define RH_RF22_REG_16_WAKEUP_TIMER_PERIOD3 0x16
davidr99 0:ab4e012489ef 65 #define RH_RF22_REG_17_WAKEUP_TIMER_VALUE1 0x17
davidr99 0:ab4e012489ef 66 #define RH_RF22_REG_18_WAKEUP_TIMER_VALUE2 0x18
davidr99 0:ab4e012489ef 67 #define RH_RF22_REG_19_LDC_MODE_DURATION 0x19
davidr99 0:ab4e012489ef 68 #define RH_RF22_REG_1A_LOW_BATTERY_DETECTOR_THRESHOLD 0x1a
davidr99 0:ab4e012489ef 69 #define RH_RF22_REG_1B_BATTERY_VOLTAGE_LEVEL 0x1b
davidr99 0:ab4e012489ef 70 #define RH_RF22_REG_1C_IF_FILTER_BANDWIDTH 0x1c
davidr99 0:ab4e012489ef 71 #define RH_RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE 0x1d
davidr99 0:ab4e012489ef 72 #define RH_RF22_REG_1E_AFC_TIMING_CONTROL 0x1e
davidr99 0:ab4e012489ef 73 #define RH_RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE 0x1f
davidr99 0:ab4e012489ef 74 #define RH_RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE 0x20
davidr99 0:ab4e012489ef 75 #define RH_RF22_REG_21_CLOCK_RECOVERY_OFFSET2 0x21
davidr99 0:ab4e012489ef 76 #define RH_RF22_REG_22_CLOCK_RECOVERY_OFFSET1 0x22
davidr99 0:ab4e012489ef 77 #define RH_RF22_REG_23_CLOCK_RECOVERY_OFFSET0 0x23
davidr99 0:ab4e012489ef 78 #define RH_RF22_REG_24_CLOCK_RECOVERY_TIMING_LOOP_GAIN1 0x24
davidr99 0:ab4e012489ef 79 #define RH_RF22_REG_25_CLOCK_RECOVERY_TIMING_LOOP_GAIN0 0x25
davidr99 0:ab4e012489ef 80 #define RH_RF22_REG_26_RSSI 0x26
davidr99 0:ab4e012489ef 81 #define RH_RF22_REG_27_RSSI_THRESHOLD 0x27
davidr99 0:ab4e012489ef 82 #define RH_RF22_REG_28_ANTENNA_DIVERSITY1 0x28
davidr99 0:ab4e012489ef 83 #define RH_RF22_REG_29_ANTENNA_DIVERSITY2 0x29
davidr99 0:ab4e012489ef 84 #define RH_RF22_REG_2A_AFC_LIMITER 0x2a
davidr99 0:ab4e012489ef 85 #define RH_RF22_REG_2B_AFC_CORRECTION_READ 0x2b
davidr99 0:ab4e012489ef 86 #define RH_RF22_REG_2C_OOK_COUNTER_VALUE_1 0x2c
davidr99 0:ab4e012489ef 87 #define RH_RF22_REG_2D_OOK_COUNTER_VALUE_2 0x2d
davidr99 0:ab4e012489ef 88 #define RH_RF22_REG_2E_SLICER_PEAK_HOLD 0x2e
davidr99 0:ab4e012489ef 89 #define RH_RF22_REG_30_DATA_ACCESS_CONTROL 0x30
davidr99 0:ab4e012489ef 90 #define RH_RF22_REG_31_EZMAC_STATUS 0x31
davidr99 0:ab4e012489ef 91 #define RH_RF22_REG_32_HEADER_CONTROL1 0x32
davidr99 0:ab4e012489ef 92 #define RH_RF22_REG_33_HEADER_CONTROL2 0x33
davidr99 0:ab4e012489ef 93 #define RH_RF22_REG_34_PREAMBLE_LENGTH 0x34
davidr99 0:ab4e012489ef 94 #define RH_RF22_REG_35_PREAMBLE_DETECTION_CONTROL1 0x35
davidr99 0:ab4e012489ef 95 #define RH_RF22_REG_36_SYNC_WORD3 0x36
davidr99 0:ab4e012489ef 96 #define RH_RF22_REG_37_SYNC_WORD2 0x37
davidr99 0:ab4e012489ef 97 #define RH_RF22_REG_38_SYNC_WORD1 0x38
davidr99 0:ab4e012489ef 98 #define RH_RF22_REG_39_SYNC_WORD0 0x39
davidr99 0:ab4e012489ef 99 #define RH_RF22_REG_3A_TRANSMIT_HEADER3 0x3a
davidr99 0:ab4e012489ef 100 #define RH_RF22_REG_3B_TRANSMIT_HEADER2 0x3b
davidr99 0:ab4e012489ef 101 #define RH_RF22_REG_3C_TRANSMIT_HEADER1 0x3c
davidr99 0:ab4e012489ef 102 #define RH_RF22_REG_3D_TRANSMIT_HEADER0 0x3d
davidr99 0:ab4e012489ef 103 #define RH_RF22_REG_3E_PACKET_LENGTH 0x3e
davidr99 0:ab4e012489ef 104 #define RH_RF22_REG_3F_CHECK_HEADER3 0x3f
davidr99 0:ab4e012489ef 105 #define RH_RF22_REG_40_CHECK_HEADER2 0x40
davidr99 0:ab4e012489ef 106 #define RH_RF22_REG_41_CHECK_HEADER1 0x41
davidr99 0:ab4e012489ef 107 #define RH_RF22_REG_42_CHECK_HEADER0 0x42
davidr99 0:ab4e012489ef 108 #define RH_RF22_REG_43_HEADER_ENABLE3 0x43
davidr99 0:ab4e012489ef 109 #define RH_RF22_REG_44_HEADER_ENABLE2 0x44
davidr99 0:ab4e012489ef 110 #define RH_RF22_REG_45_HEADER_ENABLE1 0x45
davidr99 0:ab4e012489ef 111 #define RH_RF22_REG_46_HEADER_ENABLE0 0x46
davidr99 0:ab4e012489ef 112 #define RH_RF22_REG_47_RECEIVED_HEADER3 0x47
davidr99 0:ab4e012489ef 113 #define RH_RF22_REG_48_RECEIVED_HEADER2 0x48
davidr99 0:ab4e012489ef 114 #define RH_RF22_REG_49_RECEIVED_HEADER1 0x49
davidr99 0:ab4e012489ef 115 #define RH_RF22_REG_4A_RECEIVED_HEADER0 0x4a
davidr99 0:ab4e012489ef 116 #define RH_RF22_REG_4B_RECEIVED_PACKET_LENGTH 0x4b
davidr99 0:ab4e012489ef 117 #define RH_RF22_REG_50_ANALOG_TEST_BUS_SELECT 0x50
davidr99 0:ab4e012489ef 118 #define RH_RF22_REG_51_DIGITAL_TEST_BUS_SELECT 0x51
davidr99 0:ab4e012489ef 119 #define RH_RF22_REG_52_TX_RAMP_CONTROL 0x52
davidr99 0:ab4e012489ef 120 #define RH_RF22_REG_53_PLL_TUNE_TIME 0x53
davidr99 0:ab4e012489ef 121 #define RH_RF22_REG_55_CALIBRATION_CONTROL 0x55
davidr99 0:ab4e012489ef 122 #define RH_RF22_REG_56_MODEM_TEST 0x56
davidr99 0:ab4e012489ef 123 #define RH_RF22_REG_57_CHARGE_PUMP_TEST 0x57
davidr99 0:ab4e012489ef 124 #define RH_RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING 0x58
davidr99 0:ab4e012489ef 125 #define RH_RF22_REG_59_DIVIDER_CURRENT_TRIMMING 0x59
davidr99 0:ab4e012489ef 126 #define RH_RF22_REG_5A_VCO_CURRENT_TRIMMING 0x5a
davidr99 0:ab4e012489ef 127 #define RH_RF22_REG_5B_VCO_CALIBRATION 0x5b
davidr99 0:ab4e012489ef 128 #define RH_RF22_REG_5C_SYNTHESIZER_TEST 0x5c
davidr99 0:ab4e012489ef 129 #define RH_RF22_REG_5D_BLOCK_ENABLE_OVERRIDE1 0x5d
davidr99 0:ab4e012489ef 130 #define RH_RF22_REG_5E_BLOCK_ENABLE_OVERRIDE2 0x5e
davidr99 0:ab4e012489ef 131 #define RH_RF22_REG_5F_BLOCK_ENABLE_OVERRIDE3 0x5f
davidr99 0:ab4e012489ef 132 #define RH_RF22_REG_60_CHANNEL_FILTER_COEFFICIENT_ADDRESS 0x60
davidr99 0:ab4e012489ef 133 #define RH_RF22_REG_61_CHANNEL_FILTER_COEFFICIENT_VALUE 0x61
davidr99 0:ab4e012489ef 134 #define RH_RF22_REG_62_CRYSTAL_OSCILLATOR_POR_CONTROL 0x62
davidr99 0:ab4e012489ef 135 #define RH_RF22_REG_63_RC_OSCILLATOR_COARSE_CALIBRATION 0x63
davidr99 0:ab4e012489ef 136 #define RH_RF22_REG_64_RC_OSCILLATOR_FINE_CALIBRATION 0x64
davidr99 0:ab4e012489ef 137 #define RH_RF22_REG_65_LDO_CONTROL_OVERRIDE 0x65
davidr99 0:ab4e012489ef 138 #define RH_RF22_REG_66_LDO_LEVEL_SETTINGS 0x66
davidr99 0:ab4e012489ef 139 #define RH_RF22_REG_67_DELTA_SIGMA_ADC_TUNING1 0x67
davidr99 0:ab4e012489ef 140 #define RH_RF22_REG_68_DELTA_SIGMA_ADC_TUNING2 0x68
davidr99 0:ab4e012489ef 141 #define RH_RF22_REG_69_AGC_OVERRIDE1 0x69
davidr99 0:ab4e012489ef 142 #define RH_RF22_REG_6A_AGC_OVERRIDE2 0x6a
davidr99 0:ab4e012489ef 143 #define RH_RF22_REG_6B_GFSK_FIR_FILTER_COEFFICIENT_ADDRESS 0x6b
davidr99 0:ab4e012489ef 144 #define RH_RF22_REG_6C_GFSK_FIR_FILTER_COEFFICIENT_VALUE 0x6c
davidr99 0:ab4e012489ef 145 #define RH_RF22_REG_6D_TX_POWER 0x6d
davidr99 0:ab4e012489ef 146 #define RH_RF22_REG_6E_TX_DATA_RATE1 0x6e
davidr99 0:ab4e012489ef 147 #define RH_RF22_REG_6F_TX_DATA_RATE0 0x6f
davidr99 0:ab4e012489ef 148 #define RH_RF22_REG_70_MODULATION_CONTROL1 0x70
davidr99 0:ab4e012489ef 149 #define RH_RF22_REG_71_MODULATION_CONTROL2 0x71
davidr99 0:ab4e012489ef 150 #define RH_RF22_REG_72_FREQUENCY_DEVIATION 0x72
davidr99 0:ab4e012489ef 151 #define RH_RF22_REG_73_FREQUENCY_OFFSET1 0x73
davidr99 0:ab4e012489ef 152 #define RH_RF22_REG_74_FREQUENCY_OFFSET2 0x74
davidr99 0:ab4e012489ef 153 #define RH_RF22_REG_75_FREQUENCY_BAND_SELECT 0x75
davidr99 0:ab4e012489ef 154 #define RH_RF22_REG_76_NOMINAL_CARRIER_FREQUENCY1 0x76
davidr99 0:ab4e012489ef 155 #define RH_RF22_REG_77_NOMINAL_CARRIER_FREQUENCY0 0x77
davidr99 0:ab4e012489ef 156 #define RH_RF22_REG_79_FREQUENCY_HOPPING_CHANNEL_SELECT 0x79
davidr99 0:ab4e012489ef 157 #define RH_RF22_REG_7A_FREQUENCY_HOPPING_STEP_SIZE 0x7a
davidr99 0:ab4e012489ef 158 #define RH_RF22_REG_7C_TX_FIFO_CONTROL1 0x7c
davidr99 0:ab4e012489ef 159 #define RH_RF22_REG_7D_TX_FIFO_CONTROL2 0x7d
davidr99 0:ab4e012489ef 160 #define RH_RF22_REG_7E_RX_FIFO_CONTROL 0x7e
davidr99 0:ab4e012489ef 161 #define RH_RF22_REG_7F_FIFO_ACCESS 0x7f
davidr99 0:ab4e012489ef 162
davidr99 0:ab4e012489ef 163 // These register masks etc are named wherever possible
davidr99 0:ab4e012489ef 164 // corresponding to the bit and field names in the RF-22 Manual
davidr99 0:ab4e012489ef 165 // RH_RF22_REG_00_DEVICE_TYPE 0x00
davidr99 0:ab4e012489ef 166 #define RH_RF22_DEVICE_TYPE_RX_TRX 0x08
davidr99 0:ab4e012489ef 167 #define RH_RF22_DEVICE_TYPE_TX 0x07
davidr99 0:ab4e012489ef 168
davidr99 0:ab4e012489ef 169 // RH_RF22_REG_02_DEVICE_STATUS 0x02
davidr99 0:ab4e012489ef 170 #define RH_RF22_FFOVL 0x80
davidr99 0:ab4e012489ef 171 #define RH_RF22_FFUNFL 0x40
davidr99 0:ab4e012489ef 172 #define RH_RF22_RXFFEM 0x20
davidr99 0:ab4e012489ef 173 #define RH_RF22_HEADERR 0x10
davidr99 0:ab4e012489ef 174 #define RH_RF22_FREQERR 0x08
davidr99 0:ab4e012489ef 175 #define RH_RF22_LOCKDET 0x04
davidr99 0:ab4e012489ef 176 #define RH_RF22_CPS 0x03
davidr99 0:ab4e012489ef 177 #define RH_RF22_CPS_IDLE 0x00
davidr99 0:ab4e012489ef 178 #define RH_RF22_CPS_RX 0x01
davidr99 0:ab4e012489ef 179 #define RH_RF22_CPS_TX 0x10
davidr99 0:ab4e012489ef 180
davidr99 0:ab4e012489ef 181 // RH_RF22_REG_03_INTERRUPT_STATUS1 0x03
davidr99 0:ab4e012489ef 182 #define RH_RF22_IFFERROR 0x80
davidr99 0:ab4e012489ef 183 #define RH_RF22_ITXFFAFULL 0x40
davidr99 0:ab4e012489ef 184 #define RH_RF22_ITXFFAEM 0x20
davidr99 0:ab4e012489ef 185 #define RH_RF22_IRXFFAFULL 0x10
davidr99 0:ab4e012489ef 186 #define RH_RF22_IEXT 0x08
davidr99 0:ab4e012489ef 187 #define RH_RF22_IPKSENT 0x04
davidr99 0:ab4e012489ef 188 #define RH_RF22_IPKVALID 0x02
davidr99 0:ab4e012489ef 189 #define RH_RF22_ICRCERROR 0x01
davidr99 0:ab4e012489ef 190
davidr99 0:ab4e012489ef 191 // RH_RF22_REG_04_INTERRUPT_STATUS2 0x04
davidr99 0:ab4e012489ef 192 #define RH_RF22_ISWDET 0x80
davidr99 0:ab4e012489ef 193 #define RH_RF22_IPREAVAL 0x40
davidr99 0:ab4e012489ef 194 #define RH_RF22_IPREAINVAL 0x20
davidr99 0:ab4e012489ef 195 #define RH_RF22_IRSSI 0x10
davidr99 0:ab4e012489ef 196 #define RH_RF22_IWUT 0x08
davidr99 0:ab4e012489ef 197 #define RH_RF22_ILBD 0x04
davidr99 0:ab4e012489ef 198 #define RH_RF22_ICHIPRDY 0x02
davidr99 0:ab4e012489ef 199 #define RH_RF22_IPOR 0x01
davidr99 0:ab4e012489ef 200
davidr99 0:ab4e012489ef 201 // RH_RF22_REG_05_INTERRUPT_ENABLE1 0x05
davidr99 0:ab4e012489ef 202 #define RH_RF22_ENFFERR 0x80
davidr99 0:ab4e012489ef 203 #define RH_RF22_ENTXFFAFULL 0x40
davidr99 0:ab4e012489ef 204 #define RH_RF22_ENTXFFAEM 0x20
davidr99 0:ab4e012489ef 205 #define RH_RF22_ENRXFFAFULL 0x10
davidr99 0:ab4e012489ef 206 #define RH_RF22_ENEXT 0x08
davidr99 0:ab4e012489ef 207 #define RH_RF22_ENPKSENT 0x04
davidr99 0:ab4e012489ef 208 #define RH_RF22_ENPKVALID 0x02
davidr99 0:ab4e012489ef 209 #define RH_RF22_ENCRCERROR 0x01
davidr99 0:ab4e012489ef 210
davidr99 0:ab4e012489ef 211 // RH_RF22_REG_06_INTERRUPT_ENABLE2 0x06
davidr99 0:ab4e012489ef 212 #define RH_RF22_ENSWDET 0x80
davidr99 0:ab4e012489ef 213 #define RH_RF22_ENPREAVAL 0x40
davidr99 0:ab4e012489ef 214 #define RH_RF22_ENPREAINVAL 0x20
davidr99 0:ab4e012489ef 215 #define RH_RF22_ENRSSI 0x10
davidr99 0:ab4e012489ef 216 #define RH_RF22_ENWUT 0x08
davidr99 0:ab4e012489ef 217 #define RH_RF22_ENLBDI 0x04
davidr99 0:ab4e012489ef 218 #define RH_RF22_ENCHIPRDY 0x02
davidr99 0:ab4e012489ef 219 #define RH_RF22_ENPOR 0x01
davidr99 0:ab4e012489ef 220
davidr99 0:ab4e012489ef 221 // RH_RF22_REG_07_OPERATING_MODE 0x07
davidr99 0:ab4e012489ef 222 #define RH_RF22_SWRES 0x80
davidr99 0:ab4e012489ef 223 #define RH_RF22_ENLBD 0x40
davidr99 0:ab4e012489ef 224 #define RH_RF22_ENWT 0x20
davidr99 0:ab4e012489ef 225 #define RH_RF22_X32KSEL 0x10
davidr99 0:ab4e012489ef 226 #define RH_RF22_TXON 0x08
davidr99 0:ab4e012489ef 227 #define RH_RF22_RXON 0x04
davidr99 0:ab4e012489ef 228 #define RH_RF22_PLLON 0x02
davidr99 0:ab4e012489ef 229 #define RH_RF22_XTON 0x01
davidr99 0:ab4e012489ef 230
davidr99 0:ab4e012489ef 231 // RH_RF22_REG_08_OPERATING_MODE2 0x08
davidr99 0:ab4e012489ef 232 #define RH_RF22_ANTDIV 0xc0
davidr99 0:ab4e012489ef 233 #define RH_RF22_RXMPK 0x10
davidr99 0:ab4e012489ef 234 #define RH_RF22_AUTOTX 0x08
davidr99 0:ab4e012489ef 235 #define RH_RF22_ENLDM 0x04
davidr99 0:ab4e012489ef 236 #define RH_RF22_FFCLRRX 0x02
davidr99 0:ab4e012489ef 237 #define RH_RF22_FFCLRTX 0x01
davidr99 0:ab4e012489ef 238
davidr99 0:ab4e012489ef 239 // RH_RF22_REG_0F_ADC_CONFIGURATION 0x0f
davidr99 0:ab4e012489ef 240 #define RH_RF22_ADCSTART 0x80
davidr99 0:ab4e012489ef 241 #define RH_RF22_ADCDONE 0x80
davidr99 0:ab4e012489ef 242 #define RH_RF22_ADCSEL 0x70
davidr99 0:ab4e012489ef 243 #define RH_RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR 0x00
davidr99 0:ab4e012489ef 244 #define RH_RF22_ADCSEL_GPIO0_SINGLE_ENDED 0x10
davidr99 0:ab4e012489ef 245 #define RH_RF22_ADCSEL_GPIO1_SINGLE_ENDED 0x20
davidr99 0:ab4e012489ef 246 #define RH_RF22_ADCSEL_GPIO2_SINGLE_ENDED 0x30
davidr99 0:ab4e012489ef 247 #define RH_RF22_ADCSEL_GPIO0_GPIO1_DIFFERENTIAL 0x40
davidr99 0:ab4e012489ef 248 #define RH_RF22_ADCSEL_GPIO1_GPIO2_DIFFERENTIAL 0x50
davidr99 0:ab4e012489ef 249 #define RH_RF22_ADCSEL_GPIO0_GPIO2_DIFFERENTIAL 0x60
davidr99 0:ab4e012489ef 250 #define RH_RF22_ADCSEL_GND 0x70
davidr99 0:ab4e012489ef 251 #define RH_RF22_ADCREF 0x0c
davidr99 0:ab4e012489ef 252 #define RH_RF22_ADCREF_BANDGAP_VOLTAGE 0x00
davidr99 0:ab4e012489ef 253 #define RH_RF22_ADCREF_VDD_ON_3 0x08
davidr99 0:ab4e012489ef 254 #define RH_RF22_ADCREF_VDD_ON_2 0x0c
davidr99 0:ab4e012489ef 255 #define RH_RF22_ADCGAIN 0x03
davidr99 0:ab4e012489ef 256
davidr99 0:ab4e012489ef 257 // RH_RF22_REG_10_ADC_SENSOR_AMP_OFFSET 0x10
davidr99 0:ab4e012489ef 258 #define RH_RF22_ADCOFFS 0x0f
davidr99 0:ab4e012489ef 259
davidr99 0:ab4e012489ef 260 // RH_RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION 0x12
davidr99 0:ab4e012489ef 261 #define RH_RF22_TSRANGE 0xc0
davidr99 0:ab4e012489ef 262 #define RH_RF22_TSRANGE_M64_64C 0x00
davidr99 0:ab4e012489ef 263 #define RH_RF22_TSRANGE_M64_192C 0x40
davidr99 0:ab4e012489ef 264 #define RH_RF22_TSRANGE_0_128C 0x80
davidr99 0:ab4e012489ef 265 #define RH_RF22_TSRANGE_M40_216F 0xc0
davidr99 0:ab4e012489ef 266 #define RH_RF22_ENTSOFFS 0x20
davidr99 0:ab4e012489ef 267 #define RH_RF22_ENTSTRIM 0x10
davidr99 0:ab4e012489ef 268 #define RH_RF22_TSTRIM 0x0f
davidr99 0:ab4e012489ef 269
davidr99 0:ab4e012489ef 270 // RH_RF22_REG_14_WAKEUP_TIMER_PERIOD1 0x14
davidr99 0:ab4e012489ef 271 #define RH_RF22_WTR 0x3c
davidr99 0:ab4e012489ef 272 #define RH_RF22_WTD 0x03
davidr99 0:ab4e012489ef 273
davidr99 0:ab4e012489ef 274 // RH_RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE 0x1d
davidr99 0:ab4e012489ef 275 #define RH_RF22_AFBCD 0x80
davidr99 0:ab4e012489ef 276 #define RH_RF22_ENAFC 0x40
davidr99 0:ab4e012489ef 277 #define RH_RF22_AFCGEARH 0x38
davidr99 0:ab4e012489ef 278 #define RH_RF22_AFCGEARL 0x07
davidr99 0:ab4e012489ef 279
davidr99 0:ab4e012489ef 280 // RH_RF22_REG_1E_AFC_TIMING_CONTROL 0x1e
davidr99 0:ab4e012489ef 281 #define RH_RF22_SWAIT_TIMER 0xc0
davidr99 0:ab4e012489ef 282 #define RH_RF22_SHWAIT 0x38
davidr99 0:ab4e012489ef 283 #define RH_RF22_ANWAIT 0x07
davidr99 0:ab4e012489ef 284
davidr99 0:ab4e012489ef 285 // RH_RF22_REG_30_DATA_ACCESS_CONTROL 0x30
davidr99 0:ab4e012489ef 286 #define RH_RF22_ENPACRX 0x80
davidr99 0:ab4e012489ef 287 #define RH_RF22_MSBFRST 0x00
davidr99 0:ab4e012489ef 288 #define RH_RF22_LSBFRST 0x40
davidr99 0:ab4e012489ef 289 #define RH_RF22_CRCHDRS 0x00
davidr99 0:ab4e012489ef 290 #define RH_RF22_CRCDONLY 0x20
davidr99 0:ab4e012489ef 291 #define RH_RF22_SKIP2PH 0x10
davidr99 0:ab4e012489ef 292 #define RH_RF22_ENPACTX 0x08
davidr99 0:ab4e012489ef 293 #define RH_RF22_ENCRC 0x04
davidr99 0:ab4e012489ef 294 #define RH_RF22_CRC 0x03
davidr99 0:ab4e012489ef 295 #define RH_RF22_CRC_CCITT 0x00
davidr99 0:ab4e012489ef 296 #define RH_RF22_CRC_CRC_16_IBM 0x01
davidr99 0:ab4e012489ef 297 #define RH_RF22_CRC_IEC_16 0x02
davidr99 0:ab4e012489ef 298 #define RH_RF22_CRC_BIACHEVA 0x03
davidr99 0:ab4e012489ef 299
davidr99 0:ab4e012489ef 300 // RH_RF22_REG_32_HEADER_CONTROL1 0x32
davidr99 0:ab4e012489ef 301 #define RH_RF22_BCEN 0xf0
davidr99 0:ab4e012489ef 302 #define RH_RF22_BCEN_NONE 0x00
davidr99 0:ab4e012489ef 303 #define RH_RF22_BCEN_HEADER0 0x10
davidr99 0:ab4e012489ef 304 #define RH_RF22_BCEN_HEADER1 0x20
davidr99 0:ab4e012489ef 305 #define RH_RF22_BCEN_HEADER2 0x40
davidr99 0:ab4e012489ef 306 #define RH_RF22_BCEN_HEADER3 0x80
davidr99 0:ab4e012489ef 307 #define RH_RF22_HDCH 0x0f
davidr99 0:ab4e012489ef 308 #define RH_RF22_HDCH_NONE 0x00
davidr99 0:ab4e012489ef 309 #define RH_RF22_HDCH_HEADER0 0x01
davidr99 0:ab4e012489ef 310 #define RH_RF22_HDCH_HEADER1 0x02
davidr99 0:ab4e012489ef 311 #define RH_RF22_HDCH_HEADER2 0x04
davidr99 0:ab4e012489ef 312 #define RH_RF22_HDCH_HEADER3 0x08
davidr99 0:ab4e012489ef 313
davidr99 0:ab4e012489ef 314 // RH_RF22_REG_33_HEADER_CONTROL2 0x33
davidr99 0:ab4e012489ef 315 #define RH_RF22_HDLEN 0x70
davidr99 0:ab4e012489ef 316 #define RH_RF22_HDLEN_0 0x00
davidr99 0:ab4e012489ef 317 #define RH_RF22_HDLEN_1 0x10
davidr99 0:ab4e012489ef 318 #define RH_RF22_HDLEN_2 0x20
davidr99 0:ab4e012489ef 319 #define RH_RF22_HDLEN_3 0x30
davidr99 0:ab4e012489ef 320 #define RH_RF22_HDLEN_4 0x40
davidr99 0:ab4e012489ef 321 #define RH_RF22_VARPKLEN 0x00
davidr99 0:ab4e012489ef 322 #define RH_RF22_FIXPKLEN 0x08
davidr99 0:ab4e012489ef 323 #define RH_RF22_SYNCLEN 0x06
davidr99 0:ab4e012489ef 324 #define RH_RF22_SYNCLEN_1 0x00
davidr99 0:ab4e012489ef 325 #define RH_RF22_SYNCLEN_2 0x02
davidr99 0:ab4e012489ef 326 #define RH_RF22_SYNCLEN_3 0x04
davidr99 0:ab4e012489ef 327 #define RH_RF22_SYNCLEN_4 0x06
davidr99 0:ab4e012489ef 328 #define RH_RF22_PREALEN8 0x01
davidr99 0:ab4e012489ef 329
davidr99 0:ab4e012489ef 330 // RH_RF22_REG_6D_TX_POWER 0x6d
davidr99 0:ab4e012489ef 331 // https://www.sparkfun.com/datasheets/Wireless/General/RFM22B.pdf
davidr99 0:ab4e012489ef 332 #define RH_RF22_PAPEAKVAL 0x80
davidr99 0:ab4e012489ef 333 #define RH_RF22_PAPEAKEN 0x40
davidr99 0:ab4e012489ef 334 #define RH_RF22_PAPEAKLVL 0x30
davidr99 0:ab4e012489ef 335 #define RH_RF22_PAPEAKLVL6_5 0x00
davidr99 0:ab4e012489ef 336 #define RH_RF22_PAPEAKLVL7 0x10
davidr99 0:ab4e012489ef 337 #define RH_RF22_PAPEAKLVL7_5 0x20
davidr99 0:ab4e012489ef 338 #define RH_RF22_PAPEAKLVL8 0x30
davidr99 0:ab4e012489ef 339 #define RH_RF22_LNA_SW 0x08
davidr99 0:ab4e012489ef 340 #define RH_RF22_TXPOW 0x07
davidr99 0:ab4e012489ef 341 #define RH_RF22_TXPOW_4X31 0x08 // Not used in RFM22B
davidr99 0:ab4e012489ef 342 // For RFM22B:
davidr99 0:ab4e012489ef 343 #define RH_RF22_TXPOW_1DBM 0x00
davidr99 0:ab4e012489ef 344 #define RH_RF22_TXPOW_2DBM 0x01
davidr99 0:ab4e012489ef 345 #define RH_RF22_TXPOW_5DBM 0x02
davidr99 0:ab4e012489ef 346 #define RH_RF22_TXPOW_8DBM 0x03
davidr99 0:ab4e012489ef 347 #define RH_RF22_TXPOW_11DBM 0x04
davidr99 0:ab4e012489ef 348 #define RH_RF22_TXPOW_14DBM 0x05
davidr99 0:ab4e012489ef 349 #define RH_RF22_TXPOW_17DBM 0x06
davidr99 0:ab4e012489ef 350 #define RH_RF22_TXPOW_20DBM 0x07
davidr99 0:ab4e012489ef 351 // RFM23B only:
davidr99 0:ab4e012489ef 352 #define RH_RF22_RF23B_TXPOW_M8DBM 0x00 // -8dBm
davidr99 0:ab4e012489ef 353 #define RH_RF22_RF23B_TXPOW_M5DBM 0x01 // -5dBm
davidr99 0:ab4e012489ef 354 #define RH_RF22_RF23B_TXPOW_M2DBM 0x02 // -2dBm
davidr99 0:ab4e012489ef 355 #define RH_RF22_RF23B_TXPOW_1DBM 0x03 // 1dBm
davidr99 0:ab4e012489ef 356 #define RH_RF22_RF23B_TXPOW_4DBM 0x04 // 4dBm
davidr99 0:ab4e012489ef 357 #define RH_RF22_RF23B_TXPOW_7DBM 0x05 // 7dBm
davidr99 0:ab4e012489ef 358 #define RH_RF22_RF23B_TXPOW_10DBM 0x06 // 10dBm
davidr99 0:ab4e012489ef 359 #define RH_RF22_RF23B_TXPOW_13DBM 0x07 // 13dBm
davidr99 0:ab4e012489ef 360 // RFM23BP only:
davidr99 0:ab4e012489ef 361 #define RH_RF22_RF23BP_TXPOW_28DBM 0x05 // 28dBm
davidr99 0:ab4e012489ef 362 #define RH_RF22_RF23BP_TXPOW_29DBM 0x06 // 29dBm
davidr99 0:ab4e012489ef 363 #define RH_RF22_RF23BP_TXPOW_30DBM 0x07 // 30dBm
davidr99 0:ab4e012489ef 364
davidr99 0:ab4e012489ef 365 // RH_RF22_REG_71_MODULATION_CONTROL2 0x71
davidr99 0:ab4e012489ef 366 #define RH_RF22_TRCLK 0xc0
davidr99 0:ab4e012489ef 367 #define RH_RF22_TRCLK_NONE 0x00
davidr99 0:ab4e012489ef 368 #define RH_RF22_TRCLK_GPIO 0x40
davidr99 0:ab4e012489ef 369 #define RH_RF22_TRCLK_SDO 0x80
davidr99 0:ab4e012489ef 370 #define RH_RF22_TRCLK_NIRQ 0xc0
davidr99 0:ab4e012489ef 371 #define RH_RF22_DTMOD 0x30
davidr99 0:ab4e012489ef 372 #define RH_RF22_DTMOD_DIRECT_GPIO 0x00
davidr99 0:ab4e012489ef 373 #define RH_RF22_DTMOD_DIRECT_SDI 0x10
davidr99 0:ab4e012489ef 374 #define RH_RF22_DTMOD_FIFO 0x20
davidr99 0:ab4e012489ef 375 #define RH_RF22_DTMOD_PN9 0x30
davidr99 0:ab4e012489ef 376 #define RH_RF22_ENINV 0x08
davidr99 0:ab4e012489ef 377 #define RH_RF22_FD8 0x04
davidr99 0:ab4e012489ef 378 #define RH_RF22_MODTYP 0x30
davidr99 0:ab4e012489ef 379 #define RH_RF22_MODTYP_UNMODULATED 0x00
davidr99 0:ab4e012489ef 380 #define RH_RF22_MODTYP_OOK 0x01
davidr99 0:ab4e012489ef 381 #define RH_RF22_MODTYP_FSK 0x02
davidr99 0:ab4e012489ef 382 #define RH_RF22_MODTYP_GFSK 0x03
davidr99 0:ab4e012489ef 383
davidr99 0:ab4e012489ef 384
davidr99 0:ab4e012489ef 385 // RH_RF22_REG_75_FREQUENCY_BAND_SELECT 0x75
davidr99 0:ab4e012489ef 386 #define RH_RF22_SBSEL 0x40
davidr99 0:ab4e012489ef 387 #define RH_RF22_HBSEL 0x20
davidr99 0:ab4e012489ef 388 #define RH_RF22_FB 0x1f
davidr99 0:ab4e012489ef 389
davidr99 0:ab4e012489ef 390 // Define this to include Serial printing in diagnostic routines
davidr99 0:ab4e012489ef 391 #define RH_RF22_HAVE_SERIAL
davidr99 0:ab4e012489ef 392
davidr99 0:ab4e012489ef 393 /////////////////////////////////////////////////////////////////////
davidr99 0:ab4e012489ef 394 /// \class RH_RF22 RH_RF22.h <RH_RF22.h>
davidr99 0:ab4e012489ef 395 /// \brief Driver to send and receive unaddressed, unreliable datagrams via an RF22 and compatible radio transceiver.
davidr99 0:ab4e012489ef 396 ///
davidr99 0:ab4e012489ef 397 /// Works with RF22, RF23 based radio modules, and compatible chips and modules, including:
davidr99 0:ab4e012489ef 398 /// - RF22 bare module: http://www.sparkfun.com/products/10153
davidr99 0:ab4e012489ef 399 /// (Caution, that is a 3.3V part, and requires a 3.3V CPU such as Teensy etc or level shifters)
davidr99 0:ab4e012489ef 400 /// - RF22 shield: http://www.sparkfun.com/products/11018
davidr99 0:ab4e012489ef 401 /// - RF22 integrated board http://www.anarduino.com/miniwireless
davidr99 0:ab4e012489ef 402 /// - RFM23BP bare module: http://www.anarduino.com/details.jsp?pid=130
davidr99 0:ab4e012489ef 403 /// - Silicon Labs Si4430/31/32 based modules. S4432 is equivalent to RF22. Si4431/30 is equivalent to RF23.
davidr99 0:ab4e012489ef 404 ///
davidr99 0:ab4e012489ef 405 /// Data based on https://www.sparkfun.com/datasheets/Wireless/General/RFM22B.pdf
davidr99 0:ab4e012489ef 406 ///
davidr99 0:ab4e012489ef 407 /// \par Overview
davidr99 0:ab4e012489ef 408 ///
davidr99 0:ab4e012489ef 409 /// This base class provides basic functions for sending and receiving unaddressed,
davidr99 0:ab4e012489ef 410 /// unreliable datagrams of arbitrary length to 255 octets per packet.
davidr99 0:ab4e012489ef 411 ///
davidr99 0:ab4e012489ef 412 /// Manager classes may use this class to implement reliable, addressed datagrams and streams,
davidr99 0:ab4e012489ef 413 /// mesh routers, repeaters, translators etc.
davidr99 0:ab4e012489ef 414 ///
davidr99 0:ab4e012489ef 415 /// On transmission, the TO and FROM addresses default to 0x00, unless changed by a subclass.
davidr99 0:ab4e012489ef 416 /// On reception the TO addressed is checked against the node address (defaults to 0x00) or the
davidr99 0:ab4e012489ef 417 /// broadcast address (which is 0xff). The ID and FLAGS are set to 0, and not checked by this class.
davidr99 0:ab4e012489ef 418 /// This permits use of the this base RH_RF22 class as an
davidr99 0:ab4e012489ef 419 /// unaddressed, unreliable datagram service without the use of one the RadioHead Manager classes.
davidr99 0:ab4e012489ef 420 ///
davidr99 0:ab4e012489ef 421 /// Naturally, for any 2 radios to communicate that must be configured to use the same frequency and
davidr99 0:ab4e012489ef 422 /// modulation scheme.
davidr99 0:ab4e012489ef 423 ///
davidr99 0:ab4e012489ef 424 /// \par Details
davidr99 0:ab4e012489ef 425 ///
davidr99 0:ab4e012489ef 426 /// This Driver provides an object-oriented interface for sending and receiving data messages with Hope-RF
davidr99 0:ab4e012489ef 427 /// RF22 and RF23 based radio modules, and compatible chips and modules,
davidr99 0:ab4e012489ef 428 /// including the RFM22B transceiver module such as
davidr99 0:ab4e012489ef 429 /// this bare module: http://www.sparkfun.com/products/10153
davidr99 0:ab4e012489ef 430 /// and this shield: http://www.sparkfun.com/products/11018
davidr99 0:ab4e012489ef 431 /// and this module: http://www.hoperfusa.com/details.jsp?pid=131
davidr99 0:ab4e012489ef 432 /// and this integrated board: http://www.anarduino.com/miniwireless
davidr99 0:ab4e012489ef 433 /// and RF23BP modules such as this http://www.anarduino.com/details.jsp?pid=130
davidr99 0:ab4e012489ef 434 ///
davidr99 0:ab4e012489ef 435 /// The Hope-RF (http://www.hoperf.com) RFM22B (http://www.hoperf.com/rf_fsk/fsk/RFM22B.htm)
davidr99 0:ab4e012489ef 436 /// is a low-cost ISM transceiver module. It supports FSK, GFSK, OOK over a wide
davidr99 0:ab4e012489ef 437 /// range of frequencies and programmable data rates.
davidr99 0:ab4e012489ef 438 /// Manual can be found at https://www.sparkfun.com/datasheets/Wireless/General/RFM22.PDF
davidr99 0:ab4e012489ef 439 ///
davidr99 0:ab4e012489ef 440 /// This library provides functions for sending and receiving messages of up to 255 octets on any
davidr99 0:ab4e012489ef 441 /// frequency supported by the RF22B, in a range of predefined data rates and frequency deviations.
davidr99 0:ab4e012489ef 442 /// Frequency can be set with 312Hz precision to any frequency from 240.0MHz to 960.0MHz.
davidr99 0:ab4e012489ef 443 ///
davidr99 0:ab4e012489ef 444 /// Up to 3 RF22B modules can be connected to an Arduino, permitting the construction of translators
davidr99 0:ab4e012489ef 445 /// and frequency changers, etc.
davidr99 0:ab4e012489ef 446 ///
davidr99 0:ab4e012489ef 447 /// The following modulation types are suppported with a range of modem configurations for
davidr99 0:ab4e012489ef 448 /// common data rates and frequency deviations:
davidr99 0:ab4e012489ef 449 /// - GFSK Gaussian Frequency Shift Keying
davidr99 0:ab4e012489ef 450 /// - FSK Frequency Shift Keying
davidr99 0:ab4e012489ef 451 /// - OOK On-Off Keying
davidr99 0:ab4e012489ef 452 ///
davidr99 0:ab4e012489ef 453 /// Support for other RF22B features such as on-chip temperature measurement, analog-digital
davidr99 0:ab4e012489ef 454 /// converter, transmitter power control etc is also provided.
davidr99 0:ab4e012489ef 455 ///
davidr99 0:ab4e012489ef 456 /// Tested on Arduino Diecimila, Uno and Mega with arduino-0021, 1.0.5
davidr99 0:ab4e012489ef 457 /// on OpenSuSE 13.1 and avr-libc-1.6.1-1.15,
davidr99 0:ab4e012489ef 458 /// cross-avr-binutils-2.19-9.1, cross-avr-gcc-4.1.3_20080612-26.5.
davidr99 0:ab4e012489ef 459 /// With HopeRF RFM22 modules that appear to have RF22B chips on board:
davidr99 0:ab4e012489ef 460 /// - Device Type Code = 0x08 (RX/TRX)
davidr99 0:ab4e012489ef 461 /// - Version Code = 0x06
davidr99 0:ab4e012489ef 462 /// Works on Duo. Works with Sparkfun RFM22 Wireless shields. Works with RFM22 modules from http://www.hoperfusa.com/
davidr99 0:ab4e012489ef 463 /// Works with Arduino 1.0 to at least 1.0.5. Works on Maple, Flymaple, Uno32.
davidr99 0:ab4e012489ef 464 ///
davidr99 0:ab4e012489ef 465 /// \par Packet Format
davidr99 0:ab4e012489ef 466 ///
davidr99 0:ab4e012489ef 467 /// All messages sent and received by this Driver must conform to this packet format:
davidr99 0:ab4e012489ef 468 ///
davidr99 0:ab4e012489ef 469 /// - 8 nibbles (4 octets) PREAMBLE
davidr99 0:ab4e012489ef 470 /// - 2 octets SYNC 0x2d, 0xd4
davidr99 0:ab4e012489ef 471 /// - 4 octets HEADER: (TO, FROM, ID, FLAGS)
davidr99 0:ab4e012489ef 472 /// - 1 octet LENGTH (0 to 255), number of octets in DATA
davidr99 0:ab4e012489ef 473 /// - 0 to 255 octets DATA
davidr99 0:ab4e012489ef 474 /// - 2 octets CRC computed with CRC16(IBM), computed on HEADER, LENGTH and DATA
davidr99 0:ab4e012489ef 475 ///
davidr99 0:ab4e012489ef 476 /// For technical reasons, the message format is not protocol compatible with the
davidr99 0:ab4e012489ef 477 /// 'HopeRF Radio Transceiver Message Library for Arduino' http://www.airspayce.com/mikem/arduino/HopeRF from the same author. Nor is it compatible with
davidr99 0:ab4e012489ef 478 /// 'Virtual Wire' http://www.airspayce.com/mikem/arduino/VirtualWire.pdf also from the same author.
davidr99 0:ab4e012489ef 479 ///
davidr99 0:ab4e012489ef 480 /// \par Connecting RFM-22 to Arduino
davidr99 0:ab4e012489ef 481 ///
davidr99 0:ab4e012489ef 482 /// If you have the Sparkfun RFM22 Shield (https://www.sparkfun.com/products/11018)
davidr99 0:ab4e012489ef 483 /// the connections described below are done for you on the shield, no changes required,
davidr99 0:ab4e012489ef 484 /// just add headers and plug it in to an Arduino (but not and Arduino Mega, see below)
davidr99 0:ab4e012489ef 485 ///
davidr99 0:ab4e012489ef 486 /// The physical connection between the RF22B and the Arduino requires 3.3V,
davidr99 0:ab4e012489ef 487 /// the 3 x SPI pins (SCK, SDI, SDO), a Slave Select pin and an interrupt pin.
davidr99 0:ab4e012489ef 488 ///
davidr99 0:ab4e012489ef 489 /// Note also that on the RFM22B (but not the RFM23B), it is required to control the TX_ANT and
davidr99 0:ab4e012489ef 490 /// RX_ANT pins of the RFM22 in order to control the antenna connection properly. The RH_RF22
davidr99 0:ab4e012489ef 491 /// driver is configured by default so that GPIO0 and GPIO1 outputs can
davidr99 0:ab4e012489ef 492 /// control TX_ANT and RX_ANT input pins respectively automatically. On RFM22,
davidr99 0:ab4e012489ef 493 /// you must connect GPIO0
davidr99 0:ab4e012489ef 494 /// to TX_ANT and GPIO1 to RX_ANT for this automatic antenna switching to
davidr99 0:ab4e012489ef 495 /// occur. See setGpioReversed() for more details. These connections are not required on RFM23B.
davidr99 0:ab4e012489ef 496 ///
davidr99 0:ab4e012489ef 497 /// If you are using the Sparkfun RF22 shield, it will work with any 5V arduino without modification.
davidr99 0:ab4e012489ef 498 /// Connect the RFM-22 module to most Arduino's like this (Caution, Arduino Mega has different pins for SPI,
davidr99 0:ab4e012489ef 499 /// see below).
davidr99 0:ab4e012489ef 500 /// \code
davidr99 0:ab4e012489ef 501 /// Arduino RFM-22B
davidr99 0:ab4e012489ef 502 /// GND----------GND-\ (ground in)
davidr99 0:ab4e012489ef 503 /// SDN-/ (shutdown in)
davidr99 0:ab4e012489ef 504 /// 3V3----------VCC (3.3V in)
davidr99 0:ab4e012489ef 505 /// interrupt 0 pin D2-----------NIRQ (interrupt request out)
davidr99 0:ab4e012489ef 506 /// SS pin D10----------NSEL (chip select in)
davidr99 0:ab4e012489ef 507 /// SCK pin D13----------SCK (SPI clock in)
davidr99 0:ab4e012489ef 508 /// MOSI pin D11----------SDI (SPI Data in)
davidr99 0:ab4e012489ef 509 /// MISO pin D12----------SDO (SPI data out)
davidr99 0:ab4e012489ef 510 /// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT)
davidr99 0:ab4e012489ef 511 /// \--TX_ANT (TX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 512 /// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT)
davidr99 0:ab4e012489ef 513 /// \--RX_ANT (RX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 514 /// \endcode
davidr99 0:ab4e012489ef 515 /// For an Arduino Mega:
davidr99 0:ab4e012489ef 516 /// \code
davidr99 0:ab4e012489ef 517 /// Mega RFM-22B
davidr99 0:ab4e012489ef 518 /// GND----------GND-\ (ground in)
davidr99 0:ab4e012489ef 519 /// SDN-/ (shutdown in)
davidr99 0:ab4e012489ef 520 /// 3V3----------VCC (3.3V in)
davidr99 0:ab4e012489ef 521 /// interrupt 0 pin D2-----------NIRQ (interrupt request out)
davidr99 0:ab4e012489ef 522 /// SS pin D53----------NSEL (chip select in)
davidr99 0:ab4e012489ef 523 /// SCK pin D52----------SCK (SPI clock in)
davidr99 0:ab4e012489ef 524 /// MOSI pin D51----------SDI (SPI Data in)
davidr99 0:ab4e012489ef 525 /// MISO pin D50----------SDO (SPI data out)
davidr99 0:ab4e012489ef 526 /// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT)
davidr99 0:ab4e012489ef 527 /// \--TX_ANT (TX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 528 /// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT)
davidr99 0:ab4e012489ef 529 /// \--RX_ANT (RX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 530 /// \endcode
davidr99 0:ab4e012489ef 531 /// For Chipkit Uno32. Caution: you must also ensure jumper JP4 on the Uno32 is set to RD4
davidr99 0:ab4e012489ef 532 /// \code
davidr99 0:ab4e012489ef 533 /// Arduino RFM-22B
davidr99 0:ab4e012489ef 534 /// GND----------GND-\ (ground in)
davidr99 0:ab4e012489ef 535 /// SDN-/ (shutdown in)
davidr99 0:ab4e012489ef 536 /// 3V3----------VCC (3.3V in)
davidr99 0:ab4e012489ef 537 /// interrupt 0 pin D38----------NIRQ (interrupt request out)
davidr99 0:ab4e012489ef 538 /// SS pin D10----------NSEL (chip select in)
davidr99 0:ab4e012489ef 539 /// SCK pin D13----------SCK (SPI clock in)
davidr99 0:ab4e012489ef 540 /// MOSI pin D11----------SDI (SPI Data in)
davidr99 0:ab4e012489ef 541 /// MISO pin D12----------SDO (SPI data out)
davidr99 0:ab4e012489ef 542 /// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT)
davidr99 0:ab4e012489ef 543 /// \--TX_ANT (TX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 544 /// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT)
davidr99 0:ab4e012489ef 545 /// \--RX_ANT (RX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 546 /// \endcode
davidr99 0:ab4e012489ef 547 /// For Teensy 3.1
davidr99 0:ab4e012489ef 548 /// \code
davidr99 0:ab4e012489ef 549 /// Teensy RFM-22B
davidr99 0:ab4e012489ef 550 /// GND----------GND-\ (ground in)
davidr99 0:ab4e012489ef 551 /// SDN-/ (shutdown in)
davidr99 0:ab4e012489ef 552 /// 3V3----------VCC (3.3V in)
davidr99 0:ab4e012489ef 553 /// interrupt 2 pin D2-----------NIRQ (interrupt request out)
davidr99 0:ab4e012489ef 554 /// SS pin D10----------NSEL (chip select in)
davidr99 0:ab4e012489ef 555 /// SCK pin D13----------SCK (SPI clock in)
davidr99 0:ab4e012489ef 556 /// MOSI pin D11----------SDI (SPI Data in)
davidr99 0:ab4e012489ef 557 /// MISO pin D12----------SDO (SPI data out)
davidr99 0:ab4e012489ef 558 /// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT)
davidr99 0:ab4e012489ef 559 /// \--TX_ANT (TX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 560 /// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT)
davidr99 0:ab4e012489ef 561 /// \--RX_ANT (RX antenna control in) RFM22B only
davidr99 0:ab4e012489ef 562 /// \endcode
davidr99 0:ab4e012489ef 563 /// For connecting an Arduino to an RFM23BP module. Note that the antenna control pins are reversed
davidr99 0:ab4e012489ef 564 /// compared to the RF22.
davidr99 0:ab4e012489ef 565 /// \code
davidr99 0:ab4e012489ef 566 /// Arduino RFM-23BP
davidr99 0:ab4e012489ef 567 /// GND----------GND-\ (ground in)
davidr99 0:ab4e012489ef 568 /// SDN-/ (shutdown in)
davidr99 0:ab4e012489ef 569 /// 5V-----------VCC (5V in)
davidr99 0:ab4e012489ef 570 /// interrupt 0 pin D2-----------NIRQ (interrupt request out)
davidr99 0:ab4e012489ef 571 /// SS pin D10----------NSEL (chip select in)
davidr99 0:ab4e012489ef 572 /// SCK pin D13----------SCK (SPI clock in)
davidr99 0:ab4e012489ef 573 /// MOSI pin D11----------SDI (SPI Data in)
davidr99 0:ab4e012489ef 574 /// MISO pin D12----------SDO (SPI data out)
davidr99 0:ab4e012489ef 575 /// /--GPIO0 (GPIO0 out to control receiver antenna RXON)
davidr99 0:ab4e012489ef 576 /// \--RXON (RX antenna control in)
davidr99 0:ab4e012489ef 577 /// /--GPIO1 (GPIO1 out to control transmitter antenna TXON)
davidr99 0:ab4e012489ef 578 /// \--TXON (TX antenna control in)
davidr99 0:ab4e012489ef 579 /// \endcode
davidr99 0:ab4e012489ef 580 ///
davidr99 0:ab4e012489ef 581 /// and you can then use the default constructor RH_RF22().
davidr99 0:ab4e012489ef 582 /// You can override the default settings for the SS pin and the interrupt
davidr99 0:ab4e012489ef 583 /// in the RH_RF22 constructor if you wish to connect the slave select SS to other than the normal one for your
davidr99 0:ab4e012489ef 584 /// Arduino (D10 for Diecimila, Uno etc and D53 for Mega)
davidr99 0:ab4e012489ef 585 /// or the interrupt request to other than pin D2 (Caution, different processors have different constraints as to the
davidr99 0:ab4e012489ef 586 /// pins available for interrupts).
davidr99 0:ab4e012489ef 587 ///
davidr99 0:ab4e012489ef 588 /// It is possible to have 2 radios connected to one Arduino, provided each radio has its own
davidr99 0:ab4e012489ef 589 /// SS and interrupt line (SCK, SDI and SDO are common to both radios)
davidr99 0:ab4e012489ef 590 ///
davidr99 0:ab4e012489ef 591 /// Caution: on some Arduinos such as the Mega 2560, if you set the slave select pin to be other than the usual SS
davidr99 0:ab4e012489ef 592 /// pin (D53 on Mega 2560), you may need to set the usual SS pin to be an output to force the Arduino into SPI
davidr99 0:ab4e012489ef 593 /// master mode.
davidr99 0:ab4e012489ef 594 ///
davidr99 0:ab4e012489ef 595 /// Caution: Power supply requirements of the RF22 module may be relevant in some circumstances:
davidr99 0:ab4e012489ef 596 /// RF22 modules are capable of pulling 80mA+ at full power, where Arduino's 3.3V line can
davidr99 0:ab4e012489ef 597 /// give 50mA. You may need to make provision for alternate power supply for
davidr99 0:ab4e012489ef 598 /// the RF22, especially if you wish to use full transmit power, and/or you have
davidr99 0:ab4e012489ef 599 /// other shields demanding power. Inadequate power for the RF22 is reported to cause symptoms such as:
davidr99 0:ab4e012489ef 600 /// - reset's/bootups terminate with "init failed" messages
davidr99 0:ab4e012489ef 601 /// -random termination of communication after 5-30 packets sent/received
davidr99 0:ab4e012489ef 602 /// -"fake ok" state, where initialization passes fluently, but communication doesn't happen
davidr99 0:ab4e012489ef 603 /// -shields hang Arduino boards, especially during the flashing
davidr99 0:ab4e012489ef 604 ///
davidr99 0:ab4e012489ef 605 /// Caution: some RF22 breakout boards (such as the HAB-RFM22B-BOA HAB-RFM22B-BO) reportedly
davidr99 0:ab4e012489ef 606 /// have the TX_ANT and RX_ANT pre-connected to GPIO0 and GPIO1 round the wrong way. You can work with this
davidr99 0:ab4e012489ef 607 /// if you use setGpioReversed().
davidr99 0:ab4e012489ef 608 ///
davidr99 0:ab4e012489ef 609 /// Caution: If you are using a bare RF22 module without IO level shifters, you may have difficulty connecting
davidr99 0:ab4e012489ef 610 /// to a 5V arduino. The RF22 module is 3.3V and its IO pins are 3.3V not 5V. Some Arduinos (Diecimila and
davidr99 0:ab4e012489ef 611 /// Uno) seem to work OK with this, and some (Mega) do not always work reliably. Your Mileage May Vary.
davidr99 0:ab4e012489ef 612 /// For best result, use level shifters, or use a RF22 shield or board with level shifters built in,
davidr99 0:ab4e012489ef 613 /// such as the Sparkfun RFM22 shield http://www.sparkfun.com/products/11018.
davidr99 0:ab4e012489ef 614 /// You could also use a 3.3V IO Arduino such as a Pro.
davidr99 0:ab4e012489ef 615 /// It is recognised that it is difficult to connect
davidr99 0:ab4e012489ef 616 /// the Sparkfun RFM22 shield to a Mega, since the SPI pins on the Mega are different to other Arduinos,
davidr99 0:ab4e012489ef 617 /// But it is possible, by bending the SPI pins (D10, D11, D12, D13) on the
davidr99 0:ab4e012489ef 618 /// shield out of the way before plugging it in to the Mega and jumpering the shield pins to the Mega like this:
davidr99 0:ab4e012489ef 619 /// \code
davidr99 0:ab4e012489ef 620 /// RF22 Shield Mega
davidr99 0:ab4e012489ef 621 /// D10 D53
davidr99 0:ab4e012489ef 622 /// D13 D52
davidr99 0:ab4e012489ef 623 /// D11 D51
davidr99 0:ab4e012489ef 624 /// D12 D50
davidr99 0:ab4e012489ef 625 /// \endcode
davidr99 0:ab4e012489ef 626 ///
davidr99 0:ab4e012489ef 627 /// \par Interrupts
davidr99 0:ab4e012489ef 628 ///
davidr99 0:ab4e012489ef 629 /// The Driver uses interrupts to react to events in the RF22 module,
davidr99 0:ab4e012489ef 630 /// such as the reception of a new packet, or the completion of transmission of a packet.
davidr99 0:ab4e012489ef 631 /// The RH_RF22 interrupt service routine reads status from and writes data
davidr99 0:ab4e012489ef 632 /// to the the RF22 module via the SPI interface. It is very important therefore,
davidr99 0:ab4e012489ef 633 /// that if you are using the RF22 library with another SPI based deviced, that you
davidr99 0:ab4e012489ef 634 /// disable interrupts while you transfer data to and from that other device.
davidr99 0:ab4e012489ef 635 /// Use cli() to disable interrupts and sei() to reenable them.
davidr99 0:ab4e012489ef 636 ///
davidr99 0:ab4e012489ef 637 /// \par SPI Interface
davidr99 0:ab4e012489ef 638 ///
davidr99 0:ab4e012489ef 639 /// The RF22 module uses the SPI bus to communicate with the Arduino. Arduino
davidr99 0:ab4e012489ef 640 /// IDE includes a hardware SPI class to communicate with SPI devices using
davidr99 0:ab4e012489ef 641 /// the SPI facilities built into the Atmel chips, over the standard designated
davidr99 0:ab4e012489ef 642 /// SPI pins MOSI, MISO, SCK, which are usually on Arduino pins 11, 12 and 13
davidr99 0:ab4e012489ef 643 /// respectively (or 51, 50, 52 on a Mega).
davidr99 0:ab4e012489ef 644 ///
davidr99 0:ab4e012489ef 645 /// By default, the RH_RF22 Driver uses the Hardware SPI interface to
davidr99 0:ab4e012489ef 646 /// communicate with the RF22 module. However, if your RF22 SPI is connected to
davidr99 0:ab4e012489ef 647 /// the Arduino through non-standard pins, or the standard Hardware SPI
davidr99 0:ab4e012489ef 648 /// interface will not work for you, you can instead use a bit-banged Software
davidr99 0:ab4e012489ef 649 /// SPI class RHSoftwareSPI, which can be configured to work on any Arduino digital IO pins.
davidr99 0:ab4e012489ef 650 /// See the documentation of RHSoftwareSPI for details.
davidr99 0:ab4e012489ef 651 ///
davidr99 0:ab4e012489ef 652 /// The advantages of the Software SPI interface are that it can be used on
davidr99 0:ab4e012489ef 653 /// any Arduino pins, not just the usual dedicated hardware pins. The
davidr99 0:ab4e012489ef 654 /// disadvantage is that it is significantly slower then hardware.
davidr99 0:ab4e012489ef 655 /// If you observe reliable behaviour with the default hardware SPI RHHardwareSPI, but unreliable behaviour
davidr99 0:ab4e012489ef 656 /// with Software SPI RHSoftwareSPI, it may be due to slow CPU performance.
davidr99 0:ab4e012489ef 657 ///
davidr99 0:ab4e012489ef 658 /// Initialisation example with hardware SPI
davidr99 0:ab4e012489ef 659 /// \code
davidr99 0:ab4e012489ef 660 /// #include <RH_RF22.h>
davidr99 0:ab4e012489ef 661 /// RH_RF22 driver;
davidr99 0:ab4e012489ef 662 /// RHReliableDatagram manager(driver, CLIENT_ADDRESS);
davidr99 0:ab4e012489ef 663 /// \endcode
davidr99 0:ab4e012489ef 664 ///
davidr99 0:ab4e012489ef 665 /// Initialisation example with software SPI
davidr99 0:ab4e012489ef 666 /// \code
davidr99 0:ab4e012489ef 667 /// #include <RH_RF22.h>
davidr99 0:ab4e012489ef 668 /// #include <RHSoftwareSPI.h>
davidr99 0:ab4e012489ef 669 /// RHSoftwareSPI spi;
davidr99 0:ab4e012489ef 670 /// RH_RF22 driver(10, 2, spi);
davidr99 0:ab4e012489ef 671 /// RHReliableDatagram manager(driver, CLIENT_ADDRESS);
davidr99 0:ab4e012489ef 672 /// \endcode
davidr99 0:ab4e012489ef 673 ///
davidr99 0:ab4e012489ef 674 /// \par Memory
davidr99 0:ab4e012489ef 675 ///
davidr99 0:ab4e012489ef 676 /// The RH_RF22 Driver requires non-trivial amounts of memory. The sample programs all compile to
davidr99 0:ab4e012489ef 677 /// about 9 to 14kbytes each on Arduino, which will fit in the flash proram memory of most Arduinos. However,
davidr99 0:ab4e012489ef 678 /// the RAM requirements are more critical. Most sample programs above will run on Duemilanova,
davidr99 0:ab4e012489ef 679 /// but not on Diecimila. Even on Duemilanova, the RAM requirements are very close to the
davidr99 0:ab4e012489ef 680 /// available memory of 2kbytes. Therefore, you should be vary sparing with RAM use in programs that use
davidr99 0:ab4e012489ef 681 /// the RH_RF22 Driver on Duemilanova.
davidr99 0:ab4e012489ef 682 ///
davidr99 0:ab4e012489ef 683 /// The sample RHRouter and RHMesh programs compile to about 14kbytes,
davidr99 0:ab4e012489ef 684 /// and require more RAM than the others.
davidr99 0:ab4e012489ef 685 /// They will not run on Duemilanova or Diecimila, but will run on Arduino Mega.
davidr99 0:ab4e012489ef 686 ///
davidr99 0:ab4e012489ef 687 /// It is often hard to accurately identify when you are hitting RAM limits on Arduino.
davidr99 0:ab4e012489ef 688 /// The symptoms can include:
davidr99 0:ab4e012489ef 689 /// - Mysterious crashes and restarts
davidr99 0:ab4e012489ef 690 /// - Changes in behaviour when seemingly unrelated changes are made (such as adding print() statements)
davidr99 0:ab4e012489ef 691 /// - Hanging
davidr99 0:ab4e012489ef 692 /// - Output from Serial.print() not appearing
davidr99 0:ab4e012489ef 693 ///
davidr99 0:ab4e012489ef 694 /// With an Arduino Mega, with 8 kbytes of SRAM, there is much more RAM headroom for
davidr99 0:ab4e012489ef 695 /// your own elaborate programs.
davidr99 0:ab4e012489ef 696 /// This library is reported to work with Arduino Pro Mini, but that has not been tested by me.
davidr99 0:ab4e012489ef 697 ///
davidr99 0:ab4e012489ef 698 /// The RF22M modules use an inexpensive crystal to control the frequency synthesizer, and therfore you can expect
davidr99 0:ab4e012489ef 699 /// the transmitter and receiver frequencies to be subject to the usual inaccuracies of such crystals. The RF22
davidr99 0:ab4e012489ef 700 /// contains an AFC circuit to compensate for differences in transmitter and receiver frequencies.
davidr99 0:ab4e012489ef 701 /// It does this by altering the receiver frequency during reception by up to the pull-in frequency range.
davidr99 0:ab4e012489ef 702 /// This RF22 library enables the AFC and by default sets the pull-in frequency range to
davidr99 0:ab4e012489ef 703 /// 0.05MHz, which should be sufficient to handle most situations. However, if you observe unexplained packet losses
davidr99 0:ab4e012489ef 704 /// or failure to operate correctly all the time it may be because your modules have a wider frequency difference, and
davidr99 0:ab4e012489ef 705 /// you may need to set the afcPullInRange to a different value, using setFrequency();
davidr99 0:ab4e012489ef 706 ///
davidr99 0:ab4e012489ef 707 /// \par Transmitter Power
davidr99 0:ab4e012489ef 708 ///
davidr99 0:ab4e012489ef 709 /// You can control the transmitter power on the RF22 and RF23 transceivers
davidr99 0:ab4e012489ef 710 /// with the RH_RF22::setTxPower() function. The argument can be any of the
davidr99 0:ab4e012489ef 711 /// RH_RF22_TXPOW_* (for RFM22) or RH_RF22_RF23B_TXPOW_* (for RFM23) values.
davidr99 0:ab4e012489ef 712 /// The default is RH_RF22_TXPOW_8DBM/RH_RF22_RF23B_TXPOW_1DBM . Eg:
davidr99 0:ab4e012489ef 713 /// \code
davidr99 0:ab4e012489ef 714 /// driver.setTxPower(RH_RF22_TXPOW_2DBM);
davidr99 0:ab4e012489ef 715 /// \endcode
davidr99 0:ab4e012489ef 716 ///
davidr99 0:ab4e012489ef 717 /// The RF23BP has higher power capability, there are
davidr99 0:ab4e012489ef 718 /// several power settings that are specific to the RF23BP only:
davidr99 0:ab4e012489ef 719 ///
davidr99 0:ab4e012489ef 720 /// - RH_RF22_RF23BP_TXPOW_28DBM
davidr99 0:ab4e012489ef 721 /// - RH_RF22_RF23BP_TXPOW_29DBM
davidr99 0:ab4e012489ef 722 /// - RH_RF22_RF23BP_TXPOW_38DBM
davidr99 0:ab4e012489ef 723 ///
davidr99 0:ab4e012489ef 724 /// CAUTION: the high power settings available on the RFM23BP require
davidr99 0:ab4e012489ef 725 /// significant power supply current. For example at +30dBm, the typical chip
davidr99 0:ab4e012489ef 726 /// supply current is 550mA. This will overwhelm some small CPU board power
davidr99 0:ab4e012489ef 727 /// regulators and USB supplies. If you use this chip at high power make sure
davidr99 0:ab4e012489ef 728 /// you have an adequate supply current providing full 5V to the RFM23BP (and
davidr99 0:ab4e012489ef 729 /// the CPU if required), otherwise you can expect strange behaviour like
davidr99 0:ab4e012489ef 730 /// hanging, stopping, incorrect power levels, RF power amp overheating etc.
davidr99 0:ab4e012489ef 731 /// You must also ensure that the RFM23BP GPIO pins are connected to the
davidr99 0:ab4e012489ef 732 /// antenna switch control pins like so:
davidr99 0:ab4e012489ef 733 ////
davidr99 0:ab4e012489ef 734 /// \code
davidr99 0:ab4e012489ef 735 /// GPIO0 <-> RXON
davidr99 0:ab4e012489ef 736 /// GPIO1 <-> TXON
davidr99 0:ab4e012489ef 737 /// \endcode
davidr99 0:ab4e012489ef 738 ///
davidr99 0:ab4e012489ef 739 /// The RF output impedance of the RFM22BP module is 50 ohms. In our
davidr99 0:ab4e012489ef 740 /// experiments we found that the most critical issue (besides a suitable
davidr99 0:ab4e012489ef 741 /// power supply) is to ensure that the antenna impedance is also near 50
davidr99 0:ab4e012489ef 742 /// ohms. Connecting a simple 1/4 wavelength (ie a 17.3cm single wire)
davidr99 0:ab4e012489ef 743 /// directly to the antenna output <b>will not work at full 30dBm power</b>,
davidr99 0:ab4e012489ef 744 /// and will result in the transmitter hanging and/or the power amp
davidr99 0:ab4e012489ef 745 /// overheating. Connect a proper 50 ohm impedance transmission line or
davidr99 0:ab4e012489ef 746 /// antenna, and prevent RF radiation into the radio and arduino modules,
davidr99 0:ab4e012489ef 747 /// in order to get full, reliable power. Our tests show that a 433MHz
davidr99 0:ab4e012489ef 748 /// RFM23BP feeding a 50 ohm transmission line with a VHF discone antenna at
davidr99 0:ab4e012489ef 749 /// the end results in full power output and the power amp transistor on the
davidr99 0:ab4e012489ef 750 /// RFM22BP module runnning slightly warm but not hot. We recommend you use
davidr99 0:ab4e012489ef 751 /// the services of a competent RF engineer when trying to use this high power
davidr99 0:ab4e012489ef 752 /// module.
davidr99 0:ab4e012489ef 753 ///
davidr99 0:ab4e012489ef 754 /// Note: with RFM23BP, the reported maximum possible power when operating on 3.3V is 27dBm.
davidr99 0:ab4e012489ef 755 ///
davidr99 0:ab4e012489ef 756 /// We have made some actual power measurements against
davidr99 0:ab4e012489ef 757 /// programmed power for Sparkfun RFM22 wireless module under the following conditions:
davidr99 0:ab4e012489ef 758 /// - Sparkfun RFM22 wireless module, Duemilanove, USB power
davidr99 0:ab4e012489ef 759 /// - 10cm RG58C/U soldered direct to RFM22 module ANT and GND
davidr99 0:ab4e012489ef 760 /// - bnc connecteor
davidr99 0:ab4e012489ef 761 /// - 12dB attenuator
davidr99 0:ab4e012489ef 762 /// - BNC-SMA adapter
davidr99 0:ab4e012489ef 763 /// - MiniKits AD8307 HF/VHF Power Head (calibrated against Rohde&Schwartz 806.2020 test set)
davidr99 0:ab4e012489ef 764 /// - Tektronix TDS220 scope to measure the Vout from power head
davidr99 0:ab4e012489ef 765 /// \code
davidr99 0:ab4e012489ef 766 /// Program power Measured Power
davidr99 0:ab4e012489ef 767 /// dBm dBm
davidr99 0:ab4e012489ef 768 /// 1 -5.6
davidr99 0:ab4e012489ef 769 /// 2 -3.8
davidr99 0:ab4e012489ef 770 /// 5 -2.2
davidr99 0:ab4e012489ef 771 /// 8 -0.6
davidr99 0:ab4e012489ef 772 /// 11 1.2
davidr99 0:ab4e012489ef 773 /// 14 11.6
davidr99 0:ab4e012489ef 774 /// 17 14.4
davidr99 0:ab4e012489ef 775 /// 20 18.0
davidr99 0:ab4e012489ef 776 /// \endcode
davidr99 0:ab4e012489ef 777 /// (Caution: we dont claim laboratory accuracy for these measurements)
davidr99 0:ab4e012489ef 778 /// You would not expect to get anywhere near these powers to air with a simple 1/4 wavelength wire antenna.
davidr99 0:ab4e012489ef 779 ///
davidr99 0:ab4e012489ef 780 /// \par Performance
davidr99 0:ab4e012489ef 781 ///
davidr99 0:ab4e012489ef 782 /// Some simple speed performance tests have been conducted.
davidr99 0:ab4e012489ef 783 /// In general packet transmission rate will be limited by the modulation scheme.
davidr99 0:ab4e012489ef 784 /// Also, if your code does any slow operations like Serial printing it will also limit performance.
davidr99 0:ab4e012489ef 785 /// We disabled any printing in the tests below.
davidr99 0:ab4e012489ef 786 /// We tested with RH_RF22::GFSK_Rb125Fd125, which is probably the fastest scheme available.
davidr99 0:ab4e012489ef 787 /// We tested with a 13 octet message length, over a very short distance of 10cm.
davidr99 0:ab4e012489ef 788 ///
davidr99 0:ab4e012489ef 789 /// Transmission (no reply) tests with modulation RH_RF22::GFSK_Rb125Fd125 and a
davidr99 0:ab4e012489ef 790 /// 13 octet message show about 330 messages per second transmitted.
davidr99 0:ab4e012489ef 791 ///
davidr99 0:ab4e012489ef 792 /// Transmit-and-wait-for-a-reply tests with modulation RH_RF22::GFSK_Rb125Fd125 and a
davidr99 0:ab4e012489ef 793 /// 13 octet message (send and receive) show about 160 round trips per second.
davidr99 0:ab4e012489ef 794 ///
davidr99 0:ab4e012489ef 795 /// \par Compatibility with RF22 library
davidr99 0:ab4e012489ef 796 /// The RH_RF22 driver is based on our earlier RF22 library http://www.airspayce.com/mikem/arduino/RF22
davidr99 0:ab4e012489ef 797 /// We have tried hard to be as compatible as possible with the earlier RF22 library, but there are some differences:
davidr99 0:ab4e012489ef 798 /// - Different constructor.
davidr99 0:ab4e012489ef 799 /// - Indexes for some modem configurations have changed (we recommend you use the symbolic names, not integer indexes).
davidr99 0:ab4e012489ef 800 ///
davidr99 0:ab4e012489ef 801 /// The major difference is that under RadioHead, you are
davidr99 0:ab4e012489ef 802 /// required to create 2 objects (ie RH_RF22 and a manager) instead of just one object under RF22
davidr99 0:ab4e012489ef 803 /// (ie RHMesh, RHRouter, RHReliableDatagram or RHDatagram).
davidr99 0:ab4e012489ef 804 /// It may be sufficient or you to change for example:
davidr99 0:ab4e012489ef 805 /// \code
davidr99 0:ab4e012489ef 806 /// RF22ReliableDatagram rf22(CLIENT_ADDRESS);
davidr99 0:ab4e012489ef 807 /// \endcode
davidr99 0:ab4e012489ef 808 /// to:
davidr99 0:ab4e012489ef 809 /// \code
davidr99 0:ab4e012489ef 810 /// RH_RF22 driver;
davidr99 0:ab4e012489ef 811 /// RHReliableDatagram rf22(driver, CLIENT_ADDRESS);
davidr99 0:ab4e012489ef 812 /// \endcode
davidr99 0:ab4e012489ef 813 /// and any instance of RF22_MAX_MESSAGE_LEN to RH_RF22_MAX_MESSAGE_LEN
davidr99 0:ab4e012489ef 814 ///
davidr99 0:ab4e012489ef 815 /// RadioHead version 1.6 changed the way the interrupt pin number is
davidr99 0:ab4e012489ef 816 /// specified on Arduino and Uno32 platforms. If your code previously
davidr99 0:ab4e012489ef 817 /// specifed a non-default interrupt pin number in the RH_RF22 constructor,
davidr99 0:ab4e012489ef 818 /// you may need to review your code to specify the correct interrrupt pin
davidr99 0:ab4e012489ef 819 /// (and not the interrupt number as before).
davidr99 0:ab4e012489ef 820 class RH_RF22 : public RHSPIDriver
davidr99 0:ab4e012489ef 821 {
davidr99 0:ab4e012489ef 822 public:
davidr99 0:ab4e012489ef 823
davidr99 0:ab4e012489ef 824 /// \brief Defines register values for a set of modem configuration registers
davidr99 0:ab4e012489ef 825 ///
davidr99 0:ab4e012489ef 826 /// Defines register values for a set of modem configuration registers
davidr99 0:ab4e012489ef 827 /// that can be passed to setModemConfig()
davidr99 0:ab4e012489ef 828 /// if none of the choices in ModemConfigChoice suit your need
davidr99 0:ab4e012489ef 829 /// setModemConfig() writes the register values to the appropriate RH_RF22 registers
davidr99 0:ab4e012489ef 830 /// to set the desired modulation type, data rate and deviation/bandwidth.
davidr99 0:ab4e012489ef 831 /// Suitable values for these registers can be computed using the register calculator at
davidr99 0:ab4e012489ef 832 /// http://www.hoperf.com/upload/rf/RF22B%2023B%2031B%2042B%2043B%20Register%20Settings_RevB1-v5.xls
davidr99 0:ab4e012489ef 833 typedef struct
davidr99 0:ab4e012489ef 834 {
davidr99 0:ab4e012489ef 835 uint8_t reg_1c; ///< Value for register RH_RF22_REG_1C_IF_FILTER_BANDWIDTH
davidr99 0:ab4e012489ef 836 uint8_t reg_1f; ///< Value for register RH_RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE
davidr99 0:ab4e012489ef 837 uint8_t reg_20; ///< Value for register RH_RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE
davidr99 0:ab4e012489ef 838 uint8_t reg_21; ///< Value for register RH_RF22_REG_21_CLOCK_RECOVERY_OFFSET2
davidr99 0:ab4e012489ef 839 uint8_t reg_22; ///< Value for register RH_RF22_REG_22_CLOCK_RECOVERY_OFFSET1
davidr99 0:ab4e012489ef 840 uint8_t reg_23; ///< Value for register RH_RF22_REG_23_CLOCK_RECOVERY_OFFSET0
davidr99 0:ab4e012489ef 841 uint8_t reg_24; ///< Value for register RH_RF22_REG_24_CLOCK_RECOVERY_TIMING_LOOP_GAIN1
davidr99 0:ab4e012489ef 842 uint8_t reg_25; ///< Value for register RH_RF22_REG_25_CLOCK_RECOVERY_TIMING_LOOP_GAIN0
davidr99 0:ab4e012489ef 843 uint8_t reg_2c; ///< Value for register RH_RF22_REG_2C_OOK_COUNTER_VALUE_1
davidr99 0:ab4e012489ef 844 uint8_t reg_2d; ///< Value for register RH_RF22_REG_2D_OOK_COUNTER_VALUE_2
davidr99 0:ab4e012489ef 845 uint8_t reg_2e; ///< Value for register RH_RF22_REG_2E_SLICER_PEAK_HOLD
davidr99 0:ab4e012489ef 846 uint8_t reg_58; ///< Value for register RH_RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING
davidr99 0:ab4e012489ef 847 uint8_t reg_69; ///< Value for register RH_RF22_REG_69_AGC_OVERRIDE1
davidr99 0:ab4e012489ef 848 uint8_t reg_6e; ///< Value for register RH_RF22_REG_6E_TX_DATA_RATE1
davidr99 0:ab4e012489ef 849 uint8_t reg_6f; ///< Value for register RH_RF22_REG_6F_TX_DATA_RATE0
davidr99 0:ab4e012489ef 850 uint8_t reg_70; ///< Value for register RH_RF22_REG_70_MODULATION_CONTROL1
davidr99 0:ab4e012489ef 851 uint8_t reg_71; ///< Value for register RH_RF22_REG_71_MODULATION_CONTROL2
davidr99 0:ab4e012489ef 852 uint8_t reg_72; ///< Value for register RH_RF22_REG_72_FREQUENCY_DEVIATION
davidr99 0:ab4e012489ef 853 } ModemConfig;
davidr99 0:ab4e012489ef 854
davidr99 0:ab4e012489ef 855 /// Choices for setModemConfig() for a selected subset of common modulation types,
davidr99 0:ab4e012489ef 856 /// and data rates. If you need another configuration, use the register calculator.
davidr99 0:ab4e012489ef 857 /// and call setModemRegisters() with your desired settings.
davidr99 0:ab4e012489ef 858 /// These are indexes into MODEM_CONFIG_TABLE. We strongly recommend you use these symbolic
davidr99 0:ab4e012489ef 859 /// definitions and not their integer equivalents: its possible that new values will be
davidr99 0:ab4e012489ef 860 /// introduced in later versions (though we will try to avoid it).
davidr99 0:ab4e012489ef 861 typedef enum
davidr99 0:ab4e012489ef 862 {
davidr99 0:ab4e012489ef 863 UnmodulatedCarrier = 0, ///< Unmodulated carrier for testing
davidr99 0:ab4e012489ef 864 FSK_PN9_Rb2Fd5, ///< FSK, No Manchester, Rb = 2kbs, Fd = 5kHz, PN9 random modulation for testing
davidr99 0:ab4e012489ef 865
davidr99 0:ab4e012489ef 866 FSK_Rb2Fd5, ///< FSK, No Manchester, Rb = 2kbs, Fd = 5kHz
davidr99 0:ab4e012489ef 867 FSK_Rb2_4Fd36, ///< FSK, No Manchester, Rb = 2.4kbs, Fd = 36kHz
davidr99 0:ab4e012489ef 868 FSK_Rb4_8Fd45, ///< FSK, No Manchester, Rb = 4.8kbs, Fd = 45kHz
davidr99 0:ab4e012489ef 869 FSK_Rb9_6Fd45, ///< FSK, No Manchester, Rb = 9.6kbs, Fd = 45kHz
davidr99 0:ab4e012489ef 870 FSK_Rb19_2Fd9_6, ///< FSK, No Manchester, Rb = 19.2kbs, Fd = 9.6kHz
davidr99 0:ab4e012489ef 871 FSK_Rb38_4Fd19_6, ///< FSK, No Manchester, Rb = 38.4kbs, Fd = 19.6kHz
davidr99 0:ab4e012489ef 872 FSK_Rb57_6Fd28_8, ///< FSK, No Manchester, Rb = 57.6kbs, Fd = 28.8kHz
davidr99 0:ab4e012489ef 873 FSK_Rb125Fd125, ///< FSK, No Manchester, Rb = 125kbs, Fd = 125kHz
davidr99 0:ab4e012489ef 874 FSK_Rb_512Fd2_5, ///< FSK, No Manchester, Rb = 512bs, Fd = 2.5kHz, for POCSAG compatibility
davidr99 0:ab4e012489ef 875 FSK_Rb_512Fd4_5, ///< FSK, No Manchester, Rb = 512bs, Fd = 4.5kHz, for POCSAG compatibility
davidr99 0:ab4e012489ef 876
davidr99 0:ab4e012489ef 877 GFSK_Rb2Fd5, ///< GFSK, No Manchester, Rb = 2kbs, Fd = 5kHz
davidr99 0:ab4e012489ef 878 GFSK_Rb2_4Fd36, ///< GFSK, No Manchester, Rb = 2.4kbs, Fd = 36kHz
davidr99 0:ab4e012489ef 879 GFSK_Rb4_8Fd45, ///< GFSK, No Manchester, Rb = 4.8kbs, Fd = 45kHz
davidr99 0:ab4e012489ef 880 GFSK_Rb9_6Fd45, ///< GFSK, No Manchester, Rb = 9.6kbs, Fd = 45kHz
davidr99 0:ab4e012489ef 881 GFSK_Rb19_2Fd9_6, ///< GFSK, No Manchester, Rb = 19.2kbs, Fd = 9.6kHz
davidr99 0:ab4e012489ef 882 GFSK_Rb38_4Fd19_6, ///< GFSK, No Manchester, Rb = 38.4kbs, Fd = 19.6kHz
davidr99 0:ab4e012489ef 883 GFSK_Rb57_6Fd28_8, ///< GFSK, No Manchester, Rb = 57.6kbs, Fd = 28.8kHz
davidr99 0:ab4e012489ef 884 GFSK_Rb125Fd125, ///< GFSK, No Manchester, Rb = 125kbs, Fd = 125kHz
davidr99 0:ab4e012489ef 885
davidr99 0:ab4e012489ef 886 OOK_Rb1_2Bw75, ///< OOK, No Manchester, Rb = 1.2kbs, Rx Bandwidth = 75kHz
davidr99 0:ab4e012489ef 887 OOK_Rb2_4Bw335, ///< OOK, No Manchester, Rb = 2.4kbs, Rx Bandwidth = 335kHz
davidr99 0:ab4e012489ef 888 OOK_Rb4_8Bw335, ///< OOK, No Manchester, Rb = 4.8kbs, Rx Bandwidth = 335kHz
davidr99 0:ab4e012489ef 889 OOK_Rb9_6Bw335, ///< OOK, No Manchester, Rb = 9.6kbs, Rx Bandwidth = 335kHz
davidr99 0:ab4e012489ef 890 OOK_Rb19_2Bw335, ///< OOK, No Manchester, Rb = 19.2kbs, Rx Bandwidth = 335kHz
davidr99 0:ab4e012489ef 891 OOK_Rb38_4Bw335, ///< OOK, No Manchester, Rb = 38.4kbs, Rx Bandwidth = 335kHz
davidr99 0:ab4e012489ef 892 OOK_Rb40Bw335 ///< OOK, No Manchester, Rb = 40kbs, Rx Bandwidth = 335kHz
davidr99 0:ab4e012489ef 893
davidr99 0:ab4e012489ef 894 } ModemConfigChoice;
davidr99 0:ab4e012489ef 895
davidr99 0:ab4e012489ef 896 /// \brief Defines the available choices for CRC
davidr99 0:ab4e012489ef 897 /// Types of permitted CRC polynomials, to be passed to setCRCPolynomial()
davidr99 0:ab4e012489ef 898 /// They deliberately have the same numeric values as the crc[1:0] field of Register
davidr99 0:ab4e012489ef 899 /// RH_RF22_REG_30_DATA_ACCESS_CONTROL
davidr99 0:ab4e012489ef 900 typedef enum
davidr99 0:ab4e012489ef 901 {
davidr99 0:ab4e012489ef 902 CRC_CCITT = 0, ///< CCITT
davidr99 0:ab4e012489ef 903 CRC_16_IBM = 1, ///< CRC-16 (IBM) The default used by RH_RF22 driver
davidr99 0:ab4e012489ef 904 CRC_IEC_16 = 2, ///< IEC-16
davidr99 0:ab4e012489ef 905 CRC_Biacheva = 3 ///< Biacheva
davidr99 0:ab4e012489ef 906 } CRCPolynomial;
davidr99 0:ab4e012489ef 907
davidr99 0:ab4e012489ef 908 /// Constructor. You can have multiple instances, but each instance must have its own
davidr99 0:ab4e012489ef 909 /// interrupt and slave select pin. After constructing, you must call init() to initialise the interface
davidr99 0:ab4e012489ef 910 /// and the radio module. A maximum of 3 instances can co-exist on one processor, provided there are sufficient
davidr99 0:ab4e012489ef 911 /// distinct interrupt lines, one for each instance.
davidr99 0:ab4e012489ef 912 /// \param[in] slaveSelectPin the Arduino pin number of the output to use to select the RH_RF22 before
davidr99 0:ab4e012489ef 913 /// accessing it. Defaults to the normal SS pin for your Arduino (D10 for Diecimila, Uno etc, D53 for Mega, D10 for Maple)
davidr99 0:ab4e012489ef 914 /// \param[in] interruptPin The interrupt Pin number that is connected to the RF22 NIRQ interrupt line.
davidr99 0:ab4e012489ef 915 /// Defaults to pin 2, as required by sparkfun RFM22 module shields.
davidr99 0:ab4e012489ef 916 /// Caution: You must specify an interrupt capable pin.
davidr99 0:ab4e012489ef 917 /// On many Arduino boards, there are limitations as to which pins may be used as interrupts.
davidr99 0:ab4e012489ef 918 /// On Leonardo pins 0, 1, 2 or 3. On Mega2560 pins 2, 3, 18, 19, 20, 21. On Due and Teensy, any digital pin.
davidr99 0:ab4e012489ef 919 /// On other Arduinos pins 2 or 3.
davidr99 0:ab4e012489ef 920 /// See http://arduino.cc/en/Reference/attachInterrupt for more details.
davidr99 0:ab4e012489ef 921 /// On Chipkit Uno32, pins 38, 2, 7, 8, 35.
davidr99 0:ab4e012489ef 922 /// On other boards, any digital pin may be used.
davidr99 0:ab4e012489ef 923 /// \param[in] spi Pointer to the SPI interface object to use.
davidr99 0:ab4e012489ef 924 /// Defaults to the standard Arduino hardware SPI interface
davidr99 0:ab4e012489ef 925 RH_RF22(PINS slaveSelectPin, PINS interruptPin, RHGenericSPI& spi = hardware_spi);
davidr99 0:ab4e012489ef 926
davidr99 0:ab4e012489ef 927 /// Initialises this instance and the radio module connected to it.
davidr99 0:ab4e012489ef 928 /// The following steps are taken:
davidr99 0:ab4e012489ef 929 /// - Initialise the slave select pin and the SPI interface library
davidr99 0:ab4e012489ef 930 /// - Software reset the RH_RF22 module
davidr99 0:ab4e012489ef 931 /// - Checks the connected RH_RF22 module is either a RH_RF22_DEVICE_TYPE_RX_TRX or a RH_RF22_DEVICE_TYPE_TX
davidr99 0:ab4e012489ef 932 /// - Attaches an interrupt handler
davidr99 0:ab4e012489ef 933 /// - Configures the RH_RF22 module
davidr99 0:ab4e012489ef 934 /// - Sets the frequency to 434.0 MHz
davidr99 0:ab4e012489ef 935 /// - Sets the modem data rate to FSK_Rb2_4Fd36
davidr99 0:ab4e012489ef 936 /// \return true if everything was successful
davidr99 0:ab4e012489ef 937 bool init();
davidr99 0:ab4e012489ef 938
davidr99 0:ab4e012489ef 939 /// Issues a software reset to the
davidr99 0:ab4e012489ef 940 /// RH_RF22 module. Blocks for 1ms to ensure the reset is complete.
davidr99 0:ab4e012489ef 941 void reset();
davidr99 0:ab4e012489ef 942
davidr99 0:ab4e012489ef 943 /// Reads and returns the device status register RH_RF22_REG_02_DEVICE_STATUS
davidr99 0:ab4e012489ef 944 /// \return The value of the device status register
davidr99 0:ab4e012489ef 945 uint8_t statusRead();
davidr99 0:ab4e012489ef 946
davidr99 0:ab4e012489ef 947 /// Reads a value from the on-chip analog-digital converter
davidr99 0:ab4e012489ef 948 /// \param[in] adcsel Selects the ADC input to measure. One of RH_RF22_ADCSEL_*. Defaults to the
davidr99 0:ab4e012489ef 949 /// internal temperature sensor
davidr99 0:ab4e012489ef 950 /// \param[in] adcref Specifies the refernce voltage to use. One of RH_RF22_ADCREF_*.
davidr99 0:ab4e012489ef 951 /// Defaults to the internal bandgap voltage.
davidr99 0:ab4e012489ef 952 /// \param[in] adcgain Amplifier gain selection.
davidr99 0:ab4e012489ef 953 /// \param[in] adcoffs Amplifier offseet (0 to 15).
davidr99 0:ab4e012489ef 954 /// \return The analog value. 0 to 255.
davidr99 0:ab4e012489ef 955 uint8_t adcRead(uint8_t adcsel = RH_RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR,
davidr99 0:ab4e012489ef 956 uint8_t adcref = RH_RF22_ADCREF_BANDGAP_VOLTAGE,
davidr99 0:ab4e012489ef 957 uint8_t adcgain = 0,
davidr99 0:ab4e012489ef 958 uint8_t adcoffs = 0);
davidr99 0:ab4e012489ef 959
davidr99 0:ab4e012489ef 960 /// Reads the on-chip temperature sensor
davidr99 0:ab4e012489ef 961 /// \param[in] tsrange Specifies the temperature range to use. One of RH_RF22_TSRANGE_*
davidr99 0:ab4e012489ef 962 /// \param[in] tvoffs Specifies the temperature value offset. This is actually signed value
davidr99 0:ab4e012489ef 963 /// added to the measured temperature value
davidr99 0:ab4e012489ef 964 /// \return The measured temperature.
davidr99 0:ab4e012489ef 965 uint8_t temperatureRead(uint8_t tsrange = RH_RF22_TSRANGE_M64_64C, uint8_t tvoffs = 0);
davidr99 0:ab4e012489ef 966
davidr99 0:ab4e012489ef 967 /// Reads the wakeup timer value in registers RH_RF22_REG_17_WAKEUP_TIMER_VALUE1
davidr99 0:ab4e012489ef 968 /// and RH_RF22_REG_18_WAKEUP_TIMER_VALUE2
davidr99 0:ab4e012489ef 969 /// \return The wakeup timer value
davidr99 0:ab4e012489ef 970 uint16_t wutRead();
davidr99 0:ab4e012489ef 971
davidr99 0:ab4e012489ef 972 /// Sets the wakeup timer period registers RH_RF22_REG_14_WAKEUP_TIMER_PERIOD1,
davidr99 0:ab4e012489ef 973 /// RH_RF22_REG_15_WAKEUP_TIMER_PERIOD2 and RH_RF22_R<EG_16_WAKEUP_TIMER_PERIOD3
davidr99 0:ab4e012489ef 974 /// \param[in] wtm Wakeup timer mantissa value
davidr99 0:ab4e012489ef 975 /// \param[in] wtr Wakeup timer exponent R value
davidr99 0:ab4e012489ef 976 /// \param[in] wtd Wakeup timer exponent D value
davidr99 0:ab4e012489ef 977 void setWutPeriod(uint16_t wtm, uint8_t wtr = 0, uint8_t wtd = 0);
davidr99 0:ab4e012489ef 978
davidr99 0:ab4e012489ef 979 /// Sets the transmitter and receiver centre frequency
davidr99 0:ab4e012489ef 980 /// \param[in] centre Frequency in MHz. 240.0 to 960.0. Caution, some versions of RH_RF22 and derivatives
davidr99 0:ab4e012489ef 981 /// implemented more restricted frequency ranges.
davidr99 0:ab4e012489ef 982 /// \param[in] afcPullInRange Sets the AF Pull In Range in MHz. Defaults to 0.05MHz (50kHz).
davidr99 0:ab4e012489ef 983 /// Range is 0.0 to 0.159375
davidr99 0:ab4e012489ef 984 /// for frequencies 240.0 to 480MHz, and 0.0 to 0.318750MHz for frequencies 480.0 to 960MHz,
davidr99 0:ab4e012489ef 985 /// \return true if the selected frquency centre + (fhch * fhs) is within range and the afcPullInRange
davidr99 0:ab4e012489ef 986 /// is within range
davidr99 0:ab4e012489ef 987 bool setFrequency(float centre, float afcPullInRange = 0.05);
davidr99 0:ab4e012489ef 988
davidr99 0:ab4e012489ef 989 /// Sets the frequency hopping step size.
davidr99 0:ab4e012489ef 990 /// \param[in] fhs Frequency Hopping step size in 10kHz increments
davidr99 0:ab4e012489ef 991 /// \return true if centre + (fhch * fhs) is within limits
davidr99 0:ab4e012489ef 992 bool setFHStepSize(uint8_t fhs);
davidr99 0:ab4e012489ef 993
davidr99 0:ab4e012489ef 994 /// Sets the frequncy hopping channel. Adds fhch * fhs to centre frequency
davidr99 0:ab4e012489ef 995 /// \param[in] fhch The channel number
davidr99 0:ab4e012489ef 996 /// \return true if the selected frquency centre + (fhch * fhs) is within range
davidr99 0:ab4e012489ef 997 bool setFHChannel(uint8_t fhch);
davidr99 0:ab4e012489ef 998
davidr99 0:ab4e012489ef 999 /// Reads and returns the current RSSI value from register RH_RF22_REG_26_RSSI. Caution: this is
davidr99 0:ab4e012489ef 1000 /// in internal units (see figure 31 of RFM22B/23B documentation), not in dBm. If you want to find the RSSI in dBm
davidr99 0:ab4e012489ef 1001 /// of the last received message, use lastRssi() instead.
davidr99 0:ab4e012489ef 1002 /// \return The current RSSI value
davidr99 0:ab4e012489ef 1003 uint8_t rssiRead();
davidr99 0:ab4e012489ef 1004
davidr99 0:ab4e012489ef 1005 /// Reads and returns the current EZMAC value from register RH_RF22_REG_31_EZMAC_STATUS
davidr99 0:ab4e012489ef 1006 /// \return The current EZMAC value
davidr99 0:ab4e012489ef 1007 uint8_t ezmacStatusRead();
davidr99 0:ab4e012489ef 1008
davidr99 0:ab4e012489ef 1009 /// Sets the parameters for the RH_RF22 Idle mode in register RH_RF22_REG_07_OPERATING_MODE.
davidr99 0:ab4e012489ef 1010 /// Idle mode is the mode the RH_RF22 will be in when not transmitting or receiving. The default idle mode
davidr99 0:ab4e012489ef 1011 /// is RH_RF22_XTON ie READY mode.
davidr99 0:ab4e012489ef 1012 /// \param[in] mode Mask of mode bits, using RH_RF22_SWRES, RH_RF22_ENLBD, RH_RF22_ENWT,
davidr99 0:ab4e012489ef 1013 /// RH_RF22_X32KSEL, RH_RF22_PLLON, RH_RF22_XTON.
davidr99 0:ab4e012489ef 1014 void setOpMode(uint8_t mode);
davidr99 0:ab4e012489ef 1015
davidr99 0:ab4e012489ef 1016 /// If current mode is Rx or Tx changes it to Idle. If the transmitter or receiver is running,
davidr99 0:ab4e012489ef 1017 /// disables them.
davidr99 0:ab4e012489ef 1018 void setModeIdle();
davidr99 0:ab4e012489ef 1019
davidr99 0:ab4e012489ef 1020 /// If current mode is Tx or Idle, changes it to Rx.
davidr99 0:ab4e012489ef 1021 /// Starts the receiver in the RH_RF22.
davidr99 0:ab4e012489ef 1022 void setModeRx();
davidr99 0:ab4e012489ef 1023
davidr99 0:ab4e012489ef 1024 /// If current mode is Rx or Idle, changes it to Rx.
davidr99 0:ab4e012489ef 1025 /// Starts the transmitter in the RH_RF22.
davidr99 0:ab4e012489ef 1026 void setModeTx();
davidr99 0:ab4e012489ef 1027
davidr99 0:ab4e012489ef 1028 /// Sets the transmitter power output level in register RH_RF22_REG_6D_TX_POWER.
davidr99 0:ab4e012489ef 1029 /// Be a good neighbour and set the lowest power level you need.
davidr99 0:ab4e012489ef 1030 /// After init(), the power will be set to RH_RF22::RH_RF22_TXPOW_8DBM on RF22B
davidr99 0:ab4e012489ef 1031 /// or RH_RF22_RF23B_TXPOW_1DBM on an RF23B.
davidr99 0:ab4e012489ef 1032 /// The highest power available on RF22B is RH_RF22::RH_RF22_TXPOW_20DBM (20dBm).
davidr99 0:ab4e012489ef 1033 /// The highest power available on RF23B is RH_RF22::RH_RF22_RF23B_TXPOW_13DBM (13dBm).
davidr99 0:ab4e012489ef 1034 /// Higher powers are available on RF23BP (using RH_RF22_RF23BP_TXPOW_*),
davidr99 0:ab4e012489ef 1035 /// and then only with an adequate power supply. See comments above.
davidr99 0:ab4e012489ef 1036 /// Caution: In some countries you may only select certain higher power levels if you
davidr99 0:ab4e012489ef 1037 /// are also using frequency hopping. Make sure you are aware of the legal
davidr99 0:ab4e012489ef 1038 /// limitations and regulations in your region.
davidr99 0:ab4e012489ef 1039 /// \param[in] power Transmitter power level, one of RH_RF22_*TXPOW_*
davidr99 0:ab4e012489ef 1040 void setTxPower(uint8_t power);
davidr99 0:ab4e012489ef 1041
davidr99 0:ab4e012489ef 1042 /// Sets all the registered required to configure the data modem in the RH_RF22, including the data rate,
davidr99 0:ab4e012489ef 1043 /// bandwidths etc. You cas use this to configure the modem with custom configuraitons if none of the
davidr99 0:ab4e012489ef 1044 /// canned configurations in ModemConfigChoice suit you.
davidr99 0:ab4e012489ef 1045 /// \param[in] config A ModemConfig structure containing values for the modem configuration registers.
davidr99 0:ab4e012489ef 1046 void setModemRegisters(const ModemConfig* config);
davidr99 0:ab4e012489ef 1047
davidr99 0:ab4e012489ef 1048 /// Select one of the predefined modem configurations. If you need a modem configuration not provided
davidr99 0:ab4e012489ef 1049 /// here, use setModemRegisters() with your own ModemConfig.
davidr99 0:ab4e012489ef 1050 /// \param[in] index The configuration choice.
davidr99 0:ab4e012489ef 1051 /// \return true if index is a valid choice.
davidr99 0:ab4e012489ef 1052 bool setModemConfig(ModemConfigChoice index);
davidr99 0:ab4e012489ef 1053
davidr99 0:ab4e012489ef 1054 /// Starts the receiver and checks whether a received message is available.
davidr99 0:ab4e012489ef 1055 /// This can be called multiple times in a timeout loop
davidr99 0:ab4e012489ef 1056 /// \return true if a complete, valid message has been received and is able to be retrieved by
davidr99 0:ab4e012489ef 1057 /// recv()
davidr99 0:ab4e012489ef 1058 bool available();
davidr99 0:ab4e012489ef 1059
davidr99 0:ab4e012489ef 1060 /// Turns the receiver on if it not already on.
davidr99 0:ab4e012489ef 1061 /// If there is a valid message available, copy it to buf and return true
davidr99 0:ab4e012489ef 1062 /// else return false.
davidr99 0:ab4e012489ef 1063 /// If a message is copied, *len is set to the length (Caution, 0 length messages are permitted).
davidr99 0:ab4e012489ef 1064 /// You should be sure to call this function frequently enough to not miss any messages
davidr99 0:ab4e012489ef 1065 /// It is recommended that you call it in your main loop.
davidr99 0:ab4e012489ef 1066 /// \param[in] buf Location to copy the received message
davidr99 0:ab4e012489ef 1067 /// \param[in,out] len Pointer to available space in buf. Set to the actual number of octets copied.
davidr99 0:ab4e012489ef 1068 /// \return true if a valid message was copied to buf
davidr99 0:ab4e012489ef 1069 bool recv(uint8_t* buf, uint8_t* len);
davidr99 0:ab4e012489ef 1070
davidr99 0:ab4e012489ef 1071 /// Waits until any previous transmit packet is finished being transmitted with waitPacketSent().
davidr99 0:ab4e012489ef 1072 /// Then loads a message into the transmitter and starts the transmitter. Note that a message length
davidr99 0:ab4e012489ef 1073 /// of 0 is NOT permitted.
davidr99 0:ab4e012489ef 1074 /// \param[in] data Array of data to be sent
davidr99 0:ab4e012489ef 1075 /// \param[in] len Number of bytes of data to send (> 0)
davidr99 0:ab4e012489ef 1076 /// \return true if the message length was valid and it was correctly queued for transmit
davidr99 0:ab4e012489ef 1077 bool send(const uint8_t* data, uint8_t len);
davidr99 0:ab4e012489ef 1078
davidr99 0:ab4e012489ef 1079 /// Sets the length of the preamble
davidr99 0:ab4e012489ef 1080 /// in 4-bit nibbles.
davidr99 0:ab4e012489ef 1081 /// Caution: this should be set to the same
davidr99 0:ab4e012489ef 1082 /// value on all nodes in your network. Default is 8.
davidr99 0:ab4e012489ef 1083 /// Sets the message preamble length in RH_RF22_REG_34_PREAMBLE_LENGTH
davidr99 0:ab4e012489ef 1084 /// \param[in] nibbles Preamble length in nibbles of 4 bits each.
davidr99 0:ab4e012489ef 1085 void setPreambleLength(uint8_t nibbles);
davidr99 0:ab4e012489ef 1086
davidr99 0:ab4e012489ef 1087 /// Sets the sync words for transmit and receive in registers RH_RF22_REG_36_SYNC_WORD3
davidr99 0:ab4e012489ef 1088 /// to RH_RF22_REG_39_SYNC_WORD0
davidr99 0:ab4e012489ef 1089 /// Caution: SyncWords should be set to the same
davidr99 0:ab4e012489ef 1090 /// value on all nodes in your network. Nodes with different SyncWords set will never receive
davidr99 0:ab4e012489ef 1091 /// each others messages, so different SyncWords can be used to isolate different
davidr99 0:ab4e012489ef 1092 /// networks from each other. Default is { 0x2d, 0xd4 }.
davidr99 0:ab4e012489ef 1093 /// \param[in] syncWords Array of sync words, 1 to 4 octets long
davidr99 0:ab4e012489ef 1094 /// \param[in] len Number of sync words to set, 1 to 4.
davidr99 0:ab4e012489ef 1095 void setSyncWords(const uint8_t* syncWords, uint8_t len);
davidr99 0:ab4e012489ef 1096
davidr99 0:ab4e012489ef 1097 /// Tells the receiver to accept messages with any TO address, not just messages
davidr99 0:ab4e012489ef 1098 /// addressed to thisAddress or the broadcast address
davidr99 0:ab4e012489ef 1099 /// \param[in] promiscuous true if you wish to receive messages with any TO address
davidr99 0:ab4e012489ef 1100 virtual void setPromiscuous(bool promiscuous);
davidr99 0:ab4e012489ef 1101
davidr99 0:ab4e012489ef 1102 /// Sets the CRC polynomial to be used to generate the CRC for both receive and transmit
davidr99 0:ab4e012489ef 1103 /// otherwise the default of CRC_16_IBM will be used.
davidr99 0:ab4e012489ef 1104 /// \param[in] polynomial One of RH_RF22::CRCPolynomial choices CRC_*
davidr99 0:ab4e012489ef 1105 /// \return true if polynomial is a valid option for this radio.
davidr99 0:ab4e012489ef 1106 bool setCRCPolynomial(CRCPolynomial polynomial);
davidr99 0:ab4e012489ef 1107
davidr99 0:ab4e012489ef 1108 /// Configures GPIO pins for reversed GPIO connections to the antenna switch.
davidr99 0:ab4e012489ef 1109 /// Normally on RF22 modules, GPIO0(out) is connected to TX_ANT(in) to enable tx antenna during transmit
davidr99 0:ab4e012489ef 1110 /// and GPIO1(out) is connected to RX_ANT(in) to enable rx antenna during receive. The RH_RF22 driver
davidr99 0:ab4e012489ef 1111 /// configures the GPIO pins during init() so the antenna switch works as expected.
davidr99 0:ab4e012489ef 1112 /// However, some RF22 modules, such as HAB-RFM22B-BOA HAB-RFM22B-BO, also Si4432 sold by Dorji.com via Tindie.com
davidr99 0:ab4e012489ef 1113 /// have these GPIO pins reversed, so that GPIO0 is connected to RX_ANT.
davidr99 0:ab4e012489ef 1114 /// Call this function with a true argument after init() and before transmitting
davidr99 0:ab4e012489ef 1115 /// in order to configure the module for reversed GPIO pins.
davidr99 0:ab4e012489ef 1116 /// \param[in] gpioReversed Set to true if your RF22 module has reversed GPIO antenna switch connections.
davidr99 0:ab4e012489ef 1117 void setGpioReversed(bool gpioReversed = false);
davidr99 0:ab4e012489ef 1118
davidr99 0:ab4e012489ef 1119 /// Returns the time in millis since the last preamble was received, and when the last
davidr99 0:ab4e012489ef 1120 /// RSSI measurement was made.
davidr99 0:ab4e012489ef 1121 uint32_t getLastPreambleTime();
davidr99 0:ab4e012489ef 1122
davidr99 0:ab4e012489ef 1123 /// The maximum message length supported by this driver
davidr99 0:ab4e012489ef 1124 /// \return The maximum message length supported by this driver
davidr99 0:ab4e012489ef 1125 uint8_t maxMessageLength();
davidr99 0:ab4e012489ef 1126
davidr99 0:ab4e012489ef 1127 /// Sets the radio into low-power sleep mode.
davidr99 0:ab4e012489ef 1128 /// If successful, the transport will stay in sleep mode until woken by
davidr99 0:ab4e012489ef 1129 /// changing mode it idle, transmit or receive (eg by calling send(), recv(), available() etc)
davidr99 0:ab4e012489ef 1130 /// Caution: there is a time penalty as the radio takes a finite time to wake from sleep mode.
davidr99 0:ab4e012489ef 1131 /// \return true if sleep mode was successfully entered.
davidr99 0:ab4e012489ef 1132 virtual bool sleep();
davidr99 0:ab4e012489ef 1133
davidr99 0:ab4e012489ef 1134 protected:
davidr99 0:ab4e012489ef 1135 /// This is a low level function to handle the interrupts for one instance of RH_RF22.
davidr99 0:ab4e012489ef 1136 /// Called automatically by isr*()
davidr99 0:ab4e012489ef 1137 /// Should not need to be called.
davidr99 0:ab4e012489ef 1138 void handleInterrupt();
davidr99 0:ab4e012489ef 1139
davidr99 0:ab4e012489ef 1140 /// Clears the receiver buffer.
davidr99 0:ab4e012489ef 1141 /// Internal use only
davidr99 0:ab4e012489ef 1142 void clearRxBuf();
davidr99 0:ab4e012489ef 1143
davidr99 0:ab4e012489ef 1144 /// Clears the transmitter buffer
davidr99 0:ab4e012489ef 1145 /// Internal use only
davidr99 0:ab4e012489ef 1146 void clearTxBuf();
davidr99 0:ab4e012489ef 1147
davidr99 0:ab4e012489ef 1148 /// Fills the transmitter buffer with the data of a mesage to be sent
davidr99 0:ab4e012489ef 1149 /// \param[in] data Array of data bytes to be sent (1 to 255)
davidr99 0:ab4e012489ef 1150 /// \param[in] len Number of data bytes in data (> 0)
davidr99 0:ab4e012489ef 1151 /// \return true if the message length is valid
davidr99 0:ab4e012489ef 1152 bool fillTxBuf(const uint8_t* data, uint8_t len);
davidr99 0:ab4e012489ef 1153
davidr99 0:ab4e012489ef 1154 /// Appends the transmitter buffer with the data of a mesage to be sent
davidr99 0:ab4e012489ef 1155 /// \param[in] data Array of data bytes to be sent (0 to 255)
davidr99 0:ab4e012489ef 1156 /// \param[in] len Number of data bytes in data
davidr99 0:ab4e012489ef 1157 /// \return false if the resulting message would exceed RH_RF22_MAX_MESSAGE_LEN, else true
davidr99 0:ab4e012489ef 1158 bool appendTxBuf(const uint8_t* data, uint8_t len);
davidr99 0:ab4e012489ef 1159
davidr99 0:ab4e012489ef 1160 /// Internal function to load the next fragment of
davidr99 0:ab4e012489ef 1161 /// the current message into the transmitter FIFO
davidr99 0:ab4e012489ef 1162 /// Internal use only
davidr99 0:ab4e012489ef 1163 void sendNextFragment();
davidr99 0:ab4e012489ef 1164
davidr99 0:ab4e012489ef 1165 /// function to copy the next fragment from
davidr99 0:ab4e012489ef 1166 /// the receiver FIF) into the receiver buffer
davidr99 0:ab4e012489ef 1167 void readNextFragment();
davidr99 0:ab4e012489ef 1168
davidr99 0:ab4e012489ef 1169 /// Clears the RF22 Rx and Tx FIFOs
davidr99 0:ab4e012489ef 1170 /// Internal use only
davidr99 0:ab4e012489ef 1171 void resetFifos();
davidr99 0:ab4e012489ef 1172
davidr99 0:ab4e012489ef 1173 /// Clears the RF22 Rx FIFO
davidr99 0:ab4e012489ef 1174 /// Internal use only
davidr99 0:ab4e012489ef 1175 void resetRxFifo();
davidr99 0:ab4e012489ef 1176
davidr99 0:ab4e012489ef 1177 /// Clears the RF22 Tx FIFO
davidr99 0:ab4e012489ef 1178 /// Internal use only
davidr99 0:ab4e012489ef 1179 void resetTxFifo();
davidr99 0:ab4e012489ef 1180
davidr99 0:ab4e012489ef 1181 /// This function will be called by handleInterrupt() if an RF22 external interrupt occurs.
davidr99 0:ab4e012489ef 1182 /// This can only happen if external interrupts are enabled in the RF22
davidr99 0:ab4e012489ef 1183 /// (which they are not by default).
davidr99 0:ab4e012489ef 1184 /// Subclasses may override this function to get control when an RF22 external interrupt occurs.
davidr99 0:ab4e012489ef 1185 virtual void handleExternalInterrupt();
davidr99 0:ab4e012489ef 1186
davidr99 0:ab4e012489ef 1187 /// This function will be called by handleInterrupt() if an RF22 wakeup timer interrupt occurs.
davidr99 0:ab4e012489ef 1188 /// This can only happen if wakeup timer interrupts are enabled in theRF22
davidr99 0:ab4e012489ef 1189 /// (which they are not by default).
davidr99 0:ab4e012489ef 1190 /// Subclasses may override this function to get control when an RF22 wakeup timer interrupt occurs.
davidr99 0:ab4e012489ef 1191 virtual void handleWakeupTimerInterrupt();
davidr99 0:ab4e012489ef 1192
davidr99 0:ab4e012489ef 1193 /// Start the transmission of the contents
davidr99 0:ab4e012489ef 1194 /// of the Tx buffer
davidr99 0:ab4e012489ef 1195 void startTransmit();
davidr99 0:ab4e012489ef 1196
davidr99 0:ab4e012489ef 1197 /// ReStart the transmission of the contents
davidr99 0:ab4e012489ef 1198 /// of the Tx buffer after a atransmission failure
davidr99 0:ab4e012489ef 1199 void restartTransmit();
davidr99 0:ab4e012489ef 1200
davidr99 0:ab4e012489ef 1201 void setThisAddress(uint8_t thisAddress);
davidr99 0:ab4e012489ef 1202
davidr99 0:ab4e012489ef 1203 /// Sets the radio operating mode for the case when the driver is idle (ie not
davidr99 0:ab4e012489ef 1204 /// transmitting or receiving), allowing you to control the idle mode power requirements
davidr99 0:ab4e012489ef 1205 /// at the expense of slower transitions to transmit and receive modes.
davidr99 0:ab4e012489ef 1206 /// By default, the idle mode is RH_RF22_XTON,
davidr99 0:ab4e012489ef 1207 /// but eg setIdleMode(RH_RF22_PLL) will provide a much lower
davidr99 0:ab4e012489ef 1208 /// idle current but slower transitions. Call this function after init().
davidr99 0:ab4e012489ef 1209 /// \param[in] idleMode The chip operating mode to use when the driver is idle. One of the valid definitions for RH_RF22_REG_07_OPERATING_MODE
davidr99 0:ab4e012489ef 1210 void setIdleMode(uint8_t idleMode);
davidr99 0:ab4e012489ef 1211
davidr99 0:ab4e012489ef 1212 protected:
davidr99 0:ab4e012489ef 1213 /// Low level interrupt service routine for RF22 connected to interrupt 0
davidr99 0:ab4e012489ef 1214 static void isr0();
davidr99 0:ab4e012489ef 1215
davidr99 0:ab4e012489ef 1216 /// Low level interrupt service routine for RF22 connected to interrupt 1
davidr99 0:ab4e012489ef 1217 static void isr1();
davidr99 0:ab4e012489ef 1218
davidr99 0:ab4e012489ef 1219 /// Low level interrupt service routine for RF22 connected to interrupt 1
davidr99 0:ab4e012489ef 1220 static void isr2();
davidr99 0:ab4e012489ef 1221
davidr99 0:ab4e012489ef 1222 /// Array of instances connected to interrupts 0 and 1
davidr99 0:ab4e012489ef 1223 static RH_RF22* _deviceForInterrupt[];
davidr99 0:ab4e012489ef 1224
davidr99 0:ab4e012489ef 1225 /// Index of next interrupt number to use in _deviceForInterrupt
davidr99 0:ab4e012489ef 1226 static uint8_t _interruptCount;
davidr99 0:ab4e012489ef 1227
davidr99 0:ab4e012489ef 1228 #if (RH_PLATFORM == RH_PLATFORM_MBED)
davidr99 0:ab4e012489ef 1229 /// The configured interrupt pin connected to this instance
davidr99 0:ab4e012489ef 1230 InterruptIn _interruptPin;
davidr99 0:ab4e012489ef 1231 #else
davidr99 0:ab4e012489ef 1232 /// The configured interrupt pin connected to this instance
davidr99 0:ab4e012489ef 1233 uint8_t _interruptPin;
davidr99 0:ab4e012489ef 1234 #endif
davidr99 0:ab4e012489ef 1235
davidr99 0:ab4e012489ef 1236 /// The index into _deviceForInterrupt[] for this device (if an interrupt is already allocated)
davidr99 0:ab4e012489ef 1237 /// else 0xff
davidr99 0:ab4e012489ef 1238 uint8_t _myInterruptIndex;
davidr99 0:ab4e012489ef 1239
davidr99 0:ab4e012489ef 1240 /// The radio mode to use when mode is idle
davidr99 0:ab4e012489ef 1241 uint8_t _idleMode;
davidr99 0:ab4e012489ef 1242
davidr99 0:ab4e012489ef 1243 /// The device type reported by the RF22
davidr99 0:ab4e012489ef 1244 uint8_t _deviceType;
davidr99 0:ab4e012489ef 1245
davidr99 0:ab4e012489ef 1246 /// The selected CRC polynomial
davidr99 0:ab4e012489ef 1247 CRCPolynomial _polynomial;
davidr99 0:ab4e012489ef 1248
davidr99 0:ab4e012489ef 1249 // These volatile members may get changed in the interrupt service routine
davidr99 0:ab4e012489ef 1250 /// Number of octets in the receiver buffer
davidr99 0:ab4e012489ef 1251 volatile uint8_t _bufLen;
davidr99 0:ab4e012489ef 1252
davidr99 0:ab4e012489ef 1253 /// The receiver buffer
davidr99 0:ab4e012489ef 1254 uint8_t _buf[RH_RF22_MAX_MESSAGE_LEN];
davidr99 0:ab4e012489ef 1255
davidr99 0:ab4e012489ef 1256 /// True when there is a valid message in the Rx buffer
davidr99 0:ab4e012489ef 1257 volatile bool _rxBufValid;
davidr99 0:ab4e012489ef 1258
davidr99 0:ab4e012489ef 1259 /// Index into TX buffer of the next to send chunk
davidr99 0:ab4e012489ef 1260 volatile uint8_t _txBufSentIndex;
davidr99 0:ab4e012489ef 1261
davidr99 0:ab4e012489ef 1262 /// Time in millis since the last preamble was received (and the last time the RSSI was measured)
davidr99 0:ab4e012489ef 1263 uint32_t _lastPreambleTime;
davidr99 0:ab4e012489ef 1264 };
davidr99 0:ab4e012489ef 1265
davidr99 0:ab4e012489ef 1266 /// @example rf22_client.pde
davidr99 0:ab4e012489ef 1267 /// @example rf22_server.pde
davidr99 0:ab4e012489ef 1268
davidr99 0:ab4e012489ef 1269 #endif