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@0:79c6d0071c4c, 2012-02-14 (annotated)
- Committer:
- charly
- Date:
- Tue Feb 14 19:39:36 2012 +0000
- Revision:
- 0:79c6d0071c4c
- Child:
- 2:f6f42c2ba9f2
Initial Port - Quick and Dirty !!!
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 | 0:79c6d0071c4c | 4 | // $Id: RF22.cpp,v 1.13 2011/10/09 21:22:24 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 | 0:79c6d0071c4c | 19 | // Canned modem configurations generated with |
charly | 0:79c6d0071c4c | 20 | // 'http://www.hoperf.com/upfile/RF22B 23B 31B 42B 43B Register Settings_RevB1-v5.xls' |
charly | 0:79c6d0071c4c | 21 | // Stored in flash (program) memory to save SRAM |
charly | 0:79c6d0071c4c | 22 | /*PROGMEM */ static const RF22::ModemConfig MODEM_CONFIG_TABLE[] = |
charly | 0:79c6d0071c4c | 23 | { |
charly | 0:79c6d0071c4c | 24 | { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x00, 0x08 }, // Unmodulated carrier |
charly | 0:79c6d0071c4c | 25 | { 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 | 26 | |
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 | 0:79c6d0071c4c | 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 | 0:79c6d0071c4c | 70 | |
charly | 0:79c6d0071c4c | 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 | 0:79c6d0071c4c | 84 | |
charly | 0:79c6d0071c4c | 85 | wait_ms(100); |
charly | 0:79c6d0071c4c | 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 | 0:79c6d0071c4c | 107 | && _deviceType != RF22_DEVICE_TYPE_TX) |
charly | 0:79c6d0071c4c | 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 | 0:79c6d0071c4c | 114 | //attachInterrupt(0, RF22::isr0, LOW); |
charly | 0:79c6d0071c4c | 115 | _interrupt.fall(this, &RF22::isr0); |
charly | 0:79c6d0071c4c | 116 | /* } |
charly | 0:79c6d0071c4c | 117 | else if (_interrupt == 1) |
charly | 0:79c6d0071c4c | 118 | { |
charly | 0:79c6d0071c4c | 119 | _RF22ForInterrupt[1] = this; |
charly | 0:79c6d0071c4c | 120 | attachInterrupt(1, RF22::isr1, LOW); |
charly | 0:79c6d0071c4c | 121 | } |
charly | 0:79c6d0071c4c | 122 | else |
charly | 0:79c6d0071c4c | 123 | return false; |
charly | 0:79c6d0071c4c | 124 | */ |
charly | 0:79c6d0071c4c | 125 | clearTxBuf(); |
charly | 0:79c6d0071c4c | 126 | clearRxBuf(); |
charly | 0:79c6d0071c4c | 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 | 0:79c6d0071c4c | 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 | 0:79c6d0071c4c | 167 | spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM | RF22_ENRXFFAFULL | RF22_ENPKSENT | RF22_ENPKVALID | RF22_ENCRCERROR | RF22_ENFFERR); |
charly | 0:79c6d0071c4c | 168 | spiWrite(RF22_REG_06_INTERRUPT_ENABLE2, RF22_ENPREAVAL); |
charly | 0:79c6d0071c4c | 169 | |
charly | 0:79c6d0071c4c | 170 | // Set some defaults. An innocuous ISM frequency |
charly | 0:79c6d0071c4c | 171 | setFrequency(868.0); |
charly | 0:79c6d0071c4c | 172 | // setFrequency(434.0); |
charly | 0:79c6d0071c4c | 173 | // setFrequency(900.0); |
charly | 0:79c6d0071c4c | 174 | // Some slow, reliable default speed and modulation |
charly | 0:79c6d0071c4c | 175 | setModemConfig(FSK_Rb2_4Fd36); |
charly | 0:79c6d0071c4c | 176 | // setModemConfig(FSK_Rb125Fd125); |
charly | 0:79c6d0071c4c | 177 | // Minimum power |
charly | 0:79c6d0071c4c | 178 | setTxPower(RF22_TXPOW_8DBM); |
charly | 0:79c6d0071c4c | 179 | // setTxPower(RF22_TXPOW_17DBM); |
charly | 0:79c6d0071c4c | 180 | |
charly | 0:79c6d0071c4c | 181 | return true; |
charly | 0:79c6d0071c4c | 182 | } |
charly | 0:79c6d0071c4c | 183 | |
charly | 0:79c6d0071c4c | 184 | // C++ level interrupt handler for this instance |
charly | 0:79c6d0071c4c | 185 | void RF22::handleInterrupt() |
charly | 0:79c6d0071c4c | 186 | { |
charly | 0:79c6d0071c4c | 187 | uint8_t _lastInterruptFlags[2]; |
charly | 0:79c6d0071c4c | 188 | |
charly | 0:79c6d0071c4c | 189 | led1 = !led1; |
charly | 0:79c6d0071c4c | 190 | |
charly | 0:79c6d0071c4c | 191 | // Read the interrupt flags which clears the interrupt |
charly | 0:79c6d0071c4c | 192 | spiBurstRead(RF22_REG_03_INTERRUPT_STATUS1, _lastInterruptFlags, 2); |
charly | 0:79c6d0071c4c | 193 | |
charly | 0:79c6d0071c4c | 194 | #if 0 |
charly | 0:79c6d0071c4c | 195 | pc.print("interrupt "); |
charly | 0:79c6d0071c4c | 196 | Serial.print(_lastInterruptFlags[0], HEX); |
charly | 0:79c6d0071c4c | 197 | Serial.print(" "); |
charly | 0:79c6d0071c4c | 198 | Serial.println(_lastInterruptFlags[1], HEX); |
charly | 0:79c6d0071c4c | 199 | if (_lastInterruptFlags[0] == 0 && _lastInterruptFlags[1] == 0) |
charly | 0:79c6d0071c4c | 200 | Serial.println("FUNNY: no interrupt!"); |
charly | 0:79c6d0071c4c | 201 | #endif |
charly | 0:79c6d0071c4c | 202 | |
charly | 0:79c6d0071c4c | 203 | /* |
charly | 0:79c6d0071c4c | 204 | // TESTING: fake an RF22_IFFERROR |
charly | 0:79c6d0071c4c | 205 | static int counter = 0; |
charly | 0:79c6d0071c4c | 206 | if (_lastInterruptFlags[0] & RF22_IPKSENT && counter++ == 10) |
charly | 0:79c6d0071c4c | 207 | { |
charly | 0:79c6d0071c4c | 208 | _lastInterruptFlags[0] = RF22_IFFERROR; |
charly | 0:79c6d0071c4c | 209 | counter = 0; |
charly | 0:79c6d0071c4c | 210 | } |
charly | 0:79c6d0071c4c | 211 | */ |
charly | 0:79c6d0071c4c | 212 | |
charly | 0:79c6d0071c4c | 213 | if (_lastInterruptFlags[0] & RF22_IFFERROR) |
charly | 0:79c6d0071c4c | 214 | { |
charly | 0:79c6d0071c4c | 215 | // Serial.println("IFFERROR"); |
charly | 0:79c6d0071c4c | 216 | resetFifos(); // Clears the interrupt |
charly | 0:79c6d0071c4c | 217 | if (_mode == RF22_MODE_TX) |
charly | 0:79c6d0071c4c | 218 | restartTransmit(); |
charly | 0:79c6d0071c4c | 219 | else if (_mode == RF22_MODE_RX) |
charly | 0:79c6d0071c4c | 220 | clearRxBuf(); |
charly | 0:79c6d0071c4c | 221 | } |
charly | 0:79c6d0071c4c | 222 | // Caution, any delay here may cause a FF underflow or overflow |
charly | 0:79c6d0071c4c | 223 | if (_lastInterruptFlags[0] & RF22_ITXFFAEM) |
charly | 0:79c6d0071c4c | 224 | { |
charly | 0:79c6d0071c4c | 225 | // See if more data has to be loaded into the Tx FIFO |
charly | 0:79c6d0071c4c | 226 | sendNextFragment(); |
charly | 0:79c6d0071c4c | 227 | // Serial.println("TXFFAEM"); |
charly | 0:79c6d0071c4c | 228 | } |
charly | 0:79c6d0071c4c | 229 | if (_lastInterruptFlags[0] & RF22_IRXFFAFULL) |
charly | 0:79c6d0071c4c | 230 | { |
charly | 0:79c6d0071c4c | 231 | // Caution, any delay here may cause a FF overflow |
charly | 0:79c6d0071c4c | 232 | // Read some data from the Rx FIFO |
charly | 0:79c6d0071c4c | 233 | readNextFragment(); |
charly | 0:79c6d0071c4c | 234 | // Serial.println("IRXFFAFULL"); |
charly | 0:79c6d0071c4c | 235 | } |
charly | 0:79c6d0071c4c | 236 | if (_lastInterruptFlags[0] & RF22_IEXT) |
charly | 0:79c6d0071c4c | 237 | { |
charly | 0:79c6d0071c4c | 238 | // This is not enabled by the base code, but users may want to enable it |
charly | 0:79c6d0071c4c | 239 | handleExternalInterrupt(); |
charly | 0:79c6d0071c4c | 240 | // Serial.println("IEXT"); |
charly | 0:79c6d0071c4c | 241 | } |
charly | 0:79c6d0071c4c | 242 | if (_lastInterruptFlags[1] & RF22_IWUT) |
charly | 0:79c6d0071c4c | 243 | { |
charly | 0:79c6d0071c4c | 244 | // This is not enabled by the base code, but users may want to enable it |
charly | 0:79c6d0071c4c | 245 | handleWakeupTimerInterrupt(); |
charly | 0:79c6d0071c4c | 246 | // Serial.println("IWUT"); |
charly | 0:79c6d0071c4c | 247 | } |
charly | 0:79c6d0071c4c | 248 | if (_lastInterruptFlags[0] & RF22_IPKSENT) |
charly | 0:79c6d0071c4c | 249 | { |
charly | 0:79c6d0071c4c | 250 | // Serial.println("PKSENT"); |
charly | 0:79c6d0071c4c | 251 | _txGood++; |
charly | 0:79c6d0071c4c | 252 | led4 = !led4; |
charly | 0:79c6d0071c4c | 253 | // Transmission does not automatically clear the tx buffer. |
charly | 0:79c6d0071c4c | 254 | // Could retransmit if we wanted |
charly | 0:79c6d0071c4c | 255 | _txPacketSent = true; |
charly | 0:79c6d0071c4c | 256 | // RF22 transitions automatically to Idle |
charly | 0:79c6d0071c4c | 257 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 258 | } |
charly | 0:79c6d0071c4c | 259 | if (_lastInterruptFlags[0] & RF22_IPKVALID) |
charly | 0:79c6d0071c4c | 260 | { |
charly | 0:79c6d0071c4c | 261 | // Serial.println("IPKVALID"); |
charly | 0:79c6d0071c4c | 262 | uint8_t len = spiRead(RF22_REG_4B_RECEIVED_PACKET_LENGTH); |
charly | 0:79c6d0071c4c | 263 | // May have already read one or more fragments |
charly | 0:79c6d0071c4c | 264 | // Get any remaining unread octets, based on the expected length |
charly | 0:79c6d0071c4c | 265 | len -= _bufLen; |
charly | 0:79c6d0071c4c | 266 | spiBurstRead(RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, len); |
charly | 0:79c6d0071c4c | 267 | _rxGood++; |
charly | 0:79c6d0071c4c | 268 | led3 = !led3; |
charly | 0:79c6d0071c4c | 269 | _bufLen += len; |
charly | 0:79c6d0071c4c | 270 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 271 | _rxBufValid = true; |
charly | 0:79c6d0071c4c | 272 | } |
charly | 0:79c6d0071c4c | 273 | if (_lastInterruptFlags[0] & RF22_ICRCERROR) |
charly | 0:79c6d0071c4c | 274 | { |
charly | 0:79c6d0071c4c | 275 | // Serial.println("ICRCERR"); |
charly | 0:79c6d0071c4c | 276 | _rxBad++; |
charly | 0:79c6d0071c4c | 277 | led2 = !led2; |
charly | 0:79c6d0071c4c | 278 | clearRxBuf(); |
charly | 0:79c6d0071c4c | 279 | resetRxFifo(); |
charly | 0:79c6d0071c4c | 280 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 281 | setModeRx(); // Keep trying |
charly | 0:79c6d0071c4c | 282 | } |
charly | 0:79c6d0071c4c | 283 | if (_lastInterruptFlags[1] & RF22_ENPREAVAL) |
charly | 0:79c6d0071c4c | 284 | { |
charly | 0:79c6d0071c4c | 285 | // Serial.println("ENPREAVAL"); |
charly | 0:79c6d0071c4c | 286 | _lastRssi = spiRead(RF22_REG_26_RSSI); |
charly | 0:79c6d0071c4c | 287 | clearRxBuf(); |
charly | 0:79c6d0071c4c | 288 | } |
charly | 0:79c6d0071c4c | 289 | } |
charly | 0:79c6d0071c4c | 290 | |
charly | 0:79c6d0071c4c | 291 | // These are low level functions that call the interrupt handler for the correct |
charly | 0:79c6d0071c4c | 292 | // instance of RF22. |
charly | 0:79c6d0071c4c | 293 | // 2 interrupts allows us to have 2 different devices |
charly | 0:79c6d0071c4c | 294 | void RF22::isr0() |
charly | 0:79c6d0071c4c | 295 | { |
charly | 0:79c6d0071c4c | 296 | //if (_RF22ForInterrupt[0]) |
charly | 0:79c6d0071c4c | 297 | //_RF22ForInterrupt[0]->handleInterrupt(); |
charly | 0:79c6d0071c4c | 298 | handleInterrupt(); |
charly | 0:79c6d0071c4c | 299 | } |
charly | 0:79c6d0071c4c | 300 | /* |
charly | 0:79c6d0071c4c | 301 | void RF22::isr1() |
charly | 0:79c6d0071c4c | 302 | { |
charly | 0:79c6d0071c4c | 303 | if (_RF22ForInterrupt[1]) |
charly | 0:79c6d0071c4c | 304 | _RF22ForInterrupt[1]->handleInterrupt(); |
charly | 0:79c6d0071c4c | 305 | } |
charly | 0:79c6d0071c4c | 306 | */ |
charly | 0:79c6d0071c4c | 307 | void RF22::reset() |
charly | 0:79c6d0071c4c | 308 | { |
charly | 0:79c6d0071c4c | 309 | spiWrite(RF22_REG_07_OPERATING_MODE1, RF22_SWRES); |
charly | 0:79c6d0071c4c | 310 | // Wait for it to settle |
charly | 0:79c6d0071c4c | 311 | //delay(1); // SWReset time is nominally 100usec |
charly | 0:79c6d0071c4c | 312 | wait_ms(1); |
charly | 0:79c6d0071c4c | 313 | } |
charly | 0:79c6d0071c4c | 314 | |
charly | 0:79c6d0071c4c | 315 | uint8_t RF22::spiRead(uint8_t reg) |
charly | 0:79c6d0071c4c | 316 | { |
charly | 0:79c6d0071c4c | 317 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 318 | _slaveSelectPin=0; |
charly | 0:79c6d0071c4c | 319 | //_spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the address with the write mask off |
charly | 0:79c6d0071c4c | 320 | _spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the address with the write mask off |
charly | 0:79c6d0071c4c | 321 | uint8_t val = _spi.write(0); // The written value is ignored, reg value is read |
charly | 0:79c6d0071c4c | 322 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 323 | _slaveSelectPin = 1; |
charly | 0:79c6d0071c4c | 324 | return val; |
charly | 0:79c6d0071c4c | 325 | } |
charly | 0:79c6d0071c4c | 326 | |
charly | 0:79c6d0071c4c | 327 | void RF22::spiWrite(uint8_t reg, uint8_t val) |
charly | 0:79c6d0071c4c | 328 | { |
charly | 0:79c6d0071c4c | 329 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 330 | _slaveSelectPin = 0; |
charly | 0:79c6d0071c4c | 331 | _spi.write(reg | RF22_SPI_WRITE_MASK); // Send the address with the write mask on |
charly | 0:79c6d0071c4c | 332 | _spi.write(val); // New value follows |
charly | 0:79c6d0071c4c | 333 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 334 | _slaveSelectPin = 1; |
charly | 0:79c6d0071c4c | 335 | } |
charly | 0:79c6d0071c4c | 336 | |
charly | 0:79c6d0071c4c | 337 | void RF22::spiBurstRead(uint8_t reg, uint8_t* dest, uint8_t len) |
charly | 0:79c6d0071c4c | 338 | { |
charly | 0:79c6d0071c4c | 339 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 340 | _slaveSelectPin = 0; |
charly | 0:79c6d0071c4c | 341 | _spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the start address with the write mask off |
charly | 0:79c6d0071c4c | 342 | while (len--) |
charly | 0:79c6d0071c4c | 343 | *dest++ = _spi.write(0); |
charly | 0:79c6d0071c4c | 344 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 345 | _slaveSelectPin = 1; |
charly | 0:79c6d0071c4c | 346 | } |
charly | 0:79c6d0071c4c | 347 | |
charly | 0:79c6d0071c4c | 348 | void RF22::spiBurstWrite(uint8_t reg, uint8_t* src, uint8_t len) |
charly | 0:79c6d0071c4c | 349 | { |
charly | 0:79c6d0071c4c | 350 | //digitalWrite(_slaveSelectPin, LOW); |
charly | 0:79c6d0071c4c | 351 | _slaveSelectPin = 0; |
charly | 0:79c6d0071c4c | 352 | _spi.write(reg | RF22_SPI_WRITE_MASK); // Send the start address with the write mask on |
charly | 0:79c6d0071c4c | 353 | while (len--) |
charly | 0:79c6d0071c4c | 354 | _spi.write(*src++); |
charly | 0:79c6d0071c4c | 355 | //digitalWrite(_slaveSelectPin, HIGH); |
charly | 0:79c6d0071c4c | 356 | _slaveSelectPin = 1; |
charly | 0:79c6d0071c4c | 357 | } |
charly | 0:79c6d0071c4c | 358 | |
charly | 0:79c6d0071c4c | 359 | uint8_t RF22::statusRead() |
charly | 0:79c6d0071c4c | 360 | { |
charly | 0:79c6d0071c4c | 361 | return spiRead(RF22_REG_02_DEVICE_STATUS); |
charly | 0:79c6d0071c4c | 362 | } |
charly | 0:79c6d0071c4c | 363 | |
charly | 0:79c6d0071c4c | 364 | uint8_t RF22::adcRead(uint8_t adcsel, |
charly | 0:79c6d0071c4c | 365 | uint8_t adcref , |
charly | 0:79c6d0071c4c | 366 | uint8_t adcgain, |
charly | 0:79c6d0071c4c | 367 | uint8_t adcoffs) |
charly | 0:79c6d0071c4c | 368 | { |
charly | 0:79c6d0071c4c | 369 | uint8_t configuration = adcsel | adcref | (adcgain & RF22_ADCGAIN); |
charly | 0:79c6d0071c4c | 370 | spiWrite(RF22_REG_0F_ADC_CONFIGURATION, configuration | RF22_ADCSTART); |
charly | 0:79c6d0071c4c | 371 | spiWrite(RF22_REG_10_ADC_SENSOR_AMP_OFFSET, adcoffs); |
charly | 0:79c6d0071c4c | 372 | |
charly | 0:79c6d0071c4c | 373 | // Conversion time is nominally 305usec |
charly | 0:79c6d0071c4c | 374 | // Wait for the DONE bit |
charly | 0:79c6d0071c4c | 375 | while (!(spiRead(RF22_REG_0F_ADC_CONFIGURATION) & RF22_ADCDONE)) |
charly | 0:79c6d0071c4c | 376 | ; |
charly | 0:79c6d0071c4c | 377 | // Return the value |
charly | 0:79c6d0071c4c | 378 | return spiRead(RF22_REG_11_ADC_VALUE); |
charly | 0:79c6d0071c4c | 379 | } |
charly | 0:79c6d0071c4c | 380 | |
charly | 0:79c6d0071c4c | 381 | uint8_t RF22::temperatureRead(uint8_t tsrange, uint8_t tvoffs) |
charly | 0:79c6d0071c4c | 382 | { |
charly | 0:79c6d0071c4c | 383 | spiWrite(RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION, tsrange | RF22_ENTSOFFS); |
charly | 0:79c6d0071c4c | 384 | spiWrite(RF22_REG_13_TEMPERATURE_VALUE_OFFSET, tvoffs); |
charly | 0:79c6d0071c4c | 385 | return adcRead(RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR | RF22_ADCREF_BANDGAP_VOLTAGE); |
charly | 0:79c6d0071c4c | 386 | } |
charly | 0:79c6d0071c4c | 387 | |
charly | 0:79c6d0071c4c | 388 | uint16_t RF22::wutRead() |
charly | 0:79c6d0071c4c | 389 | { |
charly | 0:79c6d0071c4c | 390 | uint8_t buf[2]; |
charly | 0:79c6d0071c4c | 391 | spiBurstRead(RF22_REG_17_WAKEUP_TIMER_VALUE1, buf, 2); |
charly | 0:79c6d0071c4c | 392 | return ((uint16_t)buf[0] << 8) | buf[1]; // Dont rely on byte order |
charly | 0:79c6d0071c4c | 393 | } |
charly | 0:79c6d0071c4c | 394 | |
charly | 0:79c6d0071c4c | 395 | // RFM-22 doc appears to be wrong: WUT for wtm = 10000, r, = 0, d = 0 is about 1 sec |
charly | 0:79c6d0071c4c | 396 | void RF22::setWutPeriod(uint16_t wtm, uint8_t wtr, uint8_t wtd) |
charly | 0:79c6d0071c4c | 397 | { |
charly | 0:79c6d0071c4c | 398 | uint8_t period[3]; |
charly | 0:79c6d0071c4c | 399 | |
charly | 0:79c6d0071c4c | 400 | period[0] = ((wtr & 0xf) << 2) | (wtd & 0x3); |
charly | 0:79c6d0071c4c | 401 | period[1] = wtm >> 8; |
charly | 0:79c6d0071c4c | 402 | period[2] = wtm & 0xff; |
charly | 0:79c6d0071c4c | 403 | spiBurstWrite(RF22_REG_14_WAKEUP_TIMER_PERIOD1, period, sizeof(period)); |
charly | 0:79c6d0071c4c | 404 | } |
charly | 0:79c6d0071c4c | 405 | |
charly | 0:79c6d0071c4c | 406 | // Returns true if centre + (fhch * fhs) is within limits |
charly | 0:79c6d0071c4c | 407 | // Caution, different versions of the RF22 suport different max freq |
charly | 0:79c6d0071c4c | 408 | // so YMMV |
charly | 0:79c6d0071c4c | 409 | boolean RF22::setFrequency(float centre) |
charly | 0:79c6d0071c4c | 410 | { |
charly | 0:79c6d0071c4c | 411 | uint8_t fbsel = RF22_SBSEL; |
charly | 0:79c6d0071c4c | 412 | if (centre < 240.0 || centre > 960.0) // 930.0 for early silicon |
charly | 0:79c6d0071c4c | 413 | return false; |
charly | 0:79c6d0071c4c | 414 | if (centre >= 480.0) |
charly | 0:79c6d0071c4c | 415 | { |
charly | 0:79c6d0071c4c | 416 | centre /= 2; |
charly | 0:79c6d0071c4c | 417 | fbsel |= RF22_HBSEL; |
charly | 0:79c6d0071c4c | 418 | } |
charly | 0:79c6d0071c4c | 419 | centre /= 10.0; |
charly | 0:79c6d0071c4c | 420 | float integerPart = floor(centre); |
charly | 0:79c6d0071c4c | 421 | float fractionalPart = centre - integerPart; |
charly | 0:79c6d0071c4c | 422 | |
charly | 0:79c6d0071c4c | 423 | uint8_t fb = (uint8_t)integerPart - 24; // Range 0 to 23 |
charly | 0:79c6d0071c4c | 424 | fbsel |= fb; |
charly | 0:79c6d0071c4c | 425 | uint16_t fc = fractionalPart * 64000; |
charly | 0:79c6d0071c4c | 426 | spiWrite(RF22_REG_73_FREQUENCY_OFFSET1, 0); // REVISIT |
charly | 0:79c6d0071c4c | 427 | spiWrite(RF22_REG_74_FREQUENCY_OFFSET2, 0); |
charly | 0:79c6d0071c4c | 428 | spiWrite(RF22_REG_75_FREQUENCY_BAND_SELECT, fbsel); |
charly | 0:79c6d0071c4c | 429 | spiWrite(RF22_REG_76_NOMINAL_CARRIER_FREQUENCY1, fc >> 8); |
charly | 0:79c6d0071c4c | 430 | spiWrite(RF22_REG_77_NOMINAL_CARRIER_FREQUENCY0, fc & 0xff); |
charly | 0:79c6d0071c4c | 431 | return !(statusRead() & RF22_FREQERR); |
charly | 0:79c6d0071c4c | 432 | } |
charly | 0:79c6d0071c4c | 433 | |
charly | 0:79c6d0071c4c | 434 | // Step size in 10kHz increments |
charly | 0:79c6d0071c4c | 435 | // Returns true if centre + (fhch * fhs) is within limits |
charly | 0:79c6d0071c4c | 436 | boolean RF22::setFHStepSize(uint8_t fhs) |
charly | 0:79c6d0071c4c | 437 | { |
charly | 0:79c6d0071c4c | 438 | spiWrite(RF22_REG_7A_FREQUENCY_HOPPING_STEP_SIZE, fhs); |
charly | 0:79c6d0071c4c | 439 | return !(statusRead() & RF22_FREQERR); |
charly | 0:79c6d0071c4c | 440 | } |
charly | 0:79c6d0071c4c | 441 | |
charly | 0:79c6d0071c4c | 442 | // Adds fhch * fhs to centre frequency |
charly | 0:79c6d0071c4c | 443 | // Returns true if centre + (fhch * fhs) is within limits |
charly | 0:79c6d0071c4c | 444 | boolean RF22::setFHChannel(uint8_t fhch) |
charly | 0:79c6d0071c4c | 445 | { |
charly | 0:79c6d0071c4c | 446 | spiWrite(RF22_REG_79_FREQUENCY_HOPPING_CHANNEL_SELECT, fhch); |
charly | 0:79c6d0071c4c | 447 | return !(statusRead() & RF22_FREQERR); |
charly | 0:79c6d0071c4c | 448 | } |
charly | 0:79c6d0071c4c | 449 | |
charly | 0:79c6d0071c4c | 450 | uint8_t RF22::rssiRead() |
charly | 0:79c6d0071c4c | 451 | { |
charly | 0:79c6d0071c4c | 452 | return spiRead(RF22_REG_26_RSSI); |
charly | 0:79c6d0071c4c | 453 | } |
charly | 0:79c6d0071c4c | 454 | |
charly | 0:79c6d0071c4c | 455 | uint8_t RF22::ezmacStatusRead() |
charly | 0:79c6d0071c4c | 456 | { |
charly | 0:79c6d0071c4c | 457 | return spiRead(RF22_REG_31_EZMAC_STATUS); |
charly | 0:79c6d0071c4c | 458 | } |
charly | 0:79c6d0071c4c | 459 | |
charly | 0:79c6d0071c4c | 460 | void RF22::setMode(uint8_t mode) |
charly | 0:79c6d0071c4c | 461 | { |
charly | 0:79c6d0071c4c | 462 | spiWrite(RF22_REG_07_OPERATING_MODE1, mode); |
charly | 0:79c6d0071c4c | 463 | } |
charly | 0:79c6d0071c4c | 464 | |
charly | 0:79c6d0071c4c | 465 | void RF22::setModeIdle() |
charly | 0:79c6d0071c4c | 466 | { |
charly | 0:79c6d0071c4c | 467 | if (_mode != RF22_MODE_IDLE) |
charly | 0:79c6d0071c4c | 468 | { |
charly | 0:79c6d0071c4c | 469 | setMode(_idleMode); |
charly | 0:79c6d0071c4c | 470 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 471 | } |
charly | 0:79c6d0071c4c | 472 | } |
charly | 0:79c6d0071c4c | 473 | |
charly | 0:79c6d0071c4c | 474 | void RF22::setModeRx() |
charly | 0:79c6d0071c4c | 475 | { |
charly | 0:79c6d0071c4c | 476 | if (_mode != RF22_MODE_RX) |
charly | 0:79c6d0071c4c | 477 | { |
charly | 0:79c6d0071c4c | 478 | setMode(_idleMode | RF22_RXON); |
charly | 0:79c6d0071c4c | 479 | _mode = RF22_MODE_RX; |
charly | 0:79c6d0071c4c | 480 | } |
charly | 0:79c6d0071c4c | 481 | } |
charly | 0:79c6d0071c4c | 482 | |
charly | 0:79c6d0071c4c | 483 | void RF22::setModeTx() |
charly | 0:79c6d0071c4c | 484 | { |
charly | 0:79c6d0071c4c | 485 | if (_mode != RF22_MODE_TX) |
charly | 0:79c6d0071c4c | 486 | { |
charly | 0:79c6d0071c4c | 487 | setMode(_idleMode | RF22_TXON); |
charly | 0:79c6d0071c4c | 488 | _mode = RF22_MODE_TX; |
charly | 0:79c6d0071c4c | 489 | } |
charly | 0:79c6d0071c4c | 490 | } |
charly | 0:79c6d0071c4c | 491 | |
charly | 0:79c6d0071c4c | 492 | void RF22::setTxPower(uint8_t power) |
charly | 0:79c6d0071c4c | 493 | { |
charly | 0:79c6d0071c4c | 494 | spiWrite(RF22_REG_6D_TX_POWER, power); |
charly | 0:79c6d0071c4c | 495 | } |
charly | 0:79c6d0071c4c | 496 | |
charly | 0:79c6d0071c4c | 497 | // Sets registers from a canned modem configuration structure |
charly | 0:79c6d0071c4c | 498 | void RF22::setModemRegisters(ModemConfig* config) |
charly | 0:79c6d0071c4c | 499 | { |
charly | 0:79c6d0071c4c | 500 | spiWrite(RF22_REG_1C_IF_FILTER_BANDWIDTH, config->reg_1c); |
charly | 0:79c6d0071c4c | 501 | spiWrite(RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE, config->reg_1f); |
charly | 0:79c6d0071c4c | 502 | spiBurstWrite(RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE, &config->reg_20, 6); |
charly | 0:79c6d0071c4c | 503 | spiBurstWrite(RF22_REG_2C_OOK_COUNTER_VALUE_1, &config->reg_2c, 3); |
charly | 0:79c6d0071c4c | 504 | spiWrite(RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING, config->reg_58); |
charly | 0:79c6d0071c4c | 505 | spiWrite(RF22_REG_69_AGC_OVERRIDE1, config->reg_69); |
charly | 0:79c6d0071c4c | 506 | spiBurstWrite(RF22_REG_6E_TX_DATA_RATE1, &config->reg_6e, 5); |
charly | 0:79c6d0071c4c | 507 | } |
charly | 0:79c6d0071c4c | 508 | |
charly | 0:79c6d0071c4c | 509 | // Set one of the canned FSK Modem configs |
charly | 0:79c6d0071c4c | 510 | // Returns true if its a valid choice |
charly | 0:79c6d0071c4c | 511 | boolean RF22::setModemConfig(ModemConfigChoice index) |
charly | 0:79c6d0071c4c | 512 | { |
charly | 0:79c6d0071c4c | 513 | if (index > (sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig))) |
charly | 0:79c6d0071c4c | 514 | return false; |
charly | 0:79c6d0071c4c | 515 | |
charly | 0:79c6d0071c4c | 516 | RF22::ModemConfig cfg; |
charly | 0:79c6d0071c4c | 517 | memcpy(&cfg, &MODEM_CONFIG_TABLE[index], sizeof(RF22::ModemConfig)); |
charly | 0:79c6d0071c4c | 518 | setModemRegisters(&cfg); |
charly | 0:79c6d0071c4c | 519 | |
charly | 0:79c6d0071c4c | 520 | return true; |
charly | 0:79c6d0071c4c | 521 | } |
charly | 0:79c6d0071c4c | 522 | |
charly | 0:79c6d0071c4c | 523 | // REVISIT: top bit is in Header Control 2 0x33 |
charly | 0:79c6d0071c4c | 524 | void RF22::setPreambleLength(uint8_t nibbles) |
charly | 0:79c6d0071c4c | 525 | { |
charly | 0:79c6d0071c4c | 526 | spiWrite(RF22_REG_34_PREAMBLE_LENGTH, nibbles); |
charly | 0:79c6d0071c4c | 527 | } |
charly | 0:79c6d0071c4c | 528 | |
charly | 0:79c6d0071c4c | 529 | // Caution doesnt set sync word len in Header Control 2 0x33 |
charly | 0:79c6d0071c4c | 530 | void RF22::setSyncWords(uint8_t* syncWords, uint8_t len) |
charly | 0:79c6d0071c4c | 531 | { |
charly | 0:79c6d0071c4c | 532 | spiBurstWrite(RF22_REG_36_SYNC_WORD3, syncWords, len); |
charly | 0:79c6d0071c4c | 533 | } |
charly | 0:79c6d0071c4c | 534 | |
charly | 0:79c6d0071c4c | 535 | void RF22::clearRxBuf() |
charly | 0:79c6d0071c4c | 536 | { |
charly | 0:79c6d0071c4c | 537 | _bufLen = 0; |
charly | 0:79c6d0071c4c | 538 | _rxBufValid = false; |
charly | 0:79c6d0071c4c | 539 | } |
charly | 0:79c6d0071c4c | 540 | |
charly | 0:79c6d0071c4c | 541 | boolean RF22::available() |
charly | 0:79c6d0071c4c | 542 | { |
charly | 0:79c6d0071c4c | 543 | setModeRx(); |
charly | 0:79c6d0071c4c | 544 | return _rxBufValid; |
charly | 0:79c6d0071c4c | 545 | } |
charly | 0:79c6d0071c4c | 546 | |
charly | 0:79c6d0071c4c | 547 | // Blocks until a valid message is received |
charly | 0:79c6d0071c4c | 548 | void RF22::waitAvailable() |
charly | 0:79c6d0071c4c | 549 | { |
charly | 0:79c6d0071c4c | 550 | while (!available()) |
charly | 0:79c6d0071c4c | 551 | ; |
charly | 0:79c6d0071c4c | 552 | } |
charly | 0:79c6d0071c4c | 553 | |
charly | 0:79c6d0071c4c | 554 | // Blocks until a valid message is received or timeout expires |
charly | 0:79c6d0071c4c | 555 | // Return true if there is a message available |
charly | 0:79c6d0071c4c | 556 | bool RF22::waitAvailableTimeout(uint16_t timeout) |
charly | 0:79c6d0071c4c | 557 | { |
charly | 0:79c6d0071c4c | 558 | Timer t; |
charly | 0:79c6d0071c4c | 559 | t.start(); |
charly | 0:79c6d0071c4c | 560 | unsigned long endtime = t.read_ms() + timeout; |
charly | 0:79c6d0071c4c | 561 | while (t.read_ms() < endtime) |
charly | 0:79c6d0071c4c | 562 | if (available()) |
charly | 0:79c6d0071c4c | 563 | return true; |
charly | 0:79c6d0071c4c | 564 | return false; |
charly | 0:79c6d0071c4c | 565 | } |
charly | 0:79c6d0071c4c | 566 | |
charly | 0:79c6d0071c4c | 567 | void RF22::waitPacketSent() |
charly | 0:79c6d0071c4c | 568 | { |
charly | 0:79c6d0071c4c | 569 | while (!_txPacketSent) |
charly | 0:79c6d0071c4c | 570 | ; |
charly | 0:79c6d0071c4c | 571 | } |
charly | 0:79c6d0071c4c | 572 | |
charly | 0:79c6d0071c4c | 573 | boolean RF22::recv(uint8_t* buf, uint8_t* len) |
charly | 0:79c6d0071c4c | 574 | { |
charly | 0:79c6d0071c4c | 575 | if (!available()) |
charly | 0:79c6d0071c4c | 576 | return false; |
charly | 0:79c6d0071c4c | 577 | if (*len > _bufLen) |
charly | 0:79c6d0071c4c | 578 | *len = _bufLen; |
charly | 0:79c6d0071c4c | 579 | memcpy(buf, _buf, *len); |
charly | 0:79c6d0071c4c | 580 | clearRxBuf(); |
charly | 0:79c6d0071c4c | 581 | return true; |
charly | 0:79c6d0071c4c | 582 | } |
charly | 0:79c6d0071c4c | 583 | |
charly | 0:79c6d0071c4c | 584 | void RF22::clearTxBuf() |
charly | 0:79c6d0071c4c | 585 | { |
charly | 0:79c6d0071c4c | 586 | _bufLen = 0; |
charly | 0:79c6d0071c4c | 587 | _txBufSentIndex = 0; |
charly | 0:79c6d0071c4c | 588 | _txPacketSent = false; |
charly | 0:79c6d0071c4c | 589 | } |
charly | 0:79c6d0071c4c | 590 | |
charly | 0:79c6d0071c4c | 591 | void RF22::startTransmit() |
charly | 0:79c6d0071c4c | 592 | { |
charly | 0:79c6d0071c4c | 593 | sendNextFragment(); // Actually the first fragment |
charly | 0:79c6d0071c4c | 594 | spiWrite(RF22_REG_3E_PACKET_LENGTH, _bufLen); // Total length that will be sent |
charly | 0:79c6d0071c4c | 595 | setModeTx(); // Start the transmitter, turns off the receiver |
charly | 0:79c6d0071c4c | 596 | } |
charly | 0:79c6d0071c4c | 597 | |
charly | 0:79c6d0071c4c | 598 | // Restart the trasnmission of a packet that had a problem |
charly | 0:79c6d0071c4c | 599 | void RF22::restartTransmit() |
charly | 0:79c6d0071c4c | 600 | { |
charly | 0:79c6d0071c4c | 601 | _mode = RF22_MODE_IDLE; |
charly | 0:79c6d0071c4c | 602 | _txBufSentIndex = 0; |
charly | 0:79c6d0071c4c | 603 | _txPacketSent = false; |
charly | 0:79c6d0071c4c | 604 | // Serial.println("Restart"); |
charly | 0:79c6d0071c4c | 605 | startTransmit(); |
charly | 0:79c6d0071c4c | 606 | } |
charly | 0:79c6d0071c4c | 607 | |
charly | 0:79c6d0071c4c | 608 | boolean RF22::send(uint8_t* data, uint8_t len) |
charly | 0:79c6d0071c4c | 609 | { |
charly | 0:79c6d0071c4c | 610 | setModeIdle(); |
charly | 0:79c6d0071c4c | 611 | fillTxBuf(data, len); |
charly | 0:79c6d0071c4c | 612 | startTransmit(); |
charly | 0:79c6d0071c4c | 613 | return true; |
charly | 0:79c6d0071c4c | 614 | } |
charly | 0:79c6d0071c4c | 615 | |
charly | 0:79c6d0071c4c | 616 | boolean RF22::fillTxBuf(uint8_t* data, uint8_t len) |
charly | 0:79c6d0071c4c | 617 | { |
charly | 0:79c6d0071c4c | 618 | clearTxBuf(); |
charly | 0:79c6d0071c4c | 619 | return appendTxBuf(data, len); |
charly | 0:79c6d0071c4c | 620 | } |
charly | 0:79c6d0071c4c | 621 | |
charly | 0:79c6d0071c4c | 622 | boolean RF22::appendTxBuf(uint8_t* data, uint8_t len) |
charly | 0:79c6d0071c4c | 623 | { |
charly | 0:79c6d0071c4c | 624 | if (((uint16_t)_bufLen + len) > RF22_MAX_MESSAGE_LEN) |
charly | 0:79c6d0071c4c | 625 | return false; |
charly | 0:79c6d0071c4c | 626 | memcpy(_buf + _bufLen, data, len); |
charly | 0:79c6d0071c4c | 627 | _bufLen += len; |
charly | 0:79c6d0071c4c | 628 | return true; |
charly | 0:79c6d0071c4c | 629 | } |
charly | 0:79c6d0071c4c | 630 | |
charly | 0:79c6d0071c4c | 631 | // Assumption: there is currently <= RF22_TXFFAEM_THRESHOLD bytes in the Tx FIFO |
charly | 0:79c6d0071c4c | 632 | void RF22::sendNextFragment() |
charly | 0:79c6d0071c4c | 633 | { |
charly | 0:79c6d0071c4c | 634 | if (_txBufSentIndex < _bufLen) |
charly | 0:79c6d0071c4c | 635 | { |
charly | 0:79c6d0071c4c | 636 | // Some left to send |
charly | 0:79c6d0071c4c | 637 | uint8_t len = _bufLen - _txBufSentIndex; |
charly | 0:79c6d0071c4c | 638 | // But dont send too much |
charly | 0:79c6d0071c4c | 639 | if (len > (RF22_FIFO_SIZE - RF22_TXFFAEM_THRESHOLD - 1)) |
charly | 0:79c6d0071c4c | 640 | len = (RF22_FIFO_SIZE - RF22_TXFFAEM_THRESHOLD - 1); |
charly | 0:79c6d0071c4c | 641 | spiBurstWrite(RF22_REG_7F_FIFO_ACCESS, _buf + _txBufSentIndex, len); |
charly | 0:79c6d0071c4c | 642 | _txBufSentIndex += len; |
charly | 0:79c6d0071c4c | 643 | } |
charly | 0:79c6d0071c4c | 644 | } |
charly | 0:79c6d0071c4c | 645 | |
charly | 0:79c6d0071c4c | 646 | // Assumption: there are at least RF22_RXFFAFULL_THRESHOLD in the RX FIFO |
charly | 0:79c6d0071c4c | 647 | // That means it should only be called after a RXAFULL interrupt |
charly | 0:79c6d0071c4c | 648 | void RF22::readNextFragment() |
charly | 0:79c6d0071c4c | 649 | { |
charly | 0:79c6d0071c4c | 650 | if (((uint16_t)_bufLen + RF22_RXFFAFULL_THRESHOLD) > RF22_MAX_MESSAGE_LEN) |
charly | 0:79c6d0071c4c | 651 | { |
charly | 0:79c6d0071c4c | 652 | // Hmmm receiver overflow. Should never occur |
charly | 0:79c6d0071c4c | 653 | return; |
charly | 0:79c6d0071c4c | 654 | } |
charly | 0:79c6d0071c4c | 655 | // Read the RF22_RXFFAFULL_THRESHOLD octets that should be there |
charly | 0:79c6d0071c4c | 656 | spiBurstRead(RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, RF22_RXFFAFULL_THRESHOLD); |
charly | 0:79c6d0071c4c | 657 | _bufLen += RF22_RXFFAFULL_THRESHOLD; |
charly | 0:79c6d0071c4c | 658 | } |
charly | 0:79c6d0071c4c | 659 | |
charly | 0:79c6d0071c4c | 660 | // Clear the FIFOs |
charly | 0:79c6d0071c4c | 661 | void RF22::resetFifos() |
charly | 0:79c6d0071c4c | 662 | { |
charly | 0:79c6d0071c4c | 663 | spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRRX | RF22_FFCLRTX); |
charly | 0:79c6d0071c4c | 664 | spiWrite(RF22_REG_08_OPERATING_MODE2, 0); |
charly | 0:79c6d0071c4c | 665 | } |
charly | 0:79c6d0071c4c | 666 | |
charly | 0:79c6d0071c4c | 667 | // Clear the Rx FIFO |
charly | 0:79c6d0071c4c | 668 | void RF22::resetRxFifo() |
charly | 0:79c6d0071c4c | 669 | { |
charly | 0:79c6d0071c4c | 670 | spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRRX); |
charly | 0:79c6d0071c4c | 671 | spiWrite(RF22_REG_08_OPERATING_MODE2, 0); |
charly | 0:79c6d0071c4c | 672 | } |
charly | 0:79c6d0071c4c | 673 | |
charly | 0:79c6d0071c4c | 674 | // CLear the TX FIFO |
charly | 0:79c6d0071c4c | 675 | void RF22::resetTxFifo() |
charly | 0:79c6d0071c4c | 676 | { |
charly | 0:79c6d0071c4c | 677 | spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRTX); |
charly | 0:79c6d0071c4c | 678 | spiWrite(RF22_REG_08_OPERATING_MODE2, 0); |
charly | 0:79c6d0071c4c | 679 | } |
charly | 0:79c6d0071c4c | 680 | |
charly | 0:79c6d0071c4c | 681 | // Default implmentation does nothing. Override if you wish |
charly | 0:79c6d0071c4c | 682 | void RF22::handleExternalInterrupt() |
charly | 0:79c6d0071c4c | 683 | { |
charly | 0:79c6d0071c4c | 684 | } |
charly | 0:79c6d0071c4c | 685 | |
charly | 0:79c6d0071c4c | 686 | // Default implmentation does nothing. Override if you wish |
charly | 0:79c6d0071c4c | 687 | void RF22::handleWakeupTimerInterrupt() |
charly | 0:79c6d0071c4c | 688 | { |
charly | 0:79c6d0071c4c | 689 | } |
charly | 0:79c6d0071c4c | 690 | |
charly | 0:79c6d0071c4c | 691 | void RF22::setHeaderTo(uint8_t to) |
charly | 0:79c6d0071c4c | 692 | { |
charly | 0:79c6d0071c4c | 693 | spiWrite(RF22_REG_3A_TRANSMIT_HEADER3, to); |
charly | 0:79c6d0071c4c | 694 | } |
charly | 0:79c6d0071c4c | 695 | |
charly | 0:79c6d0071c4c | 696 | void RF22::setHeaderFrom(uint8_t from) |
charly | 0:79c6d0071c4c | 697 | { |
charly | 0:79c6d0071c4c | 698 | spiWrite(RF22_REG_3B_TRANSMIT_HEADER2, from); |
charly | 0:79c6d0071c4c | 699 | } |
charly | 0:79c6d0071c4c | 700 | |
charly | 0:79c6d0071c4c | 701 | void RF22::setHeaderId(uint8_t id) |
charly | 0:79c6d0071c4c | 702 | { |
charly | 0:79c6d0071c4c | 703 | spiWrite(RF22_REG_3C_TRANSMIT_HEADER1, id); |
charly | 0:79c6d0071c4c | 704 | } |
charly | 0:79c6d0071c4c | 705 | |
charly | 0:79c6d0071c4c | 706 | void RF22::setHeaderFlags(uint8_t flags) |
charly | 0:79c6d0071c4c | 707 | { |
charly | 0:79c6d0071c4c | 708 | spiWrite(RF22_REG_3D_TRANSMIT_HEADER0, flags); |
charly | 0:79c6d0071c4c | 709 | } |
charly | 0:79c6d0071c4c | 710 | |
charly | 0:79c6d0071c4c | 711 | uint8_t RF22::headerTo() |
charly | 0:79c6d0071c4c | 712 | { |
charly | 0:79c6d0071c4c | 713 | return spiRead(RF22_REG_47_RECEIVED_HEADER3); |
charly | 0:79c6d0071c4c | 714 | } |
charly | 0:79c6d0071c4c | 715 | |
charly | 0:79c6d0071c4c | 716 | uint8_t RF22::headerFrom() |
charly | 0:79c6d0071c4c | 717 | { |
charly | 0:79c6d0071c4c | 718 | return spiRead(RF22_REG_48_RECEIVED_HEADER2); |
charly | 0:79c6d0071c4c | 719 | } |
charly | 0:79c6d0071c4c | 720 | |
charly | 0:79c6d0071c4c | 721 | uint8_t RF22::headerId() |
charly | 0:79c6d0071c4c | 722 | { |
charly | 0:79c6d0071c4c | 723 | return spiRead(RF22_REG_49_RECEIVED_HEADER1); |
charly | 0:79c6d0071c4c | 724 | } |
charly | 0:79c6d0071c4c | 725 | |
charly | 0:79c6d0071c4c | 726 | uint8_t RF22::headerFlags() |
charly | 0:79c6d0071c4c | 727 | { |
charly | 0:79c6d0071c4c | 728 | return spiRead(RF22_REG_4A_RECEIVED_HEADER0); |
charly | 0:79c6d0071c4c | 729 | } |
charly | 0:79c6d0071c4c | 730 | |
charly | 0:79c6d0071c4c | 731 | uint8_t RF22::lastRssi() |
charly | 0:79c6d0071c4c | 732 | { |
charly | 0:79c6d0071c4c | 733 | return _lastRssi; |
charly | 0:79c6d0071c4c | 734 | } |
charly | 0:79c6d0071c4c | 735 | |
charly | 0:79c6d0071c4c | 736 | void RF22::setPromiscuous(boolean promiscuous) |
charly | 0:79c6d0071c4c | 737 | { |
charly | 0:79c6d0071c4c | 738 | spiWrite(RF22_REG_43_HEADER_ENABLE3, promiscuous ? 0x00 : 0xff); |
charly | 0:79c6d0071c4c | 739 | } |