Library for HopeRF RFM22 / RFM22B transceiver module ported to mbed. Original Software from Mike McCauley (mikem@open.com.au) . See http://www.open.com.au/mikem/arduino/RF22/
Dependents: RF22_MAX_test_Send Geofence_receiver Geofence_sender Geofence_sender ... more
More Info about RFM22-modules like connecting and a demo-program see RF22-Notebook
RF22.cpp@8:d9e2ca137f2e, 2013-04-07 (annotated)
- Committer:
- charly
- Date:
- Sun Apr 07 11:42:36 2013 +0000
- Revision:
- 8:d9e2ca137f2e
- Parent:
- 7:b86825b9d74b
- Child:
- 9:4002a2c117cc
disable RF22_ENFFERR interrupt, as this stops the receiver after some time
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
charly | 0:79c6d0071c4c | 1 | // RF22.cpp |
charly | 0:79c6d0071c4c | 2 | // |
charly | 0:79c6d0071c4c | 3 | // Copyright (C) 2011 Mike McCauley |
charly | 5:0386600f3408 | 4 | // $Id: RF22.cpp,v 1.17 2013/02/06 21:33:56 mikem Exp mikem $ |
charly | 0:79c6d0071c4c | 5 | // ported to mbed by Karl Zweimueller |
charly | 0:79c6d0071c4c | 6 | |
charly | 0:79c6d0071c4c | 7 | |
charly | 0:79c6d0071c4c | 8 | #include "mbed.h" |
charly | 0:79c6d0071c4c | 9 | #include "RF22.h" |
charly | 0:79c6d0071c4c | 10 | //#include <SPI.h> |
charly | 0:79c6d0071c4c | 11 | |
charly | 0:79c6d0071c4c | 12 | |
charly | 0:79c6d0071c4c | 13 | // Interrupt vectors for the 2 Arduino interrupt pins |
charly | 0:79c6d0071c4c | 14 | // Each interrupt can be handled by a different instance of RF22, allowing you to have |
charly | 0:79c6d0071c4c | 15 | // 2 RF22s per Arduino |
charly | 0:79c6d0071c4c | 16 | //RF22* RF22::_RF22ForInterrupt[2] = {0, 0}; |
charly | 0:79c6d0071c4c | 17 | |
charly | 0:79c6d0071c4c | 18 | // These are indexed by the values of ModemConfigChoice |
charly | 8:d9e2ca137f2e | 19 | // Canned modem configurations generated with |
charly | 5:0386600f3408 | 20 | // http://www.hoperf.com/upload/rf/RF22B%2023B%2031B%2042B%2043B%20Register%20Settings_RevB1-v5.xls |
charly | 0:79c6d0071c4c | 21 | // Stored in flash (program) memory to save SRAM |
charly | 8:d9e2ca137f2e | 22 | /*PROGMEM */ static const RF22::ModemConfig MODEM_CONFIG_TABLE[] = { |
charly | 0:79c6d0071c4c | 23 | { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x00, 0x08 }, // Unmodulated carrier |
charly | 0:79c6d0071c4c | 24 | { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x33, 0x08 }, // FSK, PN9 random modulation, 2, 5 |
charly | 0:79c6d0071c4c | 25 | |
charly | 5:0386600f3408 | 26 | // All the following enable FIFO with reg 71 |
charly | 0:79c6d0071c4c | 27 | // 1c, 1f, 20, 21, 22, 23, 24, 25, 2c, 2d, 2e, 58, 69, 6e, 6f, 70, 71, 72 |
charly | 0:79c6d0071c4c | 28 | // FSK, No Manchester, Max Rb err <1%, Xtal Tol 20ppm |
charly | 0:79c6d0071c4c | 29 | { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x22, 0x08 }, // 2, 5 |
charly | 0:79c6d0071c4c | 30 | { 0x1b, 0x03, 0x41, 0x60, 0x27, 0x52, 0x00, 0x07, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x13, 0xa9, 0x2c, 0x22, 0x3a }, // 2.4, 36 |
charly | 0:79c6d0071c4c | 31 | { 0x1d, 0x03, 0xa1, 0x20, 0x4e, 0xa5, 0x00, 0x13, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x27, 0x52, 0x2c, 0x22, 0x48 }, // 4.8, 45 |
charly | 0:79c6d0071c4c | 32 | { 0x1e, 0x03, 0xd0, 0x00, 0x9d, 0x49, 0x00, 0x45, 0x40, 0x0a, 0x20, 0x80, 0x60, 0x4e, 0xa5, 0x2c, 0x22, 0x48 }, // 9.6, 45 |
charly | 0:79c6d0071c4c | 33 | { 0x2b, 0x03, 0x34, 0x02, 0x75, 0x25, 0x07, 0xff, 0x40, 0x0a, 0x1b, 0x80, 0x60, 0x9d, 0x49, 0x2c, 0x22, 0x0f }, // 19.2, 9.6 |
charly | 0:79c6d0071c4c | 34 | { 0x02, 0x03, 0x68, 0x01, 0x3a, 0x93, 0x04, 0xd5, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x09, 0xd5, 0x0c, 0x22, 0x1f }, // 38.4, 19.6 |
charly | 0:79c6d0071c4c | 35 | { 0x06, 0x03, 0x45, 0x01, 0xd7, 0xdc, 0x07, 0x6e, 0x40, 0x0a, 0x2d, 0x80, 0x60, 0x0e, 0xbf, 0x0c, 0x22, 0x2e }, // 57.6. 28.8 |
charly | 0:79c6d0071c4c | 36 | { 0x8a, 0x03, 0x60, 0x01, 0x55, 0x55, 0x02, 0xad, 0x40, 0x0a, 0x50, 0x80, 0x60, 0x20, 0x00, 0x0c, 0x22, 0xc8 }, // 125, 125 |
charly | 0:79c6d0071c4c | 37 | |
charly | 0:79c6d0071c4c | 38 | // GFSK, No Manchester, Max Rb err <1%, Xtal Tol 20ppm |
charly | 0:79c6d0071c4c | 39 | // These differ from FSK only in register 71, for the modulation type |
charly | 0:79c6d0071c4c | 40 | { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x23, 0x08 }, // 2, 5 |
charly | 0:79c6d0071c4c | 41 | { 0x1b, 0x03, 0x41, 0x60, 0x27, 0x52, 0x00, 0x07, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x13, 0xa9, 0x2c, 0x23, 0x3a }, // 2.4, 36 |
charly | 0:79c6d0071c4c | 42 | { 0x1d, 0x03, 0xa1, 0x20, 0x4e, 0xa5, 0x00, 0x13, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x27, 0x52, 0x2c, 0x23, 0x48 }, // 4.8, 45 |
charly | 0:79c6d0071c4c | 43 | { 0x1e, 0x03, 0xd0, 0x00, 0x9d, 0x49, 0x00, 0x45, 0x40, 0x0a, 0x20, 0x80, 0x60, 0x4e, 0xa5, 0x2c, 0x23, 0x48 }, // 9.6, 45 |
charly | 0:79c6d0071c4c | 44 | { 0x2b, 0x03, 0x34, 0x02, 0x75, 0x25, 0x07, 0xff, 0x40, 0x0a, 0x1b, 0x80, 0x60, 0x9d, 0x49, 0x2c, 0x23, 0x0f }, // 19.2, 9.6 |
charly | 0:79c6d0071c4c | 45 | { 0x02, 0x03, 0x68, 0x01, 0x3a, 0x93, 0x04, 0xd5, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x09, 0xd5, 0x0c, 0x23, 0x1f }, // 38.4, 19.6 |
charly | 0:79c6d0071c4c | 46 | { 0x06, 0x03, 0x45, 0x01, 0xd7, 0xdc, 0x07, 0x6e, 0x40, 0x0a, 0x2d, 0x80, 0x60, 0x0e, 0xbf, 0x0c, 0x23, 0x2e }, // 57.6. 28.8 |
charly | 0:79c6d0071c4c | 47 | { 0x8a, 0x03, 0x60, 0x01, 0x55, 0x55, 0x02, 0xad, 0x40, 0x0a, 0x50, 0x80, 0x60, 0x20, 0x00, 0x0c, 0x23, 0xc8 }, // 125, 125 |
charly | 0:79c6d0071c4c | 48 | |
charly | 0:79c6d0071c4c | 49 | // OOK, No Manchester, Max Rb err <1%, Xtal Tol 20ppm |
charly | 0:79c6d0071c4c | 50 | { 0x51, 0x03, 0x68, 0x00, 0x3a, 0x93, 0x01, 0x3d, 0x2c, 0x11, 0x28, 0x80, 0x60, 0x09, 0xd5, 0x2c, 0x21, 0x08 }, // 1.2, 75 |
charly | 0:79c6d0071c4c | 51 | { 0xc8, 0x03, 0x39, 0x20, 0x68, 0xdc, 0x00, 0x6b, 0x2a, 0x08, 0x2a, 0x80, 0x60, 0x13, 0xa9, 0x2c, 0x21, 0x08 }, // 2.4, 335 |
charly | 0:79c6d0071c4c | 52 | { 0xc8, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x29, 0x04, 0x29, 0x80, 0x60, 0x27, 0x52, 0x2c, 0x21, 0x08 }, // 4.8, 335 |
charly | 0:79c6d0071c4c | 53 | { 0xb8, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x28, 0x82, 0x29, 0x80, 0x60, 0x4e, 0xa5, 0x2c, 0x21, 0x08 }, // 9.6, 335 |
charly | 0:79c6d0071c4c | 54 | { 0xa8, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x28, 0x41, 0x29, 0x80, 0x60, 0x9d, 0x49, 0x2c, 0x21, 0x08 }, // 19.2, 335 |
charly | 0:79c6d0071c4c | 55 | { 0x98, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x28, 0x20, 0x29, 0x80, 0x60, 0x09, 0xd5, 0x0c, 0x21, 0x08 }, // 38.4, 335 |
charly | 0:79c6d0071c4c | 56 | { 0x98, 0x03, 0x96, 0x00, 0xda, 0x74, 0x00, 0xdc, 0x28, 0x1f, 0x29, 0x80, 0x60, 0x0a, 0x3d, 0x0c, 0x21, 0x08 }, // 40, 335 |
charly | 0:79c6d0071c4c | 57 | |
charly | 0:79c6d0071c4c | 58 | }; |
charly | 0:79c6d0071c4c | 59 | |
charly | 0:79c6d0071c4c | 60 | RF22::RF22(PinName slaveSelectPin, PinName mosi, PinName miso, PinName sclk, PinName interrupt) |
charly | 8:d9e2ca137f2e | 61 | : _slaveSelectPin(slaveSelectPin), _spi(mosi, miso, sclk), _interrupt(interrupt), led1(LED1), led2(LED2), led3(LED3), led4(LED4) |
charly | 0:79c6d0071c4c | 62 | { |
charly | 0:79c6d0071c4c | 63 | |
charly | 0:79c6d0071c4c | 64 | |
charly | 0:79c6d0071c4c | 65 | _idleMode = RF22_XTON; // Default idle state is READY mode |
charly | 0:79c6d0071c4c | 66 | _mode = RF22_MODE_IDLE; // We start up in idle mode |
charly | 0:79c6d0071c4c | 67 | _rxGood = 0; |
charly | 0:79c6d0071c4c | 68 | _rxBad = 0; |
charly | 0:79c6d0071c4c | 69 | _txGood = 0; |
charly | 8:d9e2ca137f2e | 70 | |
charly | 8:d9e2ca137f2e | 71 | |
charly | 0:79c6d0071c4c | 72 | } |
charly | 0:79c6d0071c4c | 73 | |
charly | 0:79c6d0071c4c | 74 | boolean RF22::init() |
charly | 0:79c6d0071c4c | 75 | { |
charly | 0:79c6d0071c4c | 76 | // Wait for RF22 POR (up to 16msec) |
charly | 0:79c6d0071c4c | 77 | //delay(16); |
charly | 0:79c6d0071c4c | 78 | wait_ms(16); |
charly | 0:79c6d0071c4c | 79 | |
charly | 0:79c6d0071c4c | 80 | // Initialise the slave select pin |
charly | 0:79c6d0071c4c | 81 | //pinMode(_slaveSelectPin, OUTPUT); |
charly | 0:79c6d0071c4c | 82 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 83 | _slaveSelectPin = 1; |
charly | 8:d9e2ca137f2e | 84 | |
charly | 0:79c6d0071c4c | 85 | wait_ms(100); |
charly | 8:d9e2ca137f2e | 86 | |
charly | 0:79c6d0071c4c | 87 | // start the SPI library: |
charly | 0:79c6d0071c4c | 88 | // Note the RF22 wants mode 0, MSB first and default to 1 Mbps |
charly | 0:79c6d0071c4c | 89 | /*SPI.begin(); |
charly | 0:79c6d0071c4c | 90 | SPI.setDataMode(SPI_MODE0); |
charly | 0:79c6d0071c4c | 91 | SPI.setBitOrder(MSBFIRST); |
charly | 0:79c6d0071c4c | 92 | SPI.setClockDivider(SPI_CLOCK_DIV16); // (16 Mhz / 16) = 1 MHz |
charly | 0:79c6d0071c4c | 93 | */ |
charly | 0:79c6d0071c4c | 94 | |
charly | 0:79c6d0071c4c | 95 | // Setup the spi for 8 bit data : 1RW-bit 7 adressbit and 8 databit |
charly | 0:79c6d0071c4c | 96 | // second edge capture, with a 10MHz clock rate |
charly | 0:79c6d0071c4c | 97 | _spi.format(8,0); |
charly | 0:79c6d0071c4c | 98 | _spi.frequency(10000000); |
charly | 0:79c6d0071c4c | 99 | |
charly | 0:79c6d0071c4c | 100 | // Software reset the device |
charly | 0:79c6d0071c4c | 101 | reset(); |
charly | 0:79c6d0071c4c | 102 | |
charly | 0:79c6d0071c4c | 103 | // Get the device type and check it |
charly | 0:79c6d0071c4c | 104 | // This also tests whether we are really connected to a device |
charly | 0:79c6d0071c4c | 105 | _deviceType = spiRead(RF22_REG_00_DEVICE_TYPE); |
charly | 0:79c6d0071c4c | 106 | if ( _deviceType != RF22_DEVICE_TYPE_RX_TRX |
charly | 8:d9e2ca137f2e | 107 | && _deviceType != RF22_DEVICE_TYPE_TX) |
charly | 8:d9e2ca137f2e | 108 | return false; |
charly | 0:79c6d0071c4c | 109 | |
charly | 0:79c6d0071c4c | 110 | // Set up interrupt handler |
charly | 0:79c6d0071c4c | 111 | // if (_interrupt == 0) |
charly | 0:79c6d0071c4c | 112 | // { |
charly | 0:79c6d0071c4c | 113 | //_RF22ForInterrupt[0] = this; |
charly | 8:d9e2ca137f2e | 114 | //attachInterrupt(0, RF22::isr0, LOW); |
charly | 0:79c6d0071c4c | 115 | _interrupt.fall(this, &RF22::isr0); |
charly | 8:d9e2ca137f2e | 116 | /* } |
charly | 8:d9e2ca137f2e | 117 | else if (_interrupt == 1) |
charly | 8:d9e2ca137f2e | 118 | { |
charly | 8:d9e2ca137f2e | 119 | _RF22ForInterrupt[1] = this; |
charly | 8:d9e2ca137f2e | 120 | attachInterrupt(1, RF22::isr1, LOW); |
charly | 8:d9e2ca137f2e | 121 | } |
charly | 8:d9e2ca137f2e | 122 | else |
charly | 8:d9e2ca137f2e | 123 | return false; |
charly | 8:d9e2ca137f2e | 124 | */ |
charly | 0:79c6d0071c4c | 125 | clearTxBuf(); |
charly | 0:79c6d0071c4c | 126 | clearRxBuf(); |
charly | 8:d9e2ca137f2e | 127 | |
charly | 0:79c6d0071c4c | 128 | // Most of these are the POR default |
charly | 0:79c6d0071c4c | 129 | spiWrite(RF22_REG_7D_TX_FIFO_CONTROL2, RF22_TXFFAEM_THRESHOLD); |
charly | 0:79c6d0071c4c | 130 | spiWrite(RF22_REG_7E_RX_FIFO_CONTROL, RF22_RXFFAFULL_THRESHOLD); |
charly | 0:79c6d0071c4c | 131 | spiWrite(RF22_REG_30_DATA_ACCESS_CONTROL, RF22_ENPACRX | RF22_ENPACTX | RF22_ENCRC | RF22_CRC_CRC_16_IBM); |
charly | 0:79c6d0071c4c | 132 | // Configure the message headers |
charly | 0:79c6d0071c4c | 133 | // Here we set up the standard packet format for use by the RF22 library |
charly | 0:79c6d0071c4c | 134 | // 8 nibbles preamble |
charly | 0:79c6d0071c4c | 135 | // 2 SYNC words 2d, d4 |
charly | 0:79c6d0071c4c | 136 | // Header length 4 (to, from, id, flags) |
charly | 0:79c6d0071c4c | 137 | // 1 octet of data length (0 to 255) |
charly | 0:79c6d0071c4c | 138 | // 0 to 255 octets data |
charly | 0:79c6d0071c4c | 139 | // 2 CRC octets as CRC16(IBM), computed on the header, length and data |
charly | 0:79c6d0071c4c | 140 | // On reception the to address is check for validity against RF22_REG_3F_CHECK_HEADER3 |
charly | 0:79c6d0071c4c | 141 | // or the broadcast address of 0xff |
charly | 0:79c6d0071c4c | 142 | // If no changes are made after this, the transmitted |
charly | 0:79c6d0071c4c | 143 | // to address will be 0xff, the from address will be 0xff |
charly | 0:79c6d0071c4c | 144 | // and all such messages will be accepted. This permits the out-of the box |
charly | 0:79c6d0071c4c | 145 | // RF22 config to act as an unaddresed, unreliable datagram service |
charly | 0:79c6d0071c4c | 146 | spiWrite(RF22_REG_32_HEADER_CONTROL1, RF22_BCEN_HEADER3 | RF22_HDCH_HEADER3); |
charly | 0:79c6d0071c4c | 147 | spiWrite(RF22_REG_33_HEADER_CONTROL2, RF22_HDLEN_4 | RF22_SYNCLEN_2); |
charly | 0:79c6d0071c4c | 148 | setPreambleLength(8); |
charly | 0:79c6d0071c4c | 149 | uint8_t syncwords[] = { 0x2d, 0xd4 }; |
charly | 0:79c6d0071c4c | 150 | setSyncWords(syncwords, sizeof(syncwords)); |
charly | 8:d9e2ca137f2e | 151 | setPromiscuous(false); |
charly | 0:79c6d0071c4c | 152 | // Check the TO header against RF22_DEFAULT_NODE_ADDRESS |
charly | 0:79c6d0071c4c | 153 | spiWrite(RF22_REG_3F_CHECK_HEADER3, RF22_DEFAULT_NODE_ADDRESS); |
charly | 0:79c6d0071c4c | 154 | // Set the default transmit header values |
charly | 0:79c6d0071c4c | 155 | setHeaderTo(RF22_DEFAULT_NODE_ADDRESS); |
charly | 0:79c6d0071c4c | 156 | setHeaderFrom(RF22_DEFAULT_NODE_ADDRESS); |
charly | 0:79c6d0071c4c | 157 | setHeaderId(0); |
charly | 0:79c6d0071c4c | 158 | setHeaderFlags(0); |
charly | 0:79c6d0071c4c | 159 | |
charly | 0:79c6d0071c4c | 160 | // Ensure the antenna can be switched automatically according to transmit and receive |
charly | 0:79c6d0071c4c | 161 | // This assumes GPIO0(out) is connected to TX_ANT(in) to enable tx antenna during transmit |
charly | 0:79c6d0071c4c | 162 | // This assumes GPIO1(out) is connected to RX_ANT(in) to enable rx antenna during receive |
charly | 0:79c6d0071c4c | 163 | spiWrite (RF22_REG_0B_GPIO_CONFIGURATION0, 0x12) ; // TX state |
charly | 0:79c6d0071c4c | 164 | spiWrite (RF22_REG_0C_GPIO_CONFIGURATION1, 0x15) ; // RX state |
charly | 0:79c6d0071c4c | 165 | |
charly | 0:79c6d0071c4c | 166 | // Enable interrupts |
charly | 8:d9e2ca137f2e | 167 | // this is original from arduion, which crashes on mbed after some hours |
charly | 8:d9e2ca137f2e | 168 | //see https://groups.google.com/forum/?fromgroups#!topic/rf22-arduino/Ezkw256yQI8 |
charly | 8:d9e2ca137f2e | 169 | //spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM | RF22_ENRXFFAFULL | RF22_ENPKSENT | RF22_ENPKVALID | RF22_ENCRCERROR | RF22_ENFFERR); |
charly | 8:d9e2ca137f2e | 170 | //without RF22_ENFFERR it works - Charly |
charly | 8:d9e2ca137f2e | 171 | spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM |RF22_ENRXFFAFULL | RF22_ENPKSENT |RF22_ENPKVALID| RF22_ENCRCERROR); |
charly | 8:d9e2ca137f2e | 172 | |
charly | 0:79c6d0071c4c | 173 | spiWrite(RF22_REG_06_INTERRUPT_ENABLE2, RF22_ENPREAVAL); |
charly | 0:79c6d0071c4c | 174 | |
charly | 8:d9e2ca137f2e | 175 | |
charly | 5:0386600f3408 | 176 | // Set some defaults. An innocuous ISM frequency, and reasonable pull-in |
charly | 5:0386600f3408 | 177 | setFrequency(434.0, 0.05); |
charly | 0:79c6d0071c4c | 178 | // setFrequency(900.0); |
charly | 0:79c6d0071c4c | 179 | // Some slow, reliable default speed and modulation |
charly | 0:79c6d0071c4c | 180 | setModemConfig(FSK_Rb2_4Fd36); |
charly | 0:79c6d0071c4c | 181 | // setModemConfig(FSK_Rb125Fd125); |
charly | 0:79c6d0071c4c | 182 | // Minimum power |
charly | 0:79c6d0071c4c | 183 | setTxPower(RF22_TXPOW_8DBM); |
charly | 0:79c6d0071c4c | 184 | // setTxPower(RF22_TXPOW_17DBM); |
charly | 0:79c6d0071c4c | 185 | |
charly | 8:d9e2ca137f2e | 186 | |
charly | 2:f6f42c2ba9f2 | 187 | |
charly | 0:79c6d0071c4c | 188 | return true; |
charly | 0:79c6d0071c4c | 189 | } |
charly | 0:79c6d0071c4c | 190 | |
charly | 0:79c6d0071c4c | 191 | // C++ level interrupt handler for this instance |
charly | 0:79c6d0071c4c | 192 | void RF22::handleInterrupt() |
charly | 0:79c6d0071c4c | 193 | { |
charly | 0:79c6d0071c4c | 194 | uint8_t _lastInterruptFlags[2]; |
charly | 8:d9e2ca137f2e | 195 | |
charly | 8:d9e2ca137f2e | 196 | led1 = 1; |
charly | 8:d9e2ca137f2e | 197 | |
charly | 0:79c6d0071c4c | 198 | // Read the interrupt flags which clears the interrupt |
charly | 0:79c6d0071c4c | 199 | spiBurstRead(RF22_REG_03_INTERRUPT_STATUS1, _lastInterruptFlags, 2); |
charly | 0:79c6d0071c4c | 200 | |
charly | 0:79c6d0071c4c | 201 | #if 0 |
charly | 5:0386600f3408 | 202 | // Caution: Serial printing in this interrupt routine can cause mysterious crashes |
charly | 5:0386600f3408 | 203 | Serial.print("interrupt "); |
charly | 0:79c6d0071c4c | 204 | Serial.print(_lastInterruptFlags[0], HEX); |
charly | 0:79c6d0071c4c | 205 | Serial.print(" "); |
charly | 0:79c6d0071c4c | 206 | Serial.println(_lastInterruptFlags[1], HEX); |
charly | 0:79c6d0071c4c | 207 | if (_lastInterruptFlags[0] == 0 && _lastInterruptFlags[1] == 0) |
charly | 8:d9e2ca137f2e | 208 | Serial.println("FUNNY: no interrupt!"); |
charly | 0:79c6d0071c4c | 209 | #endif |
charly | 0:79c6d0071c4c | 210 | |
charly | 5:0386600f3408 | 211 | #if 0 |
charly | 0:79c6d0071c4c | 212 | // TESTING: fake an RF22_IFFERROR |
charly | 0:79c6d0071c4c | 213 | static int counter = 0; |
charly | 8:d9e2ca137f2e | 214 | if (_lastInterruptFlags[0] & RF22_IPKSENT && counter++ == 10) { |
charly | 8:d9e2ca137f2e | 215 | _lastInterruptFlags[0] = RF22_IFFERROR; |
charly | 8:d9e2ca137f2e | 216 | counter = 0; |
charly | 0:79c6d0071c4c | 217 | } |
charly | 5:0386600f3408 | 218 | #endif |
charly | 0:79c6d0071c4c | 219 | |
charly | 8:d9e2ca137f2e | 220 | |
charly | 8:d9e2ca137f2e | 221 | if (_lastInterruptFlags[0] & RF22_IFFERROR) { |
charly | 8:d9e2ca137f2e | 222 | // Serial.println("IFFERROR"); |
charly | 8:d9e2ca137f2e | 223 | led4 = !led4; |
charly | 8:d9e2ca137f2e | 224 | resetFifos(); // Clears the interrupt |
charly | 8:d9e2ca137f2e | 225 | if (_mode == RF22_MODE_TX) |
charly | 8:d9e2ca137f2e | 226 | restartTransmit(); |
charly | 8:d9e2ca137f2e | 227 | else if (_mode == RF22_MODE_RX){ |
charly | 8:d9e2ca137f2e | 228 | clearRxBuf(); |
charly | 8:d9e2ca137f2e | 229 | //stop and start Rx |
charly | 8:d9e2ca137f2e | 230 | setModeIdle(); |
charly | 8:d9e2ca137f2e | 231 | setModeRx(); |
charly | 8:d9e2ca137f2e | 232 | } |
charly | 8:d9e2ca137f2e | 233 | // stop handling the remaining interruppts as something went wrong here |
charly | 8:d9e2ca137f2e | 234 | return; |
charly | 0:79c6d0071c4c | 235 | } |
charly | 8:d9e2ca137f2e | 236 | |
charly | 8:d9e2ca137f2e | 237 | // Caution, any delay here may cause a FF underflow or overflow |
charly | 8:d9e2ca137f2e | 238 | if (_lastInterruptFlags[0] & RF22_ITXFFAEM) { |
charly | 8:d9e2ca137f2e | 239 | // See if more data has to be loaded into the Tx FIFO |
charly | 8:d9e2ca137f2e | 240 | //led2 = !led2; |
charly | 8:d9e2ca137f2e | 241 | sendNextFragment(); |
charly | 8:d9e2ca137f2e | 242 | // Serial.println("ITXFFAEM"); |
charly | 0:79c6d0071c4c | 243 | } |
charly | 8:d9e2ca137f2e | 244 | |
charly | 8:d9e2ca137f2e | 245 | if (_lastInterruptFlags[0] & RF22_IRXFFAFULL) { |
charly | 8:d9e2ca137f2e | 246 | // Caution, any delay here may cause a FF overflow |
charly | 8:d9e2ca137f2e | 247 | // Read some data from the Rx FIFO |
charly | 8:d9e2ca137f2e | 248 | //led4 = !led4; |
charly | 8:d9e2ca137f2e | 249 | readNextFragment(); |
charly | 8:d9e2ca137f2e | 250 | // Serial.println("IRXFFAFULL"); |
charly | 8:d9e2ca137f2e | 251 | } |
charly | 8:d9e2ca137f2e | 252 | if (_lastInterruptFlags[0] & RF22_IEXT) { |
charly | 8:d9e2ca137f2e | 253 | // This is not enabled by the base code, but users may want to enable it |
charly | 8:d9e2ca137f2e | 254 | //led2 = !led2; |
charly | 8:d9e2ca137f2e | 255 | handleExternalInterrupt(); |
charly | 8:d9e2ca137f2e | 256 | // Serial.println("IEXT"); |
charly | 0:79c6d0071c4c | 257 | } |
charly | 8:d9e2ca137f2e | 258 | if (_lastInterruptFlags[1] & RF22_IWUT) { |
charly | 8:d9e2ca137f2e | 259 | // This is not enabled by the base code, but users may want to enable it |
charly | 8:d9e2ca137f2e | 260 | //led2 = !led2; |
charly | 8:d9e2ca137f2e | 261 | handleWakeupTimerInterrupt(); |
charly | 8:d9e2ca137f2e | 262 | // Serial.println("IWUT"); |
charly | 8:d9e2ca137f2e | 263 | } |
charly | 8:d9e2ca137f2e | 264 | if (_lastInterruptFlags[0] & RF22_IPKSENT) { |
charly | 8:d9e2ca137f2e | 265 | // Serial.println("IPKSENT"); |
charly | 8:d9e2ca137f2e | 266 | _txGood++; |
charly | 8:d9e2ca137f2e | 267 | //led4 = !led4; |
charly | 8:d9e2ca137f2e | 268 | // Transmission does not automatically clear the tx buffer. |
charly | 8:d9e2ca137f2e | 269 | // Could retransmit if we wanted |
charly | 8:d9e2ca137f2e | 270 | // RF22 transitions automatically to Idle |
charly | 8:d9e2ca137f2e | 271 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 272 | } |
charly | 8:d9e2ca137f2e | 273 | |
charly | 8:d9e2ca137f2e | 274 | if (_lastInterruptFlags[0] & RF22_IPKVALID) { |
charly | 8:d9e2ca137f2e | 275 | uint8_t len = spiRead(RF22_REG_4B_RECEIVED_PACKET_LENGTH); |
charly | 8:d9e2ca137f2e | 276 | // Serial.println("IPKVALID"); |
charly | 8:d9e2ca137f2e | 277 | // Serial.println(len); |
charly | 8:d9e2ca137f2e | 278 | // Serial.println(_bufLen); |
charly | 5:0386600f3408 | 279 | |
charly | 8:d9e2ca137f2e | 280 | // May have already read one or more fragments |
charly | 8:d9e2ca137f2e | 281 | // Get any remaining unread octets, based on the expected length |
charly | 8:d9e2ca137f2e | 282 | // First make sure we dont overflow the buffer in the case of a stupid length |
charly | 8:d9e2ca137f2e | 283 | // or partial bad receives |
charly | 8:d9e2ca137f2e | 284 | |
charly | 8:d9e2ca137f2e | 285 | if ( len > RF22_MAX_MESSAGE_LEN |
charly | 8:d9e2ca137f2e | 286 | || len < _bufLen) { |
charly | 8:d9e2ca137f2e | 287 | _rxBad++; |
charly | 8:d9e2ca137f2e | 288 | led2 = !led2; |
charly | 8:d9e2ca137f2e | 289 | _mode = RF22_MODE_IDLE; |
charly | 8:d9e2ca137f2e | 290 | clearRxBuf(); |
charly | 8:d9e2ca137f2e | 291 | return; // Hmmm receiver buffer overflow. |
charly | 8:d9e2ca137f2e | 292 | } |
charly | 8:d9e2ca137f2e | 293 | |
charly | 8:d9e2ca137f2e | 294 | spiBurstRead(RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, len - _bufLen); |
charly | 8:d9e2ca137f2e | 295 | //__disable_irq(); // Disable Interrupts |
charly | 8:d9e2ca137f2e | 296 | _rxGood++; |
charly | 8:d9e2ca137f2e | 297 | _bufLen = len; |
charly | 5:0386600f3408 | 298 | _mode = RF22_MODE_IDLE; |
charly | 8:d9e2ca137f2e | 299 | _rxBufValid = true; |
charly | 8:d9e2ca137f2e | 300 | // reset the fifo for next packet?? |
charly | 8:d9e2ca137f2e | 301 | //resetRxFifo(); |
charly | 8:d9e2ca137f2e | 302 | //__enable_irq(); // Enable Interrupts |
charly | 5:0386600f3408 | 303 | |
charly | 8:d9e2ca137f2e | 304 | led3 = !led3; |
charly | 5:0386600f3408 | 305 | |
charly | 0:79c6d0071c4c | 306 | } |
charly | 8:d9e2ca137f2e | 307 | |
charly | 8:d9e2ca137f2e | 308 | if (_lastInterruptFlags[0] & RF22_ICRCERROR) { |
charly | 8:d9e2ca137f2e | 309 | // Serial.println("ICRCERR"); |
charly | 8:d9e2ca137f2e | 310 | _rxBad++; |
charly | 8:d9e2ca137f2e | 311 | led2 = !led2; |
charly | 8:d9e2ca137f2e | 312 | clearRxBuf(); |
charly | 8:d9e2ca137f2e | 313 | resetRxFifo(); |
charly | 8:d9e2ca137f2e | 314 | _mode = RF22_MODE_IDLE; |
charly | 8:d9e2ca137f2e | 315 | setModeRx(); // Keep trying |
charly | 0:79c6d0071c4c | 316 | } |
charly | 8:d9e2ca137f2e | 317 | |
charly | 8:d9e2ca137f2e | 318 | if (_lastInterruptFlags[1] & RF22_IPREAVAL) { |
charly | 8:d9e2ca137f2e | 319 | // Serial.println("IPREAVAL"); |
charly | 8:d9e2ca137f2e | 320 | |
charly | 8:d9e2ca137f2e | 321 | _lastRssi = spiRead(RF22_REG_26_RSSI); |
charly | 8:d9e2ca137f2e | 322 | |
charly | 8:d9e2ca137f2e | 323 | |
charly | 8:d9e2ca137f2e | 324 | // why clear the rx-buf here? charly |
charly | 8:d9e2ca137f2e | 325 | clearRxBuf(); |
charly | 8:d9e2ca137f2e | 326 | |
charly | 8:d9e2ca137f2e | 327 | |
charly | 0:79c6d0071c4c | 328 | } |
charly | 7:b86825b9d74b | 329 | led1 = 0; |
charly | 0:79c6d0071c4c | 330 | } |
charly | 0:79c6d0071c4c | 331 | |
charly | 0:79c6d0071c4c | 332 | // These are low level functions that call the interrupt handler for the correct |
charly | 0:79c6d0071c4c | 333 | // instance of RF22. |
charly | 0:79c6d0071c4c | 334 | // 2 interrupts allows us to have 2 different devices |
charly | 0:79c6d0071c4c | 335 | void RF22::isr0() |
charly | 0:79c6d0071c4c | 336 | { |
charly | 0:79c6d0071c4c | 337 | //if (_RF22ForInterrupt[0]) |
charly | 0:79c6d0071c4c | 338 | //_RF22ForInterrupt[0]->handleInterrupt(); |
charly | 0:79c6d0071c4c | 339 | handleInterrupt(); |
charly | 0:79c6d0071c4c | 340 | } |
charly | 0:79c6d0071c4c | 341 | /* |
charly | 0:79c6d0071c4c | 342 | void RF22::isr1() |
charly | 0:79c6d0071c4c | 343 | { |
charly | 0:79c6d0071c4c | 344 | if (_RF22ForInterrupt[1]) |
charly | 0:79c6d0071c4c | 345 | _RF22ForInterrupt[1]->handleInterrupt(); |
charly | 0:79c6d0071c4c | 346 | } |
charly | 0:79c6d0071c4c | 347 | */ |
charly | 0:79c6d0071c4c | 348 | void RF22::reset() |
charly | 0:79c6d0071c4c | 349 | { |
charly | 0:79c6d0071c4c | 350 | spiWrite(RF22_REG_07_OPERATING_MODE1, RF22_SWRES); |
charly | 0:79c6d0071c4c | 351 | // Wait for it to settle |
charly | 0:79c6d0071c4c | 352 | //delay(1); // SWReset time is nominally 100usec |
charly | 0:79c6d0071c4c | 353 | wait_ms(1); |
charly | 0:79c6d0071c4c | 354 | } |
charly | 0:79c6d0071c4c | 355 | |
charly | 0:79c6d0071c4c | 356 | uint8_t RF22::spiRead(uint8_t reg) |
charly | 0:79c6d0071c4c | 357 | { |
charly | 7:b86825b9d74b | 358 | __disable_irq(); // Disable Interrupts |
charly | 0:79c6d0071c4c | 359 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 360 | _slaveSelectPin=0; |
charly | 0:79c6d0071c4c | 361 | //_spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the address with the write mask off |
charly | 0:79c6d0071c4c | 362 | _spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the address with the write mask off |
charly | 0:79c6d0071c4c | 363 | uint8_t val = _spi.write(0); // The written value is ignored, reg value is read |
charly | 0:79c6d0071c4c | 364 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 365 | _slaveSelectPin = 1; |
charly | 7:b86825b9d74b | 366 | __enable_irq(); // Enable Interrupts |
charly | 0:79c6d0071c4c | 367 | return val; |
charly | 0:79c6d0071c4c | 368 | } |
charly | 0:79c6d0071c4c | 369 | |
charly | 0:79c6d0071c4c | 370 | void RF22::spiWrite(uint8_t reg, uint8_t val) |
charly | 0:79c6d0071c4c | 371 | { |
charly | 7:b86825b9d74b | 372 | __disable_irq(); // Disable Interrupts |
charly | 0:79c6d0071c4c | 373 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 374 | _slaveSelectPin = 0; |
charly | 0:79c6d0071c4c | 375 | _spi.write(reg | RF22_SPI_WRITE_MASK); // Send the address with the write mask on |
charly | 0:79c6d0071c4c | 376 | _spi.write(val); // New value follows |
charly | 0:79c6d0071c4c | 377 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 378 | _slaveSelectPin = 1; |
charly | 7:b86825b9d74b | 379 | __enable_irq(); // Enable Interrupts |
charly | 0:79c6d0071c4c | 380 | } |
charly | 0:79c6d0071c4c | 381 | |
charly | 0:79c6d0071c4c | 382 | void RF22::spiBurstRead(uint8_t reg, uint8_t* dest, uint8_t len) |
charly | 0:79c6d0071c4c | 383 | { |
charly | 0:79c6d0071c4c | 384 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 385 | _slaveSelectPin = 0; |
charly | 0:79c6d0071c4c | 386 | _spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the start address with the write mask off |
charly | 0:79c6d0071c4c | 387 | while (len--) |
charly | 8:d9e2ca137f2e | 388 | *dest++ = _spi.write(0); |
charly | 0:79c6d0071c4c | 389 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 390 | _slaveSelectPin = 1; |
charly | 0:79c6d0071c4c | 391 | } |
charly | 0:79c6d0071c4c | 392 | |
charly | 5:0386600f3408 | 393 | void RF22::spiBurstWrite(uint8_t reg, const uint8_t* src, uint8_t len) |
charly | 0:79c6d0071c4c | 394 | { |
charly | 0:79c6d0071c4c | 395 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 396 | _slaveSelectPin = 0; |
charly | 0:79c6d0071c4c | 397 | _spi.write(reg | RF22_SPI_WRITE_MASK); // Send the start address with the write mask on |
charly | 0:79c6d0071c4c | 398 | while (len--) |
charly | 8:d9e2ca137f2e | 399 | _spi.write(*src++); |
charly | 0:79c6d0071c4c | 400 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 401 | _slaveSelectPin = 1; |
charly | 0:79c6d0071c4c | 402 | } |
charly | 0:79c6d0071c4c | 403 | |
charly | 0:79c6d0071c4c | 404 | uint8_t RF22::statusRead() |
charly | 0:79c6d0071c4c | 405 | { |
charly | 0:79c6d0071c4c | 406 | return spiRead(RF22_REG_02_DEVICE_STATUS); |
charly | 0:79c6d0071c4c | 407 | } |
charly | 0:79c6d0071c4c | 408 | |
charly | 0:79c6d0071c4c | 409 | uint8_t RF22::adcRead(uint8_t adcsel, |
charly | 0:79c6d0071c4c | 410 | uint8_t adcref , |
charly | 8:d9e2ca137f2e | 411 | uint8_t adcgain, |
charly | 0:79c6d0071c4c | 412 | uint8_t adcoffs) |
charly | 0:79c6d0071c4c | 413 | { |
charly | 0:79c6d0071c4c | 414 | uint8_t configuration = adcsel | adcref | (adcgain & RF22_ADCGAIN); |
charly | 0:79c6d0071c4c | 415 | spiWrite(RF22_REG_0F_ADC_CONFIGURATION, configuration | RF22_ADCSTART); |
charly | 0:79c6d0071c4c | 416 | spiWrite(RF22_REG_10_ADC_SENSOR_AMP_OFFSET, adcoffs); |
charly | 0:79c6d0071c4c | 417 | |
charly | 0:79c6d0071c4c | 418 | // Conversion time is nominally 305usec |
charly | 0:79c6d0071c4c | 419 | // Wait for the DONE bit |
charly | 0:79c6d0071c4c | 420 | while (!(spiRead(RF22_REG_0F_ADC_CONFIGURATION) & RF22_ADCDONE)) |
charly | 8:d9e2ca137f2e | 421 | ; |
charly | 8:d9e2ca137f2e | 422 | // Return the value |
charly | 0:79c6d0071c4c | 423 | return spiRead(RF22_REG_11_ADC_VALUE); |
charly | 0:79c6d0071c4c | 424 | } |
charly | 0:79c6d0071c4c | 425 | |
charly | 0:79c6d0071c4c | 426 | uint8_t RF22::temperatureRead(uint8_t tsrange, uint8_t tvoffs) |
charly | 0:79c6d0071c4c | 427 | { |
charly | 0:79c6d0071c4c | 428 | spiWrite(RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION, tsrange | RF22_ENTSOFFS); |
charly | 0:79c6d0071c4c | 429 | spiWrite(RF22_REG_13_TEMPERATURE_VALUE_OFFSET, tvoffs); |
charly | 8:d9e2ca137f2e | 430 | return adcRead(RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR | RF22_ADCREF_BANDGAP_VOLTAGE); |
charly | 0:79c6d0071c4c | 431 | } |
charly | 0:79c6d0071c4c | 432 | |
charly | 0:79c6d0071c4c | 433 | uint16_t RF22::wutRead() |
charly | 0:79c6d0071c4c | 434 | { |
charly | 0:79c6d0071c4c | 435 | uint8_t buf[2]; |
charly | 0:79c6d0071c4c | 436 | spiBurstRead(RF22_REG_17_WAKEUP_TIMER_VALUE1, buf, 2); |
charly | 0:79c6d0071c4c | 437 | return ((uint16_t)buf[0] << 8) | buf[1]; // Dont rely on byte order |
charly | 0:79c6d0071c4c | 438 | } |
charly | 0:79c6d0071c4c | 439 | |
charly | 0:79c6d0071c4c | 440 | // RFM-22 doc appears to be wrong: WUT for wtm = 10000, r, = 0, d = 0 is about 1 sec |
charly | 0:79c6d0071c4c | 441 | void RF22::setWutPeriod(uint16_t wtm, uint8_t wtr, uint8_t wtd) |
charly | 0:79c6d0071c4c | 442 | { |
charly | 0:79c6d0071c4c | 443 | uint8_t period[3]; |
charly | 0:79c6d0071c4c | 444 | |
charly | 0:79c6d0071c4c | 445 | period[0] = ((wtr & 0xf) << 2) | (wtd & 0x3); |
charly | 0:79c6d0071c4c | 446 | period[1] = wtm >> 8; |
charly | 0:79c6d0071c4c | 447 | period[2] = wtm & 0xff; |
charly | 0:79c6d0071c4c | 448 | spiBurstWrite(RF22_REG_14_WAKEUP_TIMER_PERIOD1, period, sizeof(period)); |
charly | 0:79c6d0071c4c | 449 | } |
charly | 0:79c6d0071c4c | 450 | |
charly | 0:79c6d0071c4c | 451 | // Returns true if centre + (fhch * fhs) is within limits |
charly | 5:0386600f3408 | 452 | // Caution, different versions of the RF22 support different max freq |
charly | 0:79c6d0071c4c | 453 | // so YMMV |
charly | 5:0386600f3408 | 454 | boolean RF22::setFrequency(float centre, float afcPullInRange) |
charly | 0:79c6d0071c4c | 455 | { |
charly | 0:79c6d0071c4c | 456 | uint8_t fbsel = RF22_SBSEL; |
charly | 5:0386600f3408 | 457 | uint8_t afclimiter; |
charly | 0:79c6d0071c4c | 458 | if (centre < 240.0 || centre > 960.0) // 930.0 for early silicon |
charly | 5:0386600f3408 | 459 | return false; |
charly | 8:d9e2ca137f2e | 460 | if (centre >= 480.0) { |
charly | 8:d9e2ca137f2e | 461 | if (afcPullInRange < 0.0 || afcPullInRange > 0.318750) |
charly | 8:d9e2ca137f2e | 462 | return false; |
charly | 8:d9e2ca137f2e | 463 | centre /= 2; |
charly | 8:d9e2ca137f2e | 464 | fbsel |= RF22_HBSEL; |
charly | 8:d9e2ca137f2e | 465 | afclimiter = afcPullInRange * 1000000.0 / 1250.0; |
charly | 8:d9e2ca137f2e | 466 | } else { |
charly | 8:d9e2ca137f2e | 467 | if (afcPullInRange < 0.0 || afcPullInRange > 0.159375) |
charly | 8:d9e2ca137f2e | 468 | return false; |
charly | 8:d9e2ca137f2e | 469 | afclimiter = afcPullInRange * 1000000.0 / 625.0; |
charly | 0:79c6d0071c4c | 470 | } |
charly | 0:79c6d0071c4c | 471 | centre /= 10.0; |
charly | 0:79c6d0071c4c | 472 | float integerPart = floor(centre); |
charly | 0:79c6d0071c4c | 473 | float fractionalPart = centre - integerPart; |
charly | 0:79c6d0071c4c | 474 | |
charly | 0:79c6d0071c4c | 475 | uint8_t fb = (uint8_t)integerPart - 24; // Range 0 to 23 |
charly | 0:79c6d0071c4c | 476 | fbsel |= fb; |
charly | 0:79c6d0071c4c | 477 | uint16_t fc = fractionalPart * 64000; |
charly | 0:79c6d0071c4c | 478 | spiWrite(RF22_REG_73_FREQUENCY_OFFSET1, 0); // REVISIT |
charly | 0:79c6d0071c4c | 479 | spiWrite(RF22_REG_74_FREQUENCY_OFFSET2, 0); |
charly | 0:79c6d0071c4c | 480 | spiWrite(RF22_REG_75_FREQUENCY_BAND_SELECT, fbsel); |
charly | 0:79c6d0071c4c | 481 | spiWrite(RF22_REG_76_NOMINAL_CARRIER_FREQUENCY1, fc >> 8); |
charly | 0:79c6d0071c4c | 482 | spiWrite(RF22_REG_77_NOMINAL_CARRIER_FREQUENCY0, fc & 0xff); |
charly | 5:0386600f3408 | 483 | spiWrite(RF22_REG_2A_AFC_LIMITER, afclimiter); |
charly | 0:79c6d0071c4c | 484 | return !(statusRead() & RF22_FREQERR); |
charly | 0:79c6d0071c4c | 485 | } |
charly | 0:79c6d0071c4c | 486 | |
charly | 0:79c6d0071c4c | 487 | // Step size in 10kHz increments |
charly | 0:79c6d0071c4c | 488 | // Returns true if centre + (fhch * fhs) is within limits |
charly | 0:79c6d0071c4c | 489 | boolean RF22::setFHStepSize(uint8_t fhs) |
charly | 0:79c6d0071c4c | 490 | { |
charly | 0:79c6d0071c4c | 491 | spiWrite(RF22_REG_7A_FREQUENCY_HOPPING_STEP_SIZE, fhs); |
charly | 0:79c6d0071c4c | 492 | return !(statusRead() & RF22_FREQERR); |
charly | 0:79c6d0071c4c | 493 | } |
charly | 0:79c6d0071c4c | 494 | |
charly | 0:79c6d0071c4c | 495 | // Adds fhch * fhs to centre frequency |
charly | 0:79c6d0071c4c | 496 | // Returns true if centre + (fhch * fhs) is within limits |
charly | 0:79c6d0071c4c | 497 | boolean RF22::setFHChannel(uint8_t fhch) |
charly | 0:79c6d0071c4c | 498 | { |
charly | 0:79c6d0071c4c | 499 | spiWrite(RF22_REG_79_FREQUENCY_HOPPING_CHANNEL_SELECT, fhch); |
charly | 0:79c6d0071c4c | 500 | return !(statusRead() & RF22_FREQERR); |
charly | 0:79c6d0071c4c | 501 | } |
charly | 0:79c6d0071c4c | 502 | |
charly | 0:79c6d0071c4c | 503 | uint8_t RF22::rssiRead() |
charly | 0:79c6d0071c4c | 504 | { |
charly | 0:79c6d0071c4c | 505 | return spiRead(RF22_REG_26_RSSI); |
charly | 0:79c6d0071c4c | 506 | } |
charly | 0:79c6d0071c4c | 507 | |
charly | 0:79c6d0071c4c | 508 | uint8_t RF22::ezmacStatusRead() |
charly | 0:79c6d0071c4c | 509 | { |
charly | 0:79c6d0071c4c | 510 | return spiRead(RF22_REG_31_EZMAC_STATUS); |
charly | 0:79c6d0071c4c | 511 | } |
charly | 0:79c6d0071c4c | 512 | |
charly | 0:79c6d0071c4c | 513 | void RF22::setMode(uint8_t mode) |
charly | 0:79c6d0071c4c | 514 | { |
charly | 0:79c6d0071c4c | 515 | spiWrite(RF22_REG_07_OPERATING_MODE1, mode); |
charly | 0:79c6d0071c4c | 516 | } |
charly | 0:79c6d0071c4c | 517 | |
charly | 0:79c6d0071c4c | 518 | void RF22::setModeIdle() |
charly | 0:79c6d0071c4c | 519 | { |
charly | 8:d9e2ca137f2e | 520 | if (_mode != RF22_MODE_IDLE) { |
charly | 8:d9e2ca137f2e | 521 | setMode(_idleMode); |
charly | 8:d9e2ca137f2e | 522 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 523 | } |
charly | 0:79c6d0071c4c | 524 | } |
charly | 0:79c6d0071c4c | 525 | |
charly | 0:79c6d0071c4c | 526 | void RF22::setModeRx() |
charly | 0:79c6d0071c4c | 527 | { |
charly | 8:d9e2ca137f2e | 528 | if (_mode != RF22_MODE_RX) { |
charly | 8:d9e2ca137f2e | 529 | setMode(_idleMode | RF22_RXON); |
charly | 8:d9e2ca137f2e | 530 | _mode = RF22_MODE_RX; |
charly | 0:79c6d0071c4c | 531 | } |
charly | 0:79c6d0071c4c | 532 | } |
charly | 0:79c6d0071c4c | 533 | |
charly | 0:79c6d0071c4c | 534 | void RF22::setModeTx() |
charly | 0:79c6d0071c4c | 535 | { |
charly | 8:d9e2ca137f2e | 536 | if (_mode != RF22_MODE_TX) { |
charly | 8:d9e2ca137f2e | 537 | setMode(_idleMode | RF22_TXON); |
charly | 8:d9e2ca137f2e | 538 | _mode = RF22_MODE_TX; |
charly | 8:d9e2ca137f2e | 539 | // Hmmm, if you dont clear the RX FIFO here, then it appears that going |
charly | 8:d9e2ca137f2e | 540 | // to transmit mode in the middle of a receive can corrupt the |
charly | 8:d9e2ca137f2e | 541 | // RX FIFO |
charly | 8:d9e2ca137f2e | 542 | resetRxFifo(); |
charly | 8:d9e2ca137f2e | 543 | // clearRxBuf(); |
charly | 0:79c6d0071c4c | 544 | } |
charly | 8:d9e2ca137f2e | 545 | } |
charly | 5:0386600f3408 | 546 | |
charly | 5:0386600f3408 | 547 | uint8_t RF22::mode() |
charly | 5:0386600f3408 | 548 | { |
charly | 5:0386600f3408 | 549 | return _mode; |
charly | 0:79c6d0071c4c | 550 | } |
charly | 0:79c6d0071c4c | 551 | |
charly | 0:79c6d0071c4c | 552 | void RF22::setTxPower(uint8_t power) |
charly | 0:79c6d0071c4c | 553 | { |
charly | 0:79c6d0071c4c | 554 | spiWrite(RF22_REG_6D_TX_POWER, power); |
charly | 0:79c6d0071c4c | 555 | } |
charly | 0:79c6d0071c4c | 556 | |
charly | 0:79c6d0071c4c | 557 | // Sets registers from a canned modem configuration structure |
charly | 5:0386600f3408 | 558 | void RF22::setModemRegisters(const ModemConfig* config) |
charly | 0:79c6d0071c4c | 559 | { |
charly | 0:79c6d0071c4c | 560 | spiWrite(RF22_REG_1C_IF_FILTER_BANDWIDTH, config->reg_1c); |
charly | 0:79c6d0071c4c | 561 | spiWrite(RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE, config->reg_1f); |
charly | 0:79c6d0071c4c | 562 | spiBurstWrite(RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE, &config->reg_20, 6); |
charly | 0:79c6d0071c4c | 563 | spiBurstWrite(RF22_REG_2C_OOK_COUNTER_VALUE_1, &config->reg_2c, 3); |
charly | 0:79c6d0071c4c | 564 | spiWrite(RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING, config->reg_58); |
charly | 0:79c6d0071c4c | 565 | spiWrite(RF22_REG_69_AGC_OVERRIDE1, config->reg_69); |
charly | 0:79c6d0071c4c | 566 | spiBurstWrite(RF22_REG_6E_TX_DATA_RATE1, &config->reg_6e, 5); |
charly | 0:79c6d0071c4c | 567 | } |
charly | 0:79c6d0071c4c | 568 | |
charly | 0:79c6d0071c4c | 569 | // Set one of the canned FSK Modem configs |
charly | 0:79c6d0071c4c | 570 | // Returns true if its a valid choice |
charly | 0:79c6d0071c4c | 571 | boolean RF22::setModemConfig(ModemConfigChoice index) |
charly | 0:79c6d0071c4c | 572 | { |
charly | 0:79c6d0071c4c | 573 | if (index > (sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig))) |
charly | 0:79c6d0071c4c | 574 | return false; |
charly | 0:79c6d0071c4c | 575 | |
charly | 0:79c6d0071c4c | 576 | RF22::ModemConfig cfg; |
charly | 0:79c6d0071c4c | 577 | memcpy(&cfg, &MODEM_CONFIG_TABLE[index], sizeof(RF22::ModemConfig)); |
charly | 0:79c6d0071c4c | 578 | setModemRegisters(&cfg); |
charly | 0:79c6d0071c4c | 579 | |
charly | 0:79c6d0071c4c | 580 | return true; |
charly | 0:79c6d0071c4c | 581 | } |
charly | 0:79c6d0071c4c | 582 | |
charly | 0:79c6d0071c4c | 583 | // REVISIT: top bit is in Header Control 2 0x33 |
charly | 0:79c6d0071c4c | 584 | void RF22::setPreambleLength(uint8_t nibbles) |
charly | 0:79c6d0071c4c | 585 | { |
charly | 0:79c6d0071c4c | 586 | spiWrite(RF22_REG_34_PREAMBLE_LENGTH, nibbles); |
charly | 0:79c6d0071c4c | 587 | } |
charly | 0:79c6d0071c4c | 588 | |
charly | 0:79c6d0071c4c | 589 | // Caution doesnt set sync word len in Header Control 2 0x33 |
charly | 5:0386600f3408 | 590 | void RF22::setSyncWords(const uint8_t* syncWords, uint8_t len) |
charly | 0:79c6d0071c4c | 591 | { |
charly | 0:79c6d0071c4c | 592 | spiBurstWrite(RF22_REG_36_SYNC_WORD3, syncWords, len); |
charly | 0:79c6d0071c4c | 593 | } |
charly | 0:79c6d0071c4c | 594 | |
charly | 0:79c6d0071c4c | 595 | void RF22::clearRxBuf() |
charly | 0:79c6d0071c4c | 596 | { |
charly | 7:b86825b9d74b | 597 | __disable_irq(); // Disable Interrupts |
charly | 0:79c6d0071c4c | 598 | _bufLen = 0; |
charly | 0:79c6d0071c4c | 599 | _rxBufValid = false; |
charly | 7:b86825b9d74b | 600 | __enable_irq(); // Enable Interrupts |
charly | 0:79c6d0071c4c | 601 | } |
charly | 0:79c6d0071c4c | 602 | |
charly | 0:79c6d0071c4c | 603 | boolean RF22::available() |
charly | 0:79c6d0071c4c | 604 | { |
charly | 5:0386600f3408 | 605 | if (!_rxBufValid) |
charly | 8:d9e2ca137f2e | 606 | setModeRx(); // Make sure we are receiving |
charly | 0:79c6d0071c4c | 607 | return _rxBufValid; |
charly | 0:79c6d0071c4c | 608 | } |
charly | 0:79c6d0071c4c | 609 | |
charly | 0:79c6d0071c4c | 610 | // Blocks until a valid message is received |
charly | 0:79c6d0071c4c | 611 | void RF22::waitAvailable() |
charly | 0:79c6d0071c4c | 612 | { |
charly | 0:79c6d0071c4c | 613 | while (!available()) |
charly | 8:d9e2ca137f2e | 614 | ; |
charly | 0:79c6d0071c4c | 615 | } |
charly | 0:79c6d0071c4c | 616 | |
charly | 0:79c6d0071c4c | 617 | // Blocks until a valid message is received or timeout expires |
charly | 0:79c6d0071c4c | 618 | // Return true if there is a message available |
charly | 0:79c6d0071c4c | 619 | bool RF22::waitAvailableTimeout(uint16_t timeout) |
charly | 0:79c6d0071c4c | 620 | { |
charly | 0:79c6d0071c4c | 621 | Timer t; |
charly | 0:79c6d0071c4c | 622 | t.start(); |
charly | 0:79c6d0071c4c | 623 | unsigned long endtime = t.read_ms() + timeout; |
charly | 0:79c6d0071c4c | 624 | while (t.read_ms() < endtime) |
charly | 8:d9e2ca137f2e | 625 | if (available()) |
charly | 8:d9e2ca137f2e | 626 | return true; |
charly | 0:79c6d0071c4c | 627 | return false; |
charly | 0:79c6d0071c4c | 628 | } |
charly | 0:79c6d0071c4c | 629 | |
charly | 0:79c6d0071c4c | 630 | void RF22::waitPacketSent() |
charly | 0:79c6d0071c4c | 631 | { |
charly | 5:0386600f3408 | 632 | while (_mode == RF22_MODE_TX) |
charly | 8:d9e2ca137f2e | 633 | ; // Wait for any previous transmit to finish |
charly | 5:0386600f3408 | 634 | } |
charly | 5:0386600f3408 | 635 | |
charly | 5:0386600f3408 | 636 | // Diagnostic help |
charly | 5:0386600f3408 | 637 | void RF22::printBuffer(const char* prompt, const uint8_t* buf, uint8_t len) |
charly | 5:0386600f3408 | 638 | { |
charly | 5:0386600f3408 | 639 | #ifdef RF22_HAVE_SERIAL |
charly | 5:0386600f3408 | 640 | uint8_t i; |
charly | 5:0386600f3408 | 641 | |
charly | 5:0386600f3408 | 642 | Serial.println(prompt); |
charly | 8:d9e2ca137f2e | 643 | for (i = 0; i < len; i++) { |
charly | 8:d9e2ca137f2e | 644 | if (i % 16 == 15) |
charly | 8:d9e2ca137f2e | 645 | Serial.println(buf[i], HEX); |
charly | 8:d9e2ca137f2e | 646 | else { |
charly | 8:d9e2ca137f2e | 647 | Serial.print(buf[i], HEX); |
charly | 8:d9e2ca137f2e | 648 | Serial.print(' '); |
charly | 8:d9e2ca137f2e | 649 | } |
charly | 5:0386600f3408 | 650 | } |
charly | 5:0386600f3408 | 651 | Serial.println(' '); |
charly | 5:0386600f3408 | 652 | #endif |
charly | 0:79c6d0071c4c | 653 | } |
charly | 0:79c6d0071c4c | 654 | |
charly | 0:79c6d0071c4c | 655 | boolean RF22::recv(uint8_t* buf, uint8_t* len) |
charly | 0:79c6d0071c4c | 656 | { |
charly | 0:79c6d0071c4c | 657 | if (!available()) |
charly | 8:d9e2ca137f2e | 658 | return false; |
charly | 8:d9e2ca137f2e | 659 | __disable_irq(); // Disable Interrupts |
charly | 0:79c6d0071c4c | 660 | if (*len > _bufLen) |
charly | 8:d9e2ca137f2e | 661 | *len = _bufLen; |
charly | 0:79c6d0071c4c | 662 | memcpy(buf, _buf, *len); |
charly | 0:79c6d0071c4c | 663 | clearRxBuf(); |
charly | 8:d9e2ca137f2e | 664 | __enable_irq(); // Enable Interrupts |
charly | 5:0386600f3408 | 665 | // printBuffer("recv:", buf, *len); |
charly | 5:0386600f3408 | 666 | // } |
charly | 0:79c6d0071c4c | 667 | return true; |
charly | 0:79c6d0071c4c | 668 | } |
charly | 0:79c6d0071c4c | 669 | |
charly | 0:79c6d0071c4c | 670 | void RF22::clearTxBuf() |
charly | 0:79c6d0071c4c | 671 | { |
charly | 7:b86825b9d74b | 672 | __disable_irq(); // Disable Interrupts |
charly | 0:79c6d0071c4c | 673 | _bufLen = 0; |
charly | 0:79c6d0071c4c | 674 | _txBufSentIndex = 0; |
charly | 0:79c6d0071c4c | 675 | _txPacketSent = false; |
charly | 7:b86825b9d74b | 676 | __enable_irq(); // Enable Interrupts |
charly | 0:79c6d0071c4c | 677 | } |
charly | 0:79c6d0071c4c | 678 | |
charly | 0:79c6d0071c4c | 679 | void RF22::startTransmit() |
charly | 0:79c6d0071c4c | 680 | { |
charly | 0:79c6d0071c4c | 681 | sendNextFragment(); // Actually the first fragment |
charly | 0:79c6d0071c4c | 682 | spiWrite(RF22_REG_3E_PACKET_LENGTH, _bufLen); // Total length that will be sent |
charly | 0:79c6d0071c4c | 683 | setModeTx(); // Start the transmitter, turns off the receiver |
charly | 0:79c6d0071c4c | 684 | } |
charly | 0:79c6d0071c4c | 685 | |
charly | 5:0386600f3408 | 686 | // Restart the transmission of a packet that had a problem |
charly | 0:79c6d0071c4c | 687 | void RF22::restartTransmit() |
charly | 0:79c6d0071c4c | 688 | { |
charly | 0:79c6d0071c4c | 689 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 690 | _txBufSentIndex = 0; |
charly | 0:79c6d0071c4c | 691 | // Serial.println("Restart"); |
charly | 0:79c6d0071c4c | 692 | startTransmit(); |
charly | 0:79c6d0071c4c | 693 | } |
charly | 0:79c6d0071c4c | 694 | |
charly | 5:0386600f3408 | 695 | boolean RF22::send(const uint8_t* data, uint8_t len) |
charly | 0:79c6d0071c4c | 696 | { |
charly | 5:0386600f3408 | 697 | waitPacketSent(); |
charly | 5:0386600f3408 | 698 | // ATOMIC_BLOCK(ATOMIC_RESTORESTATE) |
charly | 5:0386600f3408 | 699 | { |
charly | 8:d9e2ca137f2e | 700 | if (!fillTxBuf(data, len)) |
charly | 8:d9e2ca137f2e | 701 | return false; |
charly | 8:d9e2ca137f2e | 702 | startTransmit(); |
charly | 5:0386600f3408 | 703 | } |
charly | 5:0386600f3408 | 704 | // printBuffer("send:", data, len); |
charly | 0:79c6d0071c4c | 705 | return true; |
charly | 0:79c6d0071c4c | 706 | } |
charly | 0:79c6d0071c4c | 707 | |
charly | 5:0386600f3408 | 708 | boolean RF22::fillTxBuf(const uint8_t* data, uint8_t len) |
charly | 0:79c6d0071c4c | 709 | { |
charly | 0:79c6d0071c4c | 710 | clearTxBuf(); |
charly | 5:0386600f3408 | 711 | if (!len) |
charly | 8:d9e2ca137f2e | 712 | return false; |
charly | 0:79c6d0071c4c | 713 | return appendTxBuf(data, len); |
charly | 0:79c6d0071c4c | 714 | } |
charly | 0:79c6d0071c4c | 715 | |
charly | 5:0386600f3408 | 716 | boolean RF22::appendTxBuf(const uint8_t* data, uint8_t len) |
charly | 0:79c6d0071c4c | 717 | { |
charly | 0:79c6d0071c4c | 718 | if (((uint16_t)_bufLen + len) > RF22_MAX_MESSAGE_LEN) |
charly | 8:d9e2ca137f2e | 719 | return false; |
charly | 8:d9e2ca137f2e | 720 | __disable_irq(); // Disable Interrupts |
charly | 0:79c6d0071c4c | 721 | memcpy(_buf + _bufLen, data, len); |
charly | 0:79c6d0071c4c | 722 | _bufLen += len; |
charly | 8:d9e2ca137f2e | 723 | __enable_irq(); // Enable Interrupts |
charly | 8:d9e2ca137f2e | 724 | |
charly | 5:0386600f3408 | 725 | // printBuffer("txbuf:", _buf, _bufLen); |
charly | 0:79c6d0071c4c | 726 | return true; |
charly | 0:79c6d0071c4c | 727 | } |
charly | 0:79c6d0071c4c | 728 | |
charly | 0:79c6d0071c4c | 729 | // Assumption: there is currently <= RF22_TXFFAEM_THRESHOLD bytes in the Tx FIFO |
charly | 0:79c6d0071c4c | 730 | void RF22::sendNextFragment() |
charly | 0:79c6d0071c4c | 731 | { |
charly | 8:d9e2ca137f2e | 732 | if (_txBufSentIndex < _bufLen) { |
charly | 8:d9e2ca137f2e | 733 | // Some left to send? |
charly | 8:d9e2ca137f2e | 734 | uint8_t len = _bufLen - _txBufSentIndex; |
charly | 8:d9e2ca137f2e | 735 | // But dont send too much |
charly | 8:d9e2ca137f2e | 736 | if (len > (RF22_FIFO_SIZE - RF22_TXFFAEM_THRESHOLD - 1)) |
charly | 8:d9e2ca137f2e | 737 | len = (RF22_FIFO_SIZE - RF22_TXFFAEM_THRESHOLD - 1); |
charly | 8:d9e2ca137f2e | 738 | spiBurstWrite(RF22_REG_7F_FIFO_ACCESS, _buf + _txBufSentIndex, len); |
charly | 8:d9e2ca137f2e | 739 | _txBufSentIndex += len; |
charly | 0:79c6d0071c4c | 740 | } |
charly | 0:79c6d0071c4c | 741 | } |
charly | 0:79c6d0071c4c | 742 | |
charly | 0:79c6d0071c4c | 743 | // Assumption: there are at least RF22_RXFFAFULL_THRESHOLD in the RX FIFO |
charly | 5:0386600f3408 | 744 | // That means it should only be called after a RXFFAFULL interrupt |
charly | 0:79c6d0071c4c | 745 | void RF22::readNextFragment() |
charly | 0:79c6d0071c4c | 746 | { |
charly | 0:79c6d0071c4c | 747 | if (((uint16_t)_bufLen + RF22_RXFFAFULL_THRESHOLD) > RF22_MAX_MESSAGE_LEN) |
charly | 8:d9e2ca137f2e | 748 | return; // Hmmm receiver overflow. Should never occur |
charly | 5:0386600f3408 | 749 | |
charly | 0:79c6d0071c4c | 750 | // Read the RF22_RXFFAFULL_THRESHOLD octets that should be there |
charly | 0:79c6d0071c4c | 751 | spiBurstRead(RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, RF22_RXFFAFULL_THRESHOLD); |
charly | 0:79c6d0071c4c | 752 | _bufLen += RF22_RXFFAFULL_THRESHOLD; |
charly | 0:79c6d0071c4c | 753 | } |
charly | 0:79c6d0071c4c | 754 | |
charly | 0:79c6d0071c4c | 755 | // Clear the FIFOs |
charly | 0:79c6d0071c4c | 756 | void RF22::resetFifos() |
charly | 0:79c6d0071c4c | 757 | { |
charly | 0:79c6d0071c4c | 758 | spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRRX | RF22_FFCLRTX); |
charly | 0:79c6d0071c4c | 759 | spiWrite(RF22_REG_08_OPERATING_MODE2, 0); |
charly | 0:79c6d0071c4c | 760 | } |
charly | 0:79c6d0071c4c | 761 | |
charly | 0:79c6d0071c4c | 762 | // Clear the Rx FIFO |
charly | 0:79c6d0071c4c | 763 | void RF22::resetRxFifo() |
charly | 0:79c6d0071c4c | 764 | { |
charly | 0:79c6d0071c4c | 765 | spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRRX); |
charly | 0:79c6d0071c4c | 766 | spiWrite(RF22_REG_08_OPERATING_MODE2, 0); |
charly | 0:79c6d0071c4c | 767 | } |
charly | 0:79c6d0071c4c | 768 | |
charly | 0:79c6d0071c4c | 769 | // CLear the TX FIFO |
charly | 0:79c6d0071c4c | 770 | void RF22::resetTxFifo() |
charly | 0:79c6d0071c4c | 771 | { |
charly | 0:79c6d0071c4c | 772 | spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRTX); |
charly | 0:79c6d0071c4c | 773 | spiWrite(RF22_REG_08_OPERATING_MODE2, 0); |
charly | 0:79c6d0071c4c | 774 | } |
charly | 0:79c6d0071c4c | 775 | |
charly | 0:79c6d0071c4c | 776 | // Default implmentation does nothing. Override if you wish |
charly | 0:79c6d0071c4c | 777 | void RF22::handleExternalInterrupt() |
charly | 0:79c6d0071c4c | 778 | { |
charly | 0:79c6d0071c4c | 779 | } |
charly | 0:79c6d0071c4c | 780 | |
charly | 0:79c6d0071c4c | 781 | // Default implmentation does nothing. Override if you wish |
charly | 0:79c6d0071c4c | 782 | void RF22::handleWakeupTimerInterrupt() |
charly | 0:79c6d0071c4c | 783 | { |
charly | 0:79c6d0071c4c | 784 | } |
charly | 0:79c6d0071c4c | 785 | |
charly | 0:79c6d0071c4c | 786 | void RF22::setHeaderTo(uint8_t to) |
charly | 0:79c6d0071c4c | 787 | { |
charly | 0:79c6d0071c4c | 788 | spiWrite(RF22_REG_3A_TRANSMIT_HEADER3, to); |
charly | 0:79c6d0071c4c | 789 | } |
charly | 0:79c6d0071c4c | 790 | |
charly | 0:79c6d0071c4c | 791 | void RF22::setHeaderFrom(uint8_t from) |
charly | 0:79c6d0071c4c | 792 | { |
charly | 0:79c6d0071c4c | 793 | spiWrite(RF22_REG_3B_TRANSMIT_HEADER2, from); |
charly | 0:79c6d0071c4c | 794 | } |
charly | 0:79c6d0071c4c | 795 | |
charly | 0:79c6d0071c4c | 796 | void RF22::setHeaderId(uint8_t id) |
charly | 0:79c6d0071c4c | 797 | { |
charly | 0:79c6d0071c4c | 798 | spiWrite(RF22_REG_3C_TRANSMIT_HEADER1, id); |
charly | 0:79c6d0071c4c | 799 | } |
charly | 0:79c6d0071c4c | 800 | |
charly | 0:79c6d0071c4c | 801 | void RF22::setHeaderFlags(uint8_t flags) |
charly | 0:79c6d0071c4c | 802 | { |
charly | 0:79c6d0071c4c | 803 | spiWrite(RF22_REG_3D_TRANSMIT_HEADER0, flags); |
charly | 0:79c6d0071c4c | 804 | } |
charly | 0:79c6d0071c4c | 805 | |
charly | 0:79c6d0071c4c | 806 | uint8_t RF22::headerTo() |
charly | 0:79c6d0071c4c | 807 | { |
charly | 0:79c6d0071c4c | 808 | return spiRead(RF22_REG_47_RECEIVED_HEADER3); |
charly | 0:79c6d0071c4c | 809 | } |
charly | 0:79c6d0071c4c | 810 | |
charly | 0:79c6d0071c4c | 811 | uint8_t RF22::headerFrom() |
charly | 0:79c6d0071c4c | 812 | { |
charly | 0:79c6d0071c4c | 813 | return spiRead(RF22_REG_48_RECEIVED_HEADER2); |
charly | 0:79c6d0071c4c | 814 | } |
charly | 0:79c6d0071c4c | 815 | |
charly | 0:79c6d0071c4c | 816 | uint8_t RF22::headerId() |
charly | 0:79c6d0071c4c | 817 | { |
charly | 0:79c6d0071c4c | 818 | return spiRead(RF22_REG_49_RECEIVED_HEADER1); |
charly | 0:79c6d0071c4c | 819 | } |
charly | 0:79c6d0071c4c | 820 | |
charly | 0:79c6d0071c4c | 821 | uint8_t RF22::headerFlags() |
charly | 0:79c6d0071c4c | 822 | { |
charly | 0:79c6d0071c4c | 823 | return spiRead(RF22_REG_4A_RECEIVED_HEADER0); |
charly | 0:79c6d0071c4c | 824 | } |
charly | 0:79c6d0071c4c | 825 | |
charly | 0:79c6d0071c4c | 826 | uint8_t RF22::lastRssi() |
charly | 0:79c6d0071c4c | 827 | { |
charly | 0:79c6d0071c4c | 828 | return _lastRssi; |
charly | 0:79c6d0071c4c | 829 | } |
charly | 0:79c6d0071c4c | 830 | |
charly | 0:79c6d0071c4c | 831 | void RF22::setPromiscuous(boolean promiscuous) |
charly | 0:79c6d0071c4c | 832 | { |
charly | 0:79c6d0071c4c | 833 | spiWrite(RF22_REG_43_HEADER_ENABLE3, promiscuous ? 0x00 : 0xff); |
charly | 0:79c6d0071c4c | 834 | } |