Flo rian / RF22KL25Z

Library for HopeRF RFM22 transceiver module ported to mbed. Original Software from Mike McCauley (mikem@open.com.au) . See http://www.open.com.au/mikem/arduino/RF22/

Fork of RF22 by Karl Zweimüller

RF22.cpp@7:b86825b9d74b, 2013-03-13 (annotated)

Committer:
charly
Date:
Wed Mar 13 20:37:19 2013 +0000
Revision:
7:b86825b9d74b
Parent:
5:0386600f3408
Child:
8:d9e2ca137f2e
disable interrupts in critical sections. bug fixes, changes.

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