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@2:f6f42c2ba9f2, 2012-02-18 (annotated)

Committer:
charly
Date:
Sat Feb 18 20:34:59 2012 +0000
Revision:
2:f6f42c2ba9f2
Parent:
0:79c6d0071c4c
Child:
3:c3c19f30ff69
Enable AFC of RFM22  in RF22::init()

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