Karl Zweimüller / RF22

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?

UserRevisionLine numberNew 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 }