Karl Zweimüller
Test program to send MAX!-Messages with a RFM22-Module
Dependencies: RF22 TextLCD TextLCDScroll mbed RF22Max
Revision 2:941c46d37d7e, committed 2013-08-20
- Comitter:
- charly
- Date:
- Tue Aug 20 20:22:43 2013 +0000
- Parent:
- 1:b71f9a293c54
- Child:
- 3:4254b4c3557e
- Commit message:
- Initial version! Reads and decodes a window sensor. No Send, No ACK, No other devices
Changed in this revision
--- a/PinDetect.lib Wed Jan 18 20:09:21 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1 +0,0 @@ -http://mbed.org/users/AjK/libraries/PinDetect/lkyxpw \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/RF22.lib Tue Aug 20 20:22:43 2013 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/charly/code/RF22/#d9e2ca137f2e
--- a/RF22/.lib Wed Jan 18 20:09:21 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1 +0,0 @@ - \ No newline at end of file
--- a/RF22/RF22.cpp Wed Jan 18 20:09:21 2012 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,739 +0,0 @@
-// RF22.cpp
-//
-// Copyright (C) 2011 Mike McCauley
-// $Id: RF22.cpp,v 1.13 2011/10/09 21:22:24 mikem Exp mikem $
-// ported to mbed by Karl Zweimueller
-
-
-#include "mbed.h"
-#include "RF22.h"
-//#include <SPI.h>
-
-
-// Interrupt vectors for the 2 Arduino interrupt pins
-// Each interrupt can be handled by a different instance of RF22, allowing you to have
-// 2 RF22s per Arduino
-//RF22* RF22::_RF22ForInterrupt[2] = {0, 0};
-
-// These are indexed by the values of ModemConfigChoice
-// Canned modem configurations generated with
-// 'http://www.hoperf.com/upfile/RF22B 23B 31B 42B 43B Register Settings_RevB1-v5.xls'
-// Stored in flash (program) memory to save SRAM
-/*PROGMEM */ static const RF22::ModemConfig MODEM_CONFIG_TABLE[] =
-{
- { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x00, 0x08 }, // Unmodulated carrier
- { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x33, 0x08 }, // FSK, PN9 random modulation, 2, 5
-
- // 1c, 1f, 20, 21, 22, 23, 24, 25, 2c, 2d, 2e, 58, 69, 6e, 6f, 70, 71, 72
- // FSK, No Manchester, Max Rb err <1%, Xtal Tol 20ppm
- { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x22, 0x08 }, // 2, 5
- { 0x1b, 0x03, 0x41, 0x60, 0x27, 0x52, 0x00, 0x07, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x13, 0xa9, 0x2c, 0x22, 0x3a }, // 2.4, 36
- { 0x1d, 0x03, 0xa1, 0x20, 0x4e, 0xa5, 0x00, 0x13, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x27, 0x52, 0x2c, 0x22, 0x48 }, // 4.8, 45
- { 0x1e, 0x03, 0xd0, 0x00, 0x9d, 0x49, 0x00, 0x45, 0x40, 0x0a, 0x20, 0x80, 0x60, 0x4e, 0xa5, 0x2c, 0x22, 0x48 }, // 9.6, 45
- { 0x2b, 0x03, 0x34, 0x02, 0x75, 0x25, 0x07, 0xff, 0x40, 0x0a, 0x1b, 0x80, 0x60, 0x9d, 0x49, 0x2c, 0x22, 0x0f }, // 19.2, 9.6
- { 0x02, 0x03, 0x68, 0x01, 0x3a, 0x93, 0x04, 0xd5, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x09, 0xd5, 0x0c, 0x22, 0x1f }, // 38.4, 19.6
- { 0x06, 0x03, 0x45, 0x01, 0xd7, 0xdc, 0x07, 0x6e, 0x40, 0x0a, 0x2d, 0x80, 0x60, 0x0e, 0xbf, 0x0c, 0x22, 0x2e }, // 57.6. 28.8
- { 0x8a, 0x03, 0x60, 0x01, 0x55, 0x55, 0x02, 0xad, 0x40, 0x0a, 0x50, 0x80, 0x60, 0x20, 0x00, 0x0c, 0x22, 0xc8 }, // 125, 125
-
- // GFSK, No Manchester, Max Rb err <1%, Xtal Tol 20ppm
- // These differ from FSK only in register 71, for the modulation type
- { 0x2b, 0x03, 0xf4, 0x20, 0x41, 0x89, 0x00, 0x36, 0x40, 0x0a, 0x1d, 0x80, 0x60, 0x10, 0x62, 0x2c, 0x23, 0x08 }, // 2, 5
- { 0x1b, 0x03, 0x41, 0x60, 0x27, 0x52, 0x00, 0x07, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x13, 0xa9, 0x2c, 0x23, 0x3a }, // 2.4, 36
- { 0x1d, 0x03, 0xa1, 0x20, 0x4e, 0xa5, 0x00, 0x13, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x27, 0x52, 0x2c, 0x23, 0x48 }, // 4.8, 45
- { 0x1e, 0x03, 0xd0, 0x00, 0x9d, 0x49, 0x00, 0x45, 0x40, 0x0a, 0x20, 0x80, 0x60, 0x4e, 0xa5, 0x2c, 0x23, 0x48 }, // 9.6, 45
- { 0x2b, 0x03, 0x34, 0x02, 0x75, 0x25, 0x07, 0xff, 0x40, 0x0a, 0x1b, 0x80, 0x60, 0x9d, 0x49, 0x2c, 0x23, 0x0f }, // 19.2, 9.6
- { 0x02, 0x03, 0x68, 0x01, 0x3a, 0x93, 0x04, 0xd5, 0x40, 0x0a, 0x1e, 0x80, 0x60, 0x09, 0xd5, 0x0c, 0x23, 0x1f }, // 38.4, 19.6
- { 0x06, 0x03, 0x45, 0x01, 0xd7, 0xdc, 0x07, 0x6e, 0x40, 0x0a, 0x2d, 0x80, 0x60, 0x0e, 0xbf, 0x0c, 0x23, 0x2e }, // 57.6. 28.8
- { 0x8a, 0x03, 0x60, 0x01, 0x55, 0x55, 0x02, 0xad, 0x40, 0x0a, 0x50, 0x80, 0x60, 0x20, 0x00, 0x0c, 0x23, 0xc8 }, // 125, 125
-
- // OOK, No Manchester, Max Rb err <1%, Xtal Tol 20ppm
- { 0x51, 0x03, 0x68, 0x00, 0x3a, 0x93, 0x01, 0x3d, 0x2c, 0x11, 0x28, 0x80, 0x60, 0x09, 0xd5, 0x2c, 0x21, 0x08 }, // 1.2, 75
- { 0xc8, 0x03, 0x39, 0x20, 0x68, 0xdc, 0x00, 0x6b, 0x2a, 0x08, 0x2a, 0x80, 0x60, 0x13, 0xa9, 0x2c, 0x21, 0x08 }, // 2.4, 335
- { 0xc8, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x29, 0x04, 0x29, 0x80, 0x60, 0x27, 0x52, 0x2c, 0x21, 0x08 }, // 4.8, 335
- { 0xb8, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x28, 0x82, 0x29, 0x80, 0x60, 0x4e, 0xa5, 0x2c, 0x21, 0x08 }, // 9.6, 335
- { 0xa8, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x28, 0x41, 0x29, 0x80, 0x60, 0x9d, 0x49, 0x2c, 0x21, 0x08 }, // 19.2, 335
- { 0x98, 0x03, 0x9c, 0x00, 0xd1, 0xb7, 0x00, 0xd4, 0x28, 0x20, 0x29, 0x80, 0x60, 0x09, 0xd5, 0x0c, 0x21, 0x08 }, // 38.4, 335
- { 0x98, 0x03, 0x96, 0x00, 0xda, 0x74, 0x00, 0xdc, 0x28, 0x1f, 0x29, 0x80, 0x60, 0x0a, 0x3d, 0x0c, 0x21, 0x08 }, // 40, 335
-
-};
-
-RF22::RF22(PinName slaveSelectPin, PinName mosi, PinName miso, PinName sclk, PinName interrupt)
- : _slaveSelectPin(slaveSelectPin), _spi(mosi, miso, sclk), _interrupt(interrupt), led1(LED1), led2(LED2), led3(LED3), led4(LED4)
-{
-
-
- _idleMode = RF22_XTON; // Default idle state is READY mode
- _mode = RF22_MODE_IDLE; // We start up in idle mode
- _rxGood = 0;
- _rxBad = 0;
- _txGood = 0;
-
-
-}
-
-boolean RF22::init()
-{
- // Wait for RF22 POR (up to 16msec)
- //delay(16);
- wait_ms(16);
-
- // Initialise the slave select pin
- //pinMode(_slaveSelectPin, OUTPUT);
- //digitalWrite(_slaveSelectPin, HIGH);
- _slaveSelectPin = 1;
-
- wait_ms(100);
-
- // start the SPI library:
- // Note the RF22 wants mode 0, MSB first and default to 1 Mbps
- /*SPI.begin();
- SPI.setDataMode(SPI_MODE0);
- SPI.setBitOrder(MSBFIRST);
- SPI.setClockDivider(SPI_CLOCK_DIV16); // (16 Mhz / 16) = 1 MHz
- */
-
- // Setup the spi for 8 bit data : 1RW-bit 7 adressbit and 8 databit
- // second edge capture, with a 10MHz clock rate
- _spi.format(8,0);
- _spi.frequency(10000000);
-
- // Software reset the device
- reset();
-
- // Get the device type and check it
- // This also tests whether we are really connected to a device
- _deviceType = spiRead(RF22_REG_00_DEVICE_TYPE);
- if ( _deviceType != RF22_DEVICE_TYPE_RX_TRX
- && _deviceType != RF22_DEVICE_TYPE_TX)
- return false;
-
- // Set up interrupt handler
-// if (_interrupt == 0)
-// {
- //_RF22ForInterrupt[0] = this;
- //attachInterrupt(0, RF22::isr0, LOW);
- _interrupt.fall(this, &RF22::isr0);
-/* }
- else if (_interrupt == 1)
- {
- _RF22ForInterrupt[1] = this;
- attachInterrupt(1, RF22::isr1, LOW);
- }
- else
- return false;
-*/
- clearTxBuf();
- clearRxBuf();
-
- // Most of these are the POR default
- spiWrite(RF22_REG_7D_TX_FIFO_CONTROL2, RF22_TXFFAEM_THRESHOLD);
- spiWrite(RF22_REG_7E_RX_FIFO_CONTROL, RF22_RXFFAFULL_THRESHOLD);
- spiWrite(RF22_REG_30_DATA_ACCESS_CONTROL, RF22_ENPACRX | RF22_ENPACTX | RF22_ENCRC | RF22_CRC_CRC_16_IBM);
- // Configure the message headers
- // Here we set up the standard packet format for use by the RF22 library
- // 8 nibbles preamble
- // 2 SYNC words 2d, d4
- // Header length 4 (to, from, id, flags)
- // 1 octet of data length (0 to 255)
- // 0 to 255 octets data
- // 2 CRC octets as CRC16(IBM), computed on the header, length and data
- // On reception the to address is check for validity against RF22_REG_3F_CHECK_HEADER3
- // or the broadcast address of 0xff
- // If no changes are made after this, the transmitted
- // to address will be 0xff, the from address will be 0xff
- // and all such messages will be accepted. This permits the out-of the box
- // RF22 config to act as an unaddresed, unreliable datagram service
- spiWrite(RF22_REG_32_HEADER_CONTROL1, RF22_BCEN_HEADER3 | RF22_HDCH_HEADER3);
- spiWrite(RF22_REG_33_HEADER_CONTROL2, RF22_HDLEN_4 | RF22_SYNCLEN_2);
- setPreambleLength(8);
- uint8_t syncwords[] = { 0x2d, 0xd4 };
- setSyncWords(syncwords, sizeof(syncwords));
- setPromiscuous(false);
- // Check the TO header against RF22_DEFAULT_NODE_ADDRESS
- spiWrite(RF22_REG_3F_CHECK_HEADER3, RF22_DEFAULT_NODE_ADDRESS);
- // Set the default transmit header values
- setHeaderTo(RF22_DEFAULT_NODE_ADDRESS);
- setHeaderFrom(RF22_DEFAULT_NODE_ADDRESS);
- setHeaderId(0);
- setHeaderFlags(0);
-
- // Ensure the antenna can be switched automatically according to transmit and receive
- // This assumes GPIO0(out) is connected to TX_ANT(in) to enable tx antenna during transmit
- // This assumes GPIO1(out) is connected to RX_ANT(in) to enable rx antenna during receive
- spiWrite (RF22_REG_0B_GPIO_CONFIGURATION0, 0x12) ; // TX state
- spiWrite (RF22_REG_0C_GPIO_CONFIGURATION1, 0x15) ; // RX state
-
- // Enable interrupts
- spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM | RF22_ENRXFFAFULL | RF22_ENPKSENT | RF22_ENPKVALID | RF22_ENCRCERROR | RF22_ENFFERR);
- spiWrite(RF22_REG_06_INTERRUPT_ENABLE2, RF22_ENPREAVAL);
-
- // Set some defaults. An innocuous ISM frequency
- setFrequency(868.0);
-// setFrequency(434.0);
-// setFrequency(900.0);
- // Some slow, reliable default speed and modulation
- setModemConfig(FSK_Rb2_4Fd36);
-// setModemConfig(FSK_Rb125Fd125);
- // Minimum power
- setTxPower(RF22_TXPOW_8DBM);
-// setTxPower(RF22_TXPOW_17DBM);
-
- return true;
-}
-
-// C++ level interrupt handler for this instance
-void RF22::handleInterrupt()
-{
- uint8_t _lastInterruptFlags[2];
-
-led1 = !led1;
-
- // Read the interrupt flags which clears the interrupt
- spiBurstRead(RF22_REG_03_INTERRUPT_STATUS1, _lastInterruptFlags, 2);
-
-#if 0
- pc.print("interrupt ");
- Serial.print(_lastInterruptFlags[0], HEX);
- Serial.print(" ");
- Serial.println(_lastInterruptFlags[1], HEX);
- if (_lastInterruptFlags[0] == 0 && _lastInterruptFlags[1] == 0)
- Serial.println("FUNNY: no interrupt!");
-#endif
-
-/*
- // TESTING: fake an RF22_IFFERROR
- static int counter = 0;
- if (_lastInterruptFlags[0] & RF22_IPKSENT && counter++ == 10)
- {
- _lastInterruptFlags[0] = RF22_IFFERROR;
- counter = 0;
- }
-*/
-
- if (_lastInterruptFlags[0] & RF22_IFFERROR)
- {
-// Serial.println("IFFERROR");
- resetFifos(); // Clears the interrupt
- if (_mode == RF22_MODE_TX)
- restartTransmit();
- else if (_mode == RF22_MODE_RX)
- clearRxBuf();
- }
- // Caution, any delay here may cause a FF underflow or overflow
- if (_lastInterruptFlags[0] & RF22_ITXFFAEM)
- {
- // See if more data has to be loaded into the Tx FIFO
- sendNextFragment();
-// Serial.println("TXFFAEM");
- }
- if (_lastInterruptFlags[0] & RF22_IRXFFAFULL)
- {
- // Caution, any delay here may cause a FF overflow
- // Read some data from the Rx FIFO
- readNextFragment();
-// Serial.println("IRXFFAFULL");
- }
- if (_lastInterruptFlags[0] & RF22_IEXT)
- {
- // This is not enabled by the base code, but users may want to enable it
- handleExternalInterrupt();
-// Serial.println("IEXT");
- }
- if (_lastInterruptFlags[1] & RF22_IWUT)
- {
- // This is not enabled by the base code, but users may want to enable it
- handleWakeupTimerInterrupt();
-// Serial.println("IWUT");
- }
- if (_lastInterruptFlags[0] & RF22_IPKSENT)
- {
-// Serial.println("PKSENT");
- _txGood++;
- led4 = !led4;
- // Transmission does not automatically clear the tx buffer.
- // Could retransmit if we wanted
- _txPacketSent = true;
- // RF22 transitions automatically to Idle
- _mode = RF22_MODE_IDLE;
- }
- if (_lastInterruptFlags[0] & RF22_IPKVALID)
- {
-// Serial.println("IPKVALID");
- uint8_t len = spiRead(RF22_REG_4B_RECEIVED_PACKET_LENGTH);
- // May have already read one or more fragments
- // Get any remaining unread octets, based on the expected length
- len -= _bufLen;
- spiBurstRead(RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, len);
- _rxGood++;
- led3 = !led3;
- _bufLen += len;
- _mode = RF22_MODE_IDLE;
- _rxBufValid = true;
- }
- if (_lastInterruptFlags[0] & RF22_ICRCERROR)
- {
-// Serial.println("ICRCERR");
- _rxBad++;
- led2 = !led2;
- clearRxBuf();
- resetRxFifo();
- _mode = RF22_MODE_IDLE;
- setModeRx(); // Keep trying
- }
- if (_lastInterruptFlags[1] & RF22_ENPREAVAL)
- {
-// Serial.println("ENPREAVAL");
- _lastRssi = spiRead(RF22_REG_26_RSSI);
- clearRxBuf();
- }
-}
-
-// These are low level functions that call the interrupt handler for the correct
-// instance of RF22.
-// 2 interrupts allows us to have 2 different devices
-void RF22::isr0()
-{
- //if (_RF22ForInterrupt[0])
- //_RF22ForInterrupt[0]->handleInterrupt();
- handleInterrupt();
-}
-/*
-void RF22::isr1()
-{
- if (_RF22ForInterrupt[1])
- _RF22ForInterrupt[1]->handleInterrupt();
-}
-*/
-void RF22::reset()
-{
- spiWrite(RF22_REG_07_OPERATING_MODE1, RF22_SWRES);
- // Wait for it to settle
- //delay(1); // SWReset time is nominally 100usec
- wait_ms(1);
-}
-
-uint8_t RF22::spiRead(uint8_t reg)
-{
- //digitalWrite(_slaveSelectPin, LOW);
- _slaveSelectPin=0;
- //_spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the address with the write mask off
- _spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the address with the write mask off
- uint8_t val = _spi.write(0); // The written value is ignored, reg value is read
- //digitalWrite(_slaveSelectPin, HIGH);
- _slaveSelectPin = 1;
- return val;
-}
-
-void RF22::spiWrite(uint8_t reg, uint8_t val)
-{
- //digitalWrite(_slaveSelectPin, LOW);
- _slaveSelectPin = 0;
- _spi.write(reg | RF22_SPI_WRITE_MASK); // Send the address with the write mask on
- _spi.write(val); // New value follows
- //digitalWrite(_slaveSelectPin, HIGH);
- _slaveSelectPin = 1;
-}
-
-void RF22::spiBurstRead(uint8_t reg, uint8_t* dest, uint8_t len)
-{
- //digitalWrite(_slaveSelectPin, LOW);
- _slaveSelectPin = 0;
- _spi.write(reg & ~RF22_SPI_WRITE_MASK); // Send the start address with the write mask off
- while (len--)
- *dest++ = _spi.write(0);
- //digitalWrite(_slaveSelectPin, HIGH);
- _slaveSelectPin = 1;
-}
-
-void RF22::spiBurstWrite(uint8_t reg, uint8_t* src, uint8_t len)
-{
- //digitalWrite(_slaveSelectPin, LOW);
- _slaveSelectPin = 0;
- _spi.write(reg | RF22_SPI_WRITE_MASK); // Send the start address with the write mask on
- while (len--)
- _spi.write(*src++);
- //digitalWrite(_slaveSelectPin, HIGH);
- _slaveSelectPin = 1;
-}
-
-uint8_t RF22::statusRead()
-{
- return spiRead(RF22_REG_02_DEVICE_STATUS);
-}
-
-uint8_t RF22::adcRead(uint8_t adcsel,
- uint8_t adcref ,
- uint8_t adcgain,
- uint8_t adcoffs)
-{
- uint8_t configuration = adcsel | adcref | (adcgain & RF22_ADCGAIN);
- spiWrite(RF22_REG_0F_ADC_CONFIGURATION, configuration | RF22_ADCSTART);
- spiWrite(RF22_REG_10_ADC_SENSOR_AMP_OFFSET, adcoffs);
-
- // Conversion time is nominally 305usec
- // Wait for the DONE bit
- while (!(spiRead(RF22_REG_0F_ADC_CONFIGURATION) & RF22_ADCDONE))
- ;
- // Return the value
- return spiRead(RF22_REG_11_ADC_VALUE);
-}
-
-uint8_t RF22::temperatureRead(uint8_t tsrange, uint8_t tvoffs)
-{
- spiWrite(RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION, tsrange | RF22_ENTSOFFS);
- spiWrite(RF22_REG_13_TEMPERATURE_VALUE_OFFSET, tvoffs);
- return adcRead(RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR | RF22_ADCREF_BANDGAP_VOLTAGE);
-}
-
-uint16_t RF22::wutRead()
-{
- uint8_t buf[2];
- spiBurstRead(RF22_REG_17_WAKEUP_TIMER_VALUE1, buf, 2);
- return ((uint16_t)buf[0] << 8) | buf[1]; // Dont rely on byte order
-}
-
-// RFM-22 doc appears to be wrong: WUT for wtm = 10000, r, = 0, d = 0 is about 1 sec
-void RF22::setWutPeriod(uint16_t wtm, uint8_t wtr, uint8_t wtd)
-{
- uint8_t period[3];
-
- period[0] = ((wtr & 0xf) << 2) | (wtd & 0x3);
- period[1] = wtm >> 8;
- period[2] = wtm & 0xff;
- spiBurstWrite(RF22_REG_14_WAKEUP_TIMER_PERIOD1, period, sizeof(period));
-}
-
-// Returns true if centre + (fhch * fhs) is within limits
-// Caution, different versions of the RF22 suport different max freq
-// so YMMV
-boolean RF22::setFrequency(float centre)
-{
- uint8_t fbsel = RF22_SBSEL;
- if (centre < 240.0 || centre > 960.0) // 930.0 for early silicon
- return false;
- if (centre >= 480.0)
- {
- centre /= 2;
- fbsel |= RF22_HBSEL;
- }
- centre /= 10.0;
- float integerPart = floor(centre);
- float fractionalPart = centre - integerPart;
-
- uint8_t fb = (uint8_t)integerPart - 24; // Range 0 to 23
- fbsel |= fb;
- uint16_t fc = fractionalPart * 64000;
- spiWrite(RF22_REG_73_FREQUENCY_OFFSET1, 0); // REVISIT
- spiWrite(RF22_REG_74_FREQUENCY_OFFSET2, 0);
- spiWrite(RF22_REG_75_FREQUENCY_BAND_SELECT, fbsel);
- spiWrite(RF22_REG_76_NOMINAL_CARRIER_FREQUENCY1, fc >> 8);
- spiWrite(RF22_REG_77_NOMINAL_CARRIER_FREQUENCY0, fc & 0xff);
- return !(statusRead() & RF22_FREQERR);
-}
-
-// Step size in 10kHz increments
-// Returns true if centre + (fhch * fhs) is within limits
-boolean RF22::setFHStepSize(uint8_t fhs)
-{
- spiWrite(RF22_REG_7A_FREQUENCY_HOPPING_STEP_SIZE, fhs);
- return !(statusRead() & RF22_FREQERR);
-}
-
-// Adds fhch * fhs to centre frequency
-// Returns true if centre + (fhch * fhs) is within limits
-boolean RF22::setFHChannel(uint8_t fhch)
-{
- spiWrite(RF22_REG_79_FREQUENCY_HOPPING_CHANNEL_SELECT, fhch);
- return !(statusRead() & RF22_FREQERR);
-}
-
-uint8_t RF22::rssiRead()
-{
- return spiRead(RF22_REG_26_RSSI);
-}
-
-uint8_t RF22::ezmacStatusRead()
-{
- return spiRead(RF22_REG_31_EZMAC_STATUS);
-}
-
-void RF22::setMode(uint8_t mode)
-{
- spiWrite(RF22_REG_07_OPERATING_MODE1, mode);
-}
-
-void RF22::setModeIdle()
-{
- if (_mode != RF22_MODE_IDLE)
- {
- setMode(_idleMode);
- _mode = RF22_MODE_IDLE;
- }
-}
-
-void RF22::setModeRx()
-{
- if (_mode != RF22_MODE_RX)
- {
- setMode(_idleMode | RF22_RXON);
- _mode = RF22_MODE_RX;
- }
-}
-
-void RF22::setModeTx()
-{
- if (_mode != RF22_MODE_TX)
- {
- setMode(_idleMode | RF22_TXON);
- _mode = RF22_MODE_TX;
- }
-}
-
-void RF22::setTxPower(uint8_t power)
-{
- spiWrite(RF22_REG_6D_TX_POWER, power);
-}
-
-// Sets registers from a canned modem configuration structure
-void RF22::setModemRegisters(ModemConfig* config)
-{
- spiWrite(RF22_REG_1C_IF_FILTER_BANDWIDTH, config->reg_1c);
- spiWrite(RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE, config->reg_1f);
- spiBurstWrite(RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE, &config->reg_20, 6);
- spiBurstWrite(RF22_REG_2C_OOK_COUNTER_VALUE_1, &config->reg_2c, 3);
- spiWrite(RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING, config->reg_58);
- spiWrite(RF22_REG_69_AGC_OVERRIDE1, config->reg_69);
- spiBurstWrite(RF22_REG_6E_TX_DATA_RATE1, &config->reg_6e, 5);
-}
-
-// Set one of the canned FSK Modem configs
-// Returns true if its a valid choice
-boolean RF22::setModemConfig(ModemConfigChoice index)
-{
- if (index > (sizeof(MODEM_CONFIG_TABLE) / sizeof(ModemConfig)))
- return false;
-
- RF22::ModemConfig cfg;
- memcpy(&cfg, &MODEM_CONFIG_TABLE[index], sizeof(RF22::ModemConfig));
- setModemRegisters(&cfg);
-
- return true;
-}
-
-// REVISIT: top bit is in Header Control 2 0x33
-void RF22::setPreambleLength(uint8_t nibbles)
-{
- spiWrite(RF22_REG_34_PREAMBLE_LENGTH, nibbles);
-}
-
-// Caution doesnt set sync word len in Header Control 2 0x33
-void RF22::setSyncWords(uint8_t* syncWords, uint8_t len)
-{
- spiBurstWrite(RF22_REG_36_SYNC_WORD3, syncWords, len);
-}
-
-void RF22::clearRxBuf()
-{
- _bufLen = 0;
- _rxBufValid = false;
-}
-
-boolean RF22::available()
-{
- setModeRx();
- return _rxBufValid;
-}
-
-// Blocks until a valid message is received
-void RF22::waitAvailable()
-{
- while (!available())
- ;
-}
-
-// Blocks until a valid message is received or timeout expires
-// Return true if there is a message available
-bool RF22::waitAvailableTimeout(uint16_t timeout)
-{
- Timer t;
- t.start();
- unsigned long endtime = t.read_ms() + timeout;
- while (t.read_ms() < endtime)
- if (available())
- return true;
- return false;
-}
-
-void RF22::waitPacketSent()
-{
- while (!_txPacketSent)
- ;
-}
-
-boolean RF22::recv(uint8_t* buf, uint8_t* len)
-{
- if (!available())
- return false;
- if (*len > _bufLen)
- *len = _bufLen;
- memcpy(buf, _buf, *len);
- clearRxBuf();
- return true;
-}
-
-void RF22::clearTxBuf()
-{
- _bufLen = 0;
- _txBufSentIndex = 0;
- _txPacketSent = false;
-}
-
-void RF22::startTransmit()
-{
- sendNextFragment(); // Actually the first fragment
- spiWrite(RF22_REG_3E_PACKET_LENGTH, _bufLen); // Total length that will be sent
- setModeTx(); // Start the transmitter, turns off the receiver
-}
-
-// Restart the trasnmission of a packet that had a problem
-void RF22::restartTransmit()
-{
- _mode = RF22_MODE_IDLE;
- _txBufSentIndex = 0;
- _txPacketSent = false;
-// Serial.println("Restart");
- startTransmit();
-}
-
-boolean RF22::send(uint8_t* data, uint8_t len)
-{
- setModeIdle();
- fillTxBuf(data, len);
- startTransmit();
- return true;
-}
-
-boolean RF22::fillTxBuf(uint8_t* data, uint8_t len)
-{
- clearTxBuf();
- return appendTxBuf(data, len);
-}
-
-boolean RF22::appendTxBuf(uint8_t* data, uint8_t len)
-{
- if (((uint16_t)_bufLen + len) > RF22_MAX_MESSAGE_LEN)
- return false;
- memcpy(_buf + _bufLen, data, len);
- _bufLen += len;
- return true;
-}
-
-// Assumption: there is currently <= RF22_TXFFAEM_THRESHOLD bytes in the Tx FIFO
-void RF22::sendNextFragment()
-{
- if (_txBufSentIndex < _bufLen)
- {
- // Some left to send
- uint8_t len = _bufLen - _txBufSentIndex;
- // But dont send too much
- if (len > (RF22_FIFO_SIZE - RF22_TXFFAEM_THRESHOLD - 1))
- len = (RF22_FIFO_SIZE - RF22_TXFFAEM_THRESHOLD - 1);
- spiBurstWrite(RF22_REG_7F_FIFO_ACCESS, _buf + _txBufSentIndex, len);
- _txBufSentIndex += len;
- }
-}
-
-// Assumption: there are at least RF22_RXFFAFULL_THRESHOLD in the RX FIFO
-// That means it should only be called after a RXAFULL interrupt
-void RF22::readNextFragment()
-{
- if (((uint16_t)_bufLen + RF22_RXFFAFULL_THRESHOLD) > RF22_MAX_MESSAGE_LEN)
- {
- // Hmmm receiver overflow. Should never occur
- return;
- }
- // Read the RF22_RXFFAFULL_THRESHOLD octets that should be there
- spiBurstRead(RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, RF22_RXFFAFULL_THRESHOLD);
- _bufLen += RF22_RXFFAFULL_THRESHOLD;
-}
-
-// Clear the FIFOs
-void RF22::resetFifos()
-{
- spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRRX | RF22_FFCLRTX);
- spiWrite(RF22_REG_08_OPERATING_MODE2, 0);
-}
-
-// Clear the Rx FIFO
-void RF22::resetRxFifo()
-{
- spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRRX);
- spiWrite(RF22_REG_08_OPERATING_MODE2, 0);
-}
-
-// CLear the TX FIFO
-void RF22::resetTxFifo()
-{
- spiWrite(RF22_REG_08_OPERATING_MODE2, RF22_FFCLRTX);
- spiWrite(RF22_REG_08_OPERATING_MODE2, 0);
-}
-
-// Default implmentation does nothing. Override if you wish
-void RF22::handleExternalInterrupt()
-{
-}
-
-// Default implmentation does nothing. Override if you wish
-void RF22::handleWakeupTimerInterrupt()
-{
-}
-
-void RF22::setHeaderTo(uint8_t to)
-{
- spiWrite(RF22_REG_3A_TRANSMIT_HEADER3, to);
-}
-
-void RF22::setHeaderFrom(uint8_t from)
-{
- spiWrite(RF22_REG_3B_TRANSMIT_HEADER2, from);
-}
-
-void RF22::setHeaderId(uint8_t id)
-{
- spiWrite(RF22_REG_3C_TRANSMIT_HEADER1, id);
-}
-
-void RF22::setHeaderFlags(uint8_t flags)
-{
- spiWrite(RF22_REG_3D_TRANSMIT_HEADER0, flags);
-}
-
-uint8_t RF22::headerTo()
-{
- return spiRead(RF22_REG_47_RECEIVED_HEADER3);
-}
-
-uint8_t RF22::headerFrom()
-{
- return spiRead(RF22_REG_48_RECEIVED_HEADER2);
-}
-
-uint8_t RF22::headerId()
-{
- return spiRead(RF22_REG_49_RECEIVED_HEADER1);
-}
-
-uint8_t RF22::headerFlags()
-{
- return spiRead(RF22_REG_4A_RECEIVED_HEADER0);
-}
-
-uint8_t RF22::lastRssi()
-{
- return _lastRssi;
-}
-
-void RF22::setPromiscuous(boolean promiscuous)
-{
- spiWrite(RF22_REG_43_HEADER_ENABLE3, promiscuous ? 0x00 : 0xff);
-}
--- a/RF22/RF22.h Wed Jan 18 20:09:21 2012 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1024 +0,0 @@
-// RF22.h
-// Author: Mike McCauley (mikem@open.com.au)
-// Copyright (C) 2011 Mike McCauley
-// $Id: RF22.h,v 1.19 2011/10/09 21:22:24 mikem Exp mikem $
-// ported to mbed by Karl Zweimueller
-//
-/// \mainpage RF22 library for Arduino
-///
-/// This is the Arduino RF22 library.
-/// It provides an object-oriented interface for sending and receiving data messages with Hope-RF
-/// RF22B based radio modules, and compatible chips and modules, including the RFM22B transceiver module such as
-/// this one: http://www.sparkfun.com/products/10153
-///
-/// RF22 also supports some of the features of ZigBee and XBee,
-/// (such as mesh routing and automatic route discovery),
-/// but with a much less complicated system and less expensive radios.
-///
-/// The Hope-RF (http://www.hoperf.com) RFM22B (http://www.hoperf.com/rf_fsk/fsk/RFM22B.htm)
-/// is a low-cost ISM transceiver module. It supports FSK, GFSK, OOK over a wide
-/// range of frequencies and programmable data rates.
-///
-/// This library provides functions for sending and receiving messages of up to 255 octets on any
-/// frequency supported by the RF22B, in a range of predefined data rates and frequency deviations.
-/// Frequency can be set with 312Hz precision to any frequency from 240.0MHz to 960.0MHz.
-///
-/// Up to 2 RF22B modules can be connected to an Arduino, permitting the construction of translators
-/// and frequency changers, etc.
-///
-/// This library provides classes for
-/// - RF22: unaddressed, unreliable messages
-/// - RF22Datagram: addressed, unreliable messages
-/// - RF22ReliableDatagram: addressed, reliable, retransmitted, acknowledged messages.
-/// - RF22Router: multi hop delivery from source node to destination node via 0 or more intermediate nodes
-/// - RF22Mesh: multi hop delivery with automatic route discovery and rediscovery.
-///
-/// The following modulation types are suppported with a range of modem configurations for
-/// common data rates and frequency deviations:
-/// - GFSK Gaussian Frequency Shift Keying
-/// - FSK Frequency Shift Keying
-/// - OOK On-Off Keying
-///
-/// Support for other RF22B features such as on-chip temperature measurement, analog-digital
-/// converter, transmitter power control etc is also provided.
-///
-/// The latest version of this documentation can be downloaded from
-/// http://www.open.com.au/mikem/arduino/RF22
-///
-/// Example Arduino programs are included to show the main modes of use.
-///
-/// The version of the package that this documentation refers to can be downloaded
-/// from http://www.open.com.au/mikem/arduino/RF22/RF22-1.10.zip
-/// You can find the latest version at http://www.open.com.au/mikem/arduino/RF22
-///
-/// Tested on Arduino Diecimila and Mega with arduino-0021
-/// on OpenSuSE 11.1 and avr-libc-1.6.1-1.15,
-/// cross-avr-binutils-2.19-9.1, cross-avr-gcc-4.1.3_20080612-26.5.
-/// With HopeRF RFM22 modules that appear to have RF22B chips on board:
-/// - Device Type Code = 0x08 (RX/TRX)
-/// - Version Code = 0x06
-/// It is known not to work on Diecimila. Dont bother trying.
-///
-/// \par Packet Format
-///
-/// All messages sent and received by this RF22 library must conform to this packet format:
-///
-/// - 8 nibbles (4 octets) PREAMBLE
-/// - 2 octets SYNC 0x2d, 0xd4
-/// - 4 octets HEADER: (TO, FROM, ID, FLAGS)
-/// - 1 octet LENGTH (0 to 255), number of octets in DATA
-/// - 0 to 255 octets DATA
-/// - 2 octets CRC computed with CRC16(IBM), computed on HEADER, LENGTH and DATA
-///
-/// For technical reasons, the message format is not compatible with the
-/// 'HopeRF Radio Transceiver Message Library for Arduino' http://www.open.com.au/mikem/arduino/HopeRF from the same author. Nor is it compatible with
-/// 'Virtual Wire' http://www.open.com.au/mikem/arduino/VirtualWire.pdf also from the same author.
-///
-/// \par Connecting RFM-22 to Arduino
-/// The physical connection between the RF22B and the Arduino require 3.3V, the 3 x SPI pins (SCK, SDI, SDO),
-/// a Slave Select pin and an interrupt pin.
-/// Note also that on the RFF22B, it is required to control the TX_ANT and X_ANT pins of the RFM22 in order to enable the
-/// antenna connection. The RF22 library is configured so that GPIO0 and GPIO1 outputs can control TX_ANT and RX_ANT input pins
-/// automatically. You must connect GPIO0 to TX_ANT and GPIO1 to RX_ANT for this automatic antenna switching to occur.
-///
-/// Connect the RFM-22 to most Arduino's like this (Caution, Arduino Mega has different pins for SPI,
-/// see below):
-/// \code
-/// Arduino RFM-22B
-/// GND----------GND-\ (ground in)
-/// SDN-/ (shutdown in)
-/// 3V3----------VCC (3.3V in)
-/// interrupt 0 pin D2-----------NIRQ (interrupt request out)
-/// SS pin D10----------NSEL (chip select in)
-/// SCK pin D13----------SCK (SPI clock in)
-/// MOSI pin D11----------SDI (SPI Data in)
-/// MISO pin D12----------SDO (SPI data out)
-/// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT
-/// \--TX_ANT (TX antenna control in)
-/// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT
-/// \--RX_ANT (RX antenna control in)
-/// \endcode
-/// For an Arduino Mega:
-/// \code
-/// Mega RFM-22B
-/// GND----------GND-\ (ground in)
-/// SDN-/ (shutdown in)
-/// 3V3----------VCC (3.3V in)
-/// interrupt 0 pin D2-----------NIRQ (interrupt request out)
-/// SS pin D10----------NSEL (chip select in)
-/// SCK pin D52----------SCK (SPI clock in)
-/// MOSI pin D51----------SDI (SPI Data in)
-/// MISO pin D50----------SDO (SPI data out)
-/// /--GPIO0 (GPIO0 out to control transmitter antenna TX_ANT
-/// \--TX_ANT (TX antenna control in)
-/// /--GPIO1 (GPIO1 out to control receiver antenna RX_ANT
-/// \--RX_ANT (RX antenna control in)
-/// \endcode
-/// and you can then use the default constructor RF22().
-/// You can override the default settings for the SS pin and the interrupt
-/// in the RF22 constructor if you wish to connect the slave select SS to other than pin D10
-/// or the interrupt request to other than pin D2.
-/// It is possible to have 2 radios conected to one arduino, provided each radio has its own
-/// SS and interrupt line (SCK, SDI and SDO are common to both radios)
-///
-/// \par Example programs
-///
-/// The following example programs are provided:
-/// - rf22_client, rf22_server: Simple client/server pair using RF22 class
-/// - rf22_datagram_client, rf22_datagram_server: Simple client/server pair using RF22Datagram class
-/// - rf22_reliable_datagram_client, rf22_reliable_datagram_server:
-/// Simple client/server pair using RF22ReliableDatagram class
-/// - rf22_router_client, rf22_router_server1, rf22_router_server2, rf22_router_server3:
-/// Simple RF22Router network. Requires Arduino Mega.
-/// - rf22_mesh_client, rf22_mesh_server1, rf22_mesh_server2, rf22_mesh_server3:
-/// Simple RF22Mesh network. Requires Arduino Mega.
-/// - rf22_test: Some test code used during development, shows how to call some support functions
-/// - rf22_snoop: Dumps in ASCII the contents of all RF22 messages received
-/// - rf22_specan: Simple spectrum analyser using the RSSI measurements of the RF22
-/// (see <a href="specan1.png">Sample output</a> showing a plot from 395.0MHz to 396.0MHz of a
-/// signal generator at 395.5MHz amplitude modulated at 100% 1kHz)
-///
-/// \par Memory
-///
-/// The RF22 library requires non-trivial amounts of memory. The sample programs above all compile to
-/// about 9 to 14kbytes each, which will fit in the flash proram memory of most Arduinos. However,
-/// the RAM requirements are more critical. Most sample programs above will run on Duemilanova,
-/// but not on Diecimila. Even on Duemilanova, the RAM requirements are very close to the
-/// available memory of 2kbytes. Therefore, you should be vary sparing with RAM use in programs that use
-/// the RF22 library on Duemilanova.
-///
-/// The sample RF22Router and RF22Mesh programs compile to about 14kbytes,
-/// and require more RAM than the others.
-/// They will not run on Duemilanova or Diecimila, but will run on Arduino Mega.
-///
-/// It is often hard to accurately identify when you are hitting RAM limits on Arduino.
-/// The symptoms can include:
-/// - Mysterious crashes and restarts
-/// - Changes in behaviour when seemingly unrelated changes are made (such as adding print() statements)
-/// - Hanging
-/// - Output from Serial.print() not appearing
-///
-/// With an Arduino Mega, with 8 kbytes of SRAM, there is much more RAM headroom for
-/// your own elaborate programs.
-/// This library is reported not to work with Arduino Pro Mini and Arduino UNO, but these have not been tested here.
-///
-/// \par Installation
-///
-/// Install in the usual way: unzip the distribution zip file to the libraries
-/// sub-folder of your sketchbook.
-///
-/// This software is Copyright (C) 2011 Mike McCauley. Use is subject to license
-/// conditions. The main licensing options available are GPL V2 or Commercial:
-///
-/// \par Open Source Licensing GPL V2
-///
-/// This is the appropriate option if you want to share the source code of your
-/// application with everyone you distribute it to, and you also want to give them
-/// the right to share who uses it. If you wish to use this software under Open
-/// Source Licensing, you must contribute all your source code to the open source
-/// community in accordance with the GPL Version 2 when your application is
-/// distributed. See http://www.gnu.org/copyleft/gpl.html
-///
-/// \par Commercial Licensing
-///
-/// This is the appropriate option if you are creating proprietary applications
-/// and you are not prepared to distribute and share the source code of your
-/// application. Contact info@open.com.au for details.
-///
-/// \par Revision History
-///
-/// \version 1.0 Initial release
-///
-/// \version 1.1 Added rf22_snoop and rf22_specan examples
-///
-/// \version 1.2 Changed default modulation to FSK_Rb2_4Fd36
-/// Some internal reorganisation.
-/// Added RF22Router and RF22Mesh classes plus sample programs to support multi-hop and
-/// automatic route discovery.
-/// \version 1.3 Removed some unnecessary debug messages. Added virtual doArp and isPhysicalAddress
-/// functions to RF22Mesh to support other physical address interpretation schemes (IPV4/IPV6?)
-/// \version 1.4 RF22Router and RF22Mesh were inadvertently left out of the distro.
-/// \version 1.5 Improvements contributed by Peter Mousley: Modem config table is now in flash rather than SRAM,
-/// saving 400 bytes of SRAM. Allow a user-defined buffer size. Thanks Peter.
-/// \version 1.6 Fixed some minor typos on doc and clarified that this code is for the RF22B. Fixed errors in the
-/// definition of the power output constants which were incorrectly set to the values for the RF22.
-/// Reported by Fred Slamen. If you were using a previous version of RF22, you probably were not getting the output
-/// power you thought.
-/// \version 1.7 Added code to initialise GPIO0 and GPIO1 so they can automatically control the TX_ANT and RX_ANT
-/// antenna switching inputs. You must connect GPIO0 to TX_ANT and GPIO1 to RX_ANT for this automatic
-/// antenna switching to occur. Updated doc to reflect this new connection requirement
-/// \version 1.8 Changed the name of RF22_ENLBD in RF22_REG_06_INTERRUPT_ENABLE2 to RF22_ENLBDI because it collided
-/// with a define of the same name in RF22_REG_07_OPERATING_MODE. RF22_REG_05_INTERRUPT_ENABLE1 enable mask
-/// incorrectly used RF22_IFFERROR instead of RF22_ENFFERR. Reported by Steffan Woltjer.
-/// \version 1.9 Fixed typos in RF22_REG_21_CLOCk*. Reported by Steffan Woltjer.
-/// \version 1.10 Fixed a problem where a IFFERR during transmission could cause an infinite loop and a hang.
-/// Reported by Raymond Gilbert.
-///
-///
-/// \author Mike McCauley (mikem@open.com.au)
-
-#ifndef RF22_h
-#define RF22_h
-#include "mbed.h"
-
-#define boolean bool
-
-//#include <wiring.h>
-// These defs cause trouble on some versions of Arduino
-#undef round
-#undef double
-
-// This is the bit in the SPI address that marks it as a write
-#define RF22_SPI_WRITE_MASK 0x80
-
-// This is the maximum message length that can be supported by this library. Limited by
-// the message length octet in the header. Yes, 255 is correct even though the FIFO size in the RF22 is only
-// 64 octets. We use interrupts to refil the Tx FIFO during transmission and to empty the
-// Rx FIF during reception
-// Can be pre-defined to a smaller size (to save SRAM) prior to including this header
-#ifndef RF22_MAX_MESSAGE_LEN
-#define RF22_MAX_MESSAGE_LEN 255
-#endif
-
-// Max number of octets the RF22 Rx and Tx FIFOs can hold
-#define RF22_FIFO_SIZE 64
-
-// Keep track of the mode the RF22 is in
-#define RF22_MODE_IDLE 0
-#define RF22_MODE_RX 1
-#define RF22_MODE_TX 2
-
-// These values we set for FIFO thresholds are actually the same as the POR values
-#define RF22_TXFFAEM_THRESHOLD 4
-#define RF22_RXFFAFULL_THRESHOLD 55
-
-// This is the default node address,
-#define RF22_DEFAULT_NODE_ADDRESS 0
-
-// This address in the TO addreess signifies a broadcast
-#define RF22_BROADCAST_ADDRESS 0xff
-
-// Number of registers to be passed to setModemConfig()
-#define RF22_NUM_MODEM_CONFIG_REGS 18
-
-// Register names
-#define RF22_REG_00_DEVICE_TYPE 0x00
-#define RF22_REG_01_VERSION_CODE 0x01
-#define RF22_REG_02_DEVICE_STATUS 0x02
-#define RF22_REG_03_INTERRUPT_STATUS1 0x03
-#define RF22_REG_04_INTERRUPT_STATUS2 0x04
-#define RF22_REG_05_INTERRUPT_ENABLE1 0x05
-#define RF22_REG_06_INTERRUPT_ENABLE2 0x06
-#define RF22_REG_07_OPERATING_MODE1 0x07
-#define RF22_REG_08_OPERATING_MODE2 0x08
-#define RF22_REG_09_OSCILLATOR_LOAD_CAPACITANCE 0x09
-#define RF22_REG_0A_UC_OUTPUT_CLOCK 0x0a
-#define RF22_REG_0B_GPIO_CONFIGURATION0 0x0b
-#define RF22_REG_0C_GPIO_CONFIGURATION1 0x0c
-#define RF22_REG_0D_GPIO_CONFIGURATION2 0x0d
-#define RF22_REG_0E_IO_PORT_CONFIGURATION 0x0e
-#define RF22_REG_0F_ADC_CONFIGURATION 0x0f
-#define RF22_REG_10_ADC_SENSOR_AMP_OFFSET 0x10
-#define RF22_REG_11_ADC_VALUE 0x11
-#define RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION 0x12
-#define RF22_REG_13_TEMPERATURE_VALUE_OFFSET 0x13
-#define RF22_REG_14_WAKEUP_TIMER_PERIOD1 0x14
-#define RF22_REG_15_WAKEUP_TIMER_PERIOD2 0x15
-#define RF22_REG_16_WAKEUP_TIMER_PERIOD3 0x16
-#define RF22_REG_17_WAKEUP_TIMER_VALUE1 0x17
-#define RF22_REG_18_WAKEUP_TIMER_VALUE2 0x18
-#define RF22_REG_19_LDC_MODE_DURATION 0x19
-#define RF22_REG_1A_LOW_BATTERY_DETECTOR_THRESHOLD 0x1a
-#define RF22_REG_1B_BATTERY_VOLTAGE_LEVEL 0x1b
-#define RF22_REG_1C_IF_FILTER_BANDWIDTH 0x1c
-#define RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE 0x1d
-#define RF22_REG_1E_AFC_TIMING_CONTROL 0x1e
-#define RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE 0x1f
-#define RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE 0x20
-#define RF22_REG_21_CLOCK_RECOVERY_OFFSET2 0x21
-#define RF22_REG_22_CLOCK_RECOVERY_OFFSET1 0x22
-#define RF22_REG_23_CLOCK_RECOVERY_OFFSET0 0x23
-#define RF22_REG_24_CLOCK_RECOVERY_TIMING_LOOP_GAIN1 0x24
-#define RF22_REG_25_CLOCK_RECOVERY_TIMING_LOOP_GAIN0 0x25
-#define RF22_REG_26_RSSI 0x26
-#define RF22_REG_27_RSSI_THRESHOLD 0x27
-#define RF22_REG_28_ANTENNA_DIVERSITY1 0x28
-#define RF22_REG_29_ANTENNA_DIVERSITY2 0x29
-#define RF22_REG_2A_AFC_LIMITER 0x2a
-#define RF22_REG_2B_AFC_CORRECTION_READ 0x2b
-#define RF22_REG_2C_OOK_COUNTER_VALUE_1 0x2c
-#define RF22_REG_2D_OOK_COUNTER_VALUE_2 0x2d
-#define RF22_REG_2E_SLICER_PEAK_HOLD 0x2e
-#define RF22_REG_30_DATA_ACCESS_CONTROL 0x30
-#define RF22_REG_31_EZMAC_STATUS 0x31
-#define RF22_REG_32_HEADER_CONTROL1 0x32
-#define RF22_REG_33_HEADER_CONTROL2 0x33
-#define RF22_REG_34_PREAMBLE_LENGTH 0x34
-#define RF22_REG_35_PREAMBLE_DETECTION_CONTROL1 0x35
-#define RF22_REG_36_SYNC_WORD3 0x36
-#define RF22_REG_37_SYNC_WORD2 0x37
-#define RF22_REG_38_SYNC_WORD1 0x38
-#define RF22_REG_39_SYNC_WORD0 0x39
-#define RF22_REG_3A_TRANSMIT_HEADER3 0x3a
-#define RF22_REG_3B_TRANSMIT_HEADER2 0x3b
-#define RF22_REG_3C_TRANSMIT_HEADER1 0x3c
-#define RF22_REG_3D_TRANSMIT_HEADER0 0x3d
-#define RF22_REG_3E_PACKET_LENGTH 0x3e
-#define RF22_REG_3F_CHECK_HEADER3 0x3f
-#define RF22_REG_40_CHECK_HEADER2 0x40
-#define RF22_REG_41_CHECK_HEADER1 0x41
-#define RF22_REG_42_CHECK_HEADER0 0x42
-#define RF22_REG_43_HEADER_ENABLE3 0x43
-#define RF22_REG_44_HEADER_ENABLE2 0x44
-#define RF22_REG_45_HEADER_ENABLE1 0x45
-#define RF22_REG_46_HEADER_ENABLE0 0x46
-#define RF22_REG_47_RECEIVED_HEADER3 0x47
-#define RF22_REG_48_RECEIVED_HEADER2 0x48
-#define RF22_REG_49_RECEIVED_HEADER1 0x49
-#define RF22_REG_4A_RECEIVED_HEADER0 0x4a
-#define RF22_REG_4B_RECEIVED_PACKET_LENGTH 0x4b
-#define RF22_REG_50_ANALOG_TEST_BUS_SELECT 0x50
-#define RF22_REG_51_DIGITAL_TEST_BUS_SELECT 0x51
-#define RF22_REG_52_TX_RAMP_CONTROL 0x52
-#define RF22_REG_53_PLL_TUNE_TIME 0x53
-#define RF22_REG_55_CALIBRATION_CONTROL 0x55
-#define RF22_REG_56_MODEM_TEST 0x56
-#define RF22_REG_57_CHARGE_PUMP_TEST 0x57
-#define RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING 0x58
-#define RF22_REG_59_DIVIDER_CURRENT_TRIMMING 0x59
-#define RF22_REG_5A_VCO_CURRENT_TRIMMING 0x5a
-#define RF22_REG_5B_VCO_CALIBRATION 0x5b
-#define RF22_REG_5C_SYNTHESIZER_TEST 0x5c
-#define RF22_REG_5D_BLOCK_ENABLE_OVERRIDE1 0x5d
-#define RF22_REG_5E_BLOCK_ENABLE_OVERRIDE2 0x5e
-#define RF22_REG_5F_BLOCK_ENABLE_OVERRIDE3 0x5f
-#define RF22_REG_60_CHANNEL_FILTER_COEFFICIENT_ADDRESS 0x60
-#define RF22_REG_61_CHANNEL_FILTER_COEFFICIENT_VALUE 0x61
-#define RF22_REG_62_CRYSTAL_OSCILLATOR_POR_CONTROL 0x62
-#define RF22_REG_63_RC_OSCILLATOR_COARSE_CALIBRATION 0x63
-#define RF22_REG_64_RC_OSCILLATOR_FINE_CALIBRATION 0x64
-#define RF22_REG_65_LDO_CONTROL_OVERRIDE 0x65
-#define RF22_REG_66_LDO_LEVEL_SETTINGS 0x66
-#define RF22_REG_67_DELTA_SIGMA_ADC_TUNING1 0x67
-#define RF22_REG_68_DELTA_SIGMA_ADC_TUNING2 0x68
-#define RF22_REG_69_AGC_OVERRIDE1 0x69
-#define RF22_REG_6A_AGC_OVERRIDE2 0x6a
-#define RF22_REG_6B_GFSK_FIR_FILTER_COEFFICIENT_ADDRESS 0x6b
-#define RF22_REG_6C_GFSK_FIR_FILTER_COEFFICIENT_VALUE 0x6c
-#define RF22_REG_6D_TX_POWER 0x6d
-#define RF22_REG_6E_TX_DATA_RATE1 0x6e
-#define RF22_REG_6F_TX_DATA_RATE0 0x6f
-#define RF22_REG_70_MODULATION_CONTROL1 0x70
-#define RF22_REG_71_MODULATION_CONTROL2 0x71
-#define RF22_REG_72_FREQUENCY_DEVIATION 0x72
-#define RF22_REG_73_FREQUENCY_OFFSET1 0x73
-#define RF22_REG_74_FREQUENCY_OFFSET2 0x74
-#define RF22_REG_75_FREQUENCY_BAND_SELECT 0x75
-#define RF22_REG_76_NOMINAL_CARRIER_FREQUENCY1 0x76
-#define RF22_REG_77_NOMINAL_CARRIER_FREQUENCY0 0x77
-#define RF22_REG_79_FREQUENCY_HOPPING_CHANNEL_SELECT 0x79
-#define RF22_REG_7A_FREQUENCY_HOPPING_STEP_SIZE 0x7a
-#define RF22_REG_7C_TX_FIFO_CONTROL1 0x7c
-#define RF22_REG_7D_TX_FIFO_CONTROL2 0x7d
-#define RF22_REG_7E_RX_FIFO_CONTROL 0x7e
-#define RF22_REG_7F_FIFO_ACCESS 0x7f
-
-// These register masks etc are named wherever possible
-// corresponding to the bit and field names in the RF-22 Manual
-// RF22_REG_00_DEVICE_TYPE 0x00
-#define RF22_DEVICE_TYPE_RX_TRX 0x08
-#define RF22_DEVICE_TYPE_TX 0x07
-
-// RF22_REG_02_DEVICE_STATUS 0x02
-#define RF22_FFOVL 0x80
-#define RF22_FFUNFL 0x40
-#define RF22_RXFFEM 0x20
-#define RF22_HEADERR 0x10
-#define RF22_FREQERR 0x08
-#define RF22_LOCKDET 0x04
-#define RF22_CPS 0x03
-#define RF22_CPS_IDLE 0x00
-#define RF22_CPS_RX 0x01
-#define RF22_CPS_TX 0x10
-
-// RF22_REG_03_INTERRUPT_STATUS1 0x03
-#define RF22_IFFERROR 0x80
-#define RF22_ITXFFAFULL 0x40
-#define RF22_ITXFFAEM 0x20
-#define RF22_IRXFFAFULL 0x10
-#define RF22_IEXT 0x08
-#define RF22_IPKSENT 0x04
-#define RF22_IPKVALID 0x02
-#define RF22_ICRCERROR 0x01
-
-// RF22_REG_04_INTERRUPT_STATUS2 0x04
-#define RF22_ISWDET 0x80
-#define RF22_IPREAVAL 0x40
-#define RF22_IPREAINVAL 0x20
-#define RF22_IRSSI 0x10
-#define RF22_IWUT 0x08
-#define RF22_ILBD 0x04
-#define RF22_ICHIPRDY 0x02
-#define RF22_IPOR 0x01
-
-// RF22_REG_05_INTERRUPT_ENABLE1 0x05
-#define RF22_ENFFERR 0x80
-#define RF22_ENTXFFAFULL 0x40
-#define RF22_ENTXFFAEM 0x20
-#define RF22_ENRXFFAFULL 0x10
-#define RF22_ENEXT 0x08
-#define RF22_ENPKSENT 0x04
-#define RF22_ENPKVALID 0x02
-#define RF22_ENCRCERROR 0x01
-
-// RF22_REG_06_INTERRUPT_ENABLE2 0x06
-#define RF22_ENSWDET 0x80
-#define RF22_ENPREAVAL 0x40
-#define RF22_ENPREAINVAL 0x20
-#define RF22_ENRSSI 0x10
-#define RF22_ENWUT 0x08
-#define RF22_ENLBDI 0x04
-#define RF22_ENCHIPRDY 0x02
-#define RF22_ENPOR 0x01
-
-// RF22_REG_07_OPERATING_MODE 0x07
-#define RF22_SWRES 0x80
-#define RF22_ENLBD 0x40
-#define RF22_ENWT 0x20
-#define RF22_X32KSEL 0x10
-#define RF22_TXON 0x08
-#define RF22_RXON 0x04
-#define RF22_PLLON 0x02
-#define RF22_XTON 0x01
-
-// RF22_REG_08_OPERATING_MODE2 0x08
-#define RF22_ANTDIV 0xc0
-#define RF22_RXMPK 0x10
-#define RF22_AUTOTX 0x08
-#define RF22_ENLDM 0x04
-#define RF22_FFCLRRX 0x02
-#define RF22_FFCLRTX 0x01
-
-// RF22_REG_0F_ADC_CONFIGURATION 0x0f
-#define RF22_ADCSTART 0x80
-#define RF22_ADCDONE 0x80
-#define RF22_ADCSEL 0x70
-#define RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR 0x00
-#define RF22_ADCSEL_GPIO0_SINGLE_ENDED 0x10
-#define RF22_ADCSEL_GPIO1_SINGLE_ENDED 0x20
-#define RF22_ADCSEL_GPIO2_SINGLE_ENDED 0x30
-#define RF22_ADCSEL_GPIO0_GPIO1_DIFFERENTIAL 0x40
-#define RF22_ADCSEL_GPIO1_GPIO2_DIFFERENTIAL 0x50
-#define RF22_ADCSEL_GPIO0_GPIO2_DIFFERENTIAL 0x60
-#define RF22_ADCSEL_GND 0x70
-#define RF22_ADCREF 0x0c
-#define RF22_ADCREF_BANDGAP_VOLTAGE 0x00
-#define RF22_ADCREF_VDD_ON_3 0x08
-#define RF22_ADCREF_VDD_ON_2 0x0c
-#define RF22_ADCGAIN 0x03
-
-// RF22_REG_10_ADC_SENSOR_AMP_OFFSET 0x10
-#define RF22_ADCOFFS 0x0f
-
-// RF22_REG_12_TEMPERATURE_SENSOR_CALIBRATION 0x12
-#define RF22_TSRANGE 0xc0
-#define RF22_TSRANGE_M64_64C 0x00
-#define RF22_TSRANGE_M64_192C 0x40
-#define RF22_TSRANGE_0_128C 0x80
-#define RF22_TSRANGE_M40_216F 0xc0
-#define RF22_ENTSOFFS 0x20
-#define RF22_ENTSTRIM 0x10
-#define RF22_TSTRIM 0x0f
-
-// RF22_REG_14_WAKEUP_TIMER_PERIOD1 0x14
-#define RF22_WTR 0x3c
-#define RF22_WTD 0x03
-
-// RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE 0x1d
-#define RF22_AFC_EN 0x40
-
-// Reg RF22_REG_1E_AFC_TIMING_CONTROL 0x1e
-#define RF22_AFC_TC 0x0a
-
-// Reg RF22_REG_2A_AFC_LIMITER 0x2a
-#define RF22_AFC_LIMIT 0x50
-
-// RF22_REG_30_DATA_ACCESS_CONTROL 0x30
-#define RF22_ENPACRX 0x80
-#define RF22_LSBFRST 0x40
-#define RF22_CRCDONLY 0x20
-#define RF22_ENPACTX 0x08
-#define RF22_ENCRC 0x04
-#define RF22_CRC 0x03
-#define RF22_CRC_CCITT 0x00
-#define RF22_CRC_CRC_16_IBM 0x01
-#define RF22_CRC_IEC_16 0x02
-#define RF22_CRC_BIACHEVA 0x03
-
-// RF22_REG_32_HEADER_CONTROL1 0x32
-#define RF22_BCEN 0xf0
-#define RF22_BCEN_NONE 0x00
-#define RF22_BCEN_HEADER0 0x10
-#define RF22_BCEN_HEADER1 0x20
-#define RF22_BCEN_HEADER2 0x40
-#define RF22_BCEN_HEADER3 0x80
-#define RF22_HDCH 0x0f
-#define RF22_HDCH_NONE 0x00
-#define RF22_HDCH_HEADER0 0x01
-#define RF22_HDCH_HEADER1 0x02
-#define RF22_HDCH_HEADER2 0x04
-#define RF22_HDCH_HEADER3 0x08
-
-// RF22_REG_33_HEADER_CONTROL2 0x33
-#define RF22_HDLEN 0x70
-#define RF22_HDLEN_0 0x00
-#define RF22_HDLEN_1 0x10
-#define RF22_HDLEN_2 0x20
-#define RF22_HDLEN_3 0x30
-#define RF22_HDLEN_4 0x40
-#define RF22_FIXPKLEN 0x08
-#define RF22_SYNCLEN 0x06
-#define RF22_SYNCLEN_1 0x00
-#define RF22_SYNCLEN_2 0x02
-#define RF22_SYNCLEN_3 0x04
-#define RF22_SYNCLEN_4 0x06
-#define RF22_PREALEN8 0x01
-
-// RF22_REG_6D_TX_POWER 0x6d
-#define RF22_TXPOW 0x07
-#define RF22_TXPOW_4X31 0x08 // Not used in RFM22B
-#define RF22_TXPOW_1DBM 0x00
-#define RF22_TXPOW_2DBM 0x01
-#define RF22_TXPOW_5DBM 0x02
-#define RF22_TXPOW_8DBM 0x03
-#define RF22_TXPOW_11DBM 0x04
-#define RF22_TXPOW_14DBM 0x05
-#define RF22_TXPOW_17DBM 0x06
-#define RF22_TXPOW_20DBM 0x07
-// IN RFM23B
-#define RF22_TXPOW_LNA_SW 0x08
-
-// RF22_REG_71_MODULATION_CONTROL2 0x71
-#define RF22_TRCLK 0xc0
-#define RF22_TRCLK_NONE 0x00
-#define RF22_TRCLK_GPIO 0x40
-#define RF22_TRCLK_SDO 0x80
-#define RF22_TRCLK_NIRQ 0xc0
-#define RF22_DTMOD 0x30
-#define RF22_DTMOD_DIRECT_GPIO 0x00
-#define RF22_DTMOD_DIRECT_SDI 0x10
-#define RF22_DTMOD_FIFO 0x20
-#define RF22_DTMOD_PN9 0x30
-#define RF22_ENINV 0x08
-#define RF22_FD8 0x04
-#define RF22_MODTYP 0x30
-#define RF22_MODTYP_UNMODULATED 0x00
-#define RF22_MODTYP_OOK 0x01
-#define RF22_MODTYP_FSK 0x02
-#define RF22_MODTYP_GFSK 0x03
-
-// RF22_REG_75_FREQUENCY_BAND_SELECT 0x75
-#define RF22_SBSEL 0x40
-#define RF22_HBSEL 0x20
-#define RF22_FB 0x1f
-
-/////////////////////////////////////////////////////////////////////
-/// \class RF22 RF22.h <RF22.h>
-/// \brief Send and receive unaddressed, unreliable datagrams.
-///
-/// This base class provides basic functions for sending and receiving unaddressed,
-/// unreliable datagrams of arbitrary length to 255 octets per packet.
-///
-/// Subclasses may use this class to implement reliable, addressed datagrams and streams,
-/// mesh routers, repeaters, translators etc.
-///
-/// On transmission, the TO and FROM addresses default to 0x00, unless changed by a subclass.
-/// On reception the TO addressed is checked against the node address (defaults to 0x00) or the
-/// broadcast address (which is 0xff). The ID and FLAGS are set to 0, and not checked by this class.
-/// This permits use of the this base RF22 class as an
-/// unaddresed, unreliable datagram service. Subclasses are expected to change this behaviour to
-/// add node address, ids, retransmission etc
-///
-/// Naturally, for any 2 radios to communicate that must be configured to use the same frequence and
-/// modulation scheme.
-class RF22
-{
-public:
-
- /// \brief Defines register values for a set of modem configuration registers
- ///
- /// Defines register values for a set of modem configuration registers
- /// that can be passed to setModemConfig()
- /// if none of the choices in ModemConfigChoice suit your need
- /// setModemConfig() writes the register values to the appropriate RF22 registers
- /// to set the desired modulation type, data rate and deviation/bandwidth.
- /// Suitable values for these registers can be computed using the register calculator at
- /// "http://www.hoperf.com/upfile/RF22B 23B 31B 42B 43B Register Settings_RevB1-v5.xls"
- typedef struct
- {
- uint8_t reg_1c; ///< Value for register RF22_REG_1C_IF_FILTER_BANDWIDTH
- uint8_t reg_1f; ///< Value for register RF22_REG_1F_CLOCK_RECOVERY_GEARSHIFT_OVERRIDE
- uint8_t reg_20; ///< Value for register RF22_REG_20_CLOCK_RECOVERY_OVERSAMPLING_RATE
- uint8_t reg_21; ///< Value for register RF22_REG_21_CLOCK_RECOVERY_OFFSET2
- uint8_t reg_22; ///< Value for register RF22_REG_22_CLOCK_RECOVERY_OFFSET1
- uint8_t reg_23; ///< Value for register RF22_REG_23_CLOCK_RECOVERY_OFFSET0
- uint8_t reg_24; ///< Value for register RF22_REG_24_CLOCK_RECOVERY_TIMING_LOOP_GAIN1
- uint8_t reg_25; ///< Value for register RF22_REG_25_CLOCK_RECOVERY_TIMING_LOOP_GAIN0
- uint8_t reg_2c; ///< Value for register RF22_REG_2C_OOK_COUNTER_VALUE_1
- uint8_t reg_2d; ///< Value for register RF22_REG_2D_OOK_COUNTER_VALUE_2
- uint8_t reg_2e; ///< Value for register RF22_REG_2E_SLICER_PEAK_HOLD
- uint8_t reg_58; ///< Value for register RF22_REG_58_CHARGE_PUMP_CURRENT_TRIMMING
- uint8_t reg_69; ///< Value for register RF22_REG_69_AGC_OVERRIDE1
- uint8_t reg_6e; ///< Value for register RF22_REG_6E_TX_DATA_RATE1
- uint8_t reg_6f; ///< Value for register RF22_REG_6F_TX_DATA_RATE0
- uint8_t reg_70; ///< Value for register RF22_REG_70_MODULATION_CONTROL1
- uint8_t reg_71; ///< Value for register RF22_REG_71_MODULATION_CONTROL2
- uint8_t reg_72; ///< Value for register RF22_REG_72_FREQUENCY_DEVIATION
- } ModemConfig;
-
- /// Choices for setModemConfig() for a selected subset of common modulation types,
- /// and data rates. If you need another configuration, use the register calculator at
- /// "http://www.hoperf.com/upfile/RF22B 23B 31B 42B 43B Register Settings_RevB1-v5.xls"
- /// and call setModemRegisters() with your desired settings
- /// These are indexes into _modemConfig
- typedef enum
- {
- UnmodulatedCarrier = 0, ///< Unmodulated carrier for testing
- FSK_PN9_Rb2Fd5, ///< FSK, No Manchester, Rb = 2kbs, Fd = 5kHz, PN9 random modulation for testing
-
- FSK_Rb2Fd5, ///< FSK, No Manchester, Rb = 2kbs, Fd = 5kHz
- FSK_Rb2_4Fd36, ///< FSK, No Manchester, Rb = 2.4kbs, Fd = 36kHz
- FSK_Rb4_8Fd45, ///< FSK, No Manchester, Rb = 4.8kbs, Fd = 45kHz
- FSK_Rb9_6Fd45, ///< FSK, No Manchester, Rb = 9.6kbs, Fd = 45kHz
- FSK_Rb19_2Fd9_6, ///< FSK, No Manchester, Rb = 19.2kbs, Fd = 9.6kHz
- FSK_Rb38_4Fd19_6, ///< FSK, No Manchester, Rb = 38.4kbs, Fd = 19.6kHz
- FSK_Rb57_6Fd28_8, ///< FSK, No Manchester, Rb = 57.6kbs, Fd = 28.8kHz
- FSK_Rb125Fd125, ///< FSK, No Manchester, Rb = 125kbs, Fd = 125kHz
-
- GFSK_Rb2Fd5, ///< GFSK, No Manchester, Rb = 2kbs, Fd = 5kHz
- GFSK_Rb2_4Fd36, ///< GFSK, No Manchester, Rb = 2.4kbs, Fd = 36kHz
- GFSK_Rb4_8Fd45, ///< GFSK, No Manchester, Rb = 4.8kbs, Fd = 45kHz
- GFSK_Rb9_6Fd45, ///< GFSK, No Manchester, Rb = 9.6kbs, Fd = 45kHz
- GFSK_Rb19_2Fd9_6, ///< GFSK, No Manchester, Rb = 19.2kbs, Fd = 9.6kHz
- GFSK_Rb38_4Fd19_6, ///< GFSK, No Manchester, Rb = 38.4kbs, Fd = 19.6kHz
- GFSK_Rb57_6Fd28_8, ///< GFSK, No Manchester, Rb = 57.6kbs, Fd = 28.8kHz
- GFSK_Rb125Fd125, ///< GFSK, No Manchester, Rb = 125kbs, Fd = 125kHz
-
- OOK_Rb1_2Bw75, ///< OOK, No Manchester, Rb = 1.2kbs, Rx Bandwidth = 75kHz
- OOK_Rb2_4Bw335, ///< OOK, No Manchester, Rb = 2.4kbs, Rx Bandwidth = 335kHz
- OOK_Rb4_8Bw335, ///< OOK, No Manchester, Rb = 4.8kbs, Rx Bandwidth = 335kHz
- OOK_Rb9_6Bw335, ///< OOK, No Manchester, Rb = 9.6kbs, Rx Bandwidth = 335kHz
- OOK_Rb19_2Bw335, ///< OOK, No Manchester, Rb = 19.2kbs, Rx Bandwidth = 335kHz
- OOK_Rb38_4Bw335, ///< OOK, No Manchester, Rb = 38.4kbs, Rx Bandwidth = 335kHz
- OOK_Rb40Bw335 ///< OOK, No Manchester, Rb = 40kbs, Rx Bandwidth = 335kHz
- } ModemConfigChoice;
-
- /// Constructor. You can have multiple instances, but each instance must have its own
- /// interrupt and slave select pin. After constructing, you must call init() to initialise the intnerface
- /// and the radio module
- /// \param[in] slaveSelectPin the Arduino pin number of the output to use to select the RF22 before
- /// accessing it
- /// \param[in] interrupt The interrupt number to use. Default is interrupt 0 (Arduino input pin 2)
- RF22(PinName slaveSelectPin , PinName mosi, PinName miso, PinName sclk, PinName interrupt );
-
- /// Initialises this instance and the radio module connected to it.
- /// The following steps are taken:
- /// - Initialise the slave select pin and the SPI interface library
- /// - Software reset the RF22 module
- /// - Checks the connected RF22 module is either a RF22_DEVICE_TYPE_RX_TRX or a RF22_DEVICE_TYPE_TX
- /// - Attaches an interrupt handler
- /// - Configures the RF22 module
- /// - Sets the frequncy to 434.0 MHz
- /// - Sets the modem data rate to FSK_Rb2_4Fd36
- /// \return true if everything was successful
- boolean init();
-
- /// Issues a software reset to the
- /// RF22 module. Blocks for 1ms to ensure the reset is complete.
- void reset();
-
- /// Reads a single register from the RF22
- /// \param[in] reg Register number, one of RF22_REG_*
- /// \return The value of the register
- uint8_t spiRead(uint8_t reg);
-
- /// Writes a single byte to the RF22
- /// \param[in] reg Register number, one of RF22_REG_*
- /// \param[in] val The value to write
- void spiWrite(uint8_t reg, uint8_t val);
-
- /// Reads a number of consecutive registers from the RF22 using burst read mode
- /// \param[in] reg Register number of the first register, one of RF22_REG_*
- /// \param[in] dest Array to write the register values to. Must be at least len bytes
- /// \param[in] len Number of bytes to read
- void spiBurstRead(uint8_t reg, uint8_t* dest, uint8_t len);
-
- /// Write a number of consecutive registers using burst write mode
- /// \param[in] reg Register number of the first register, one of RF22_REG_*
- /// \param[in] src Array of new register values to write. Must be at least len bytes
- /// \param[in] len Number of bytes to write
- void spiBurstWrite(uint8_t reg, uint8_t* src, uint8_t len);
-
- /// Reads and returns the device status register RF22_REG_02_DEVICE_STATUS
- /// \return The value of the device status register
- uint8_t statusRead();
-
- /// Reads a value from the on-chip analog-digital converter
- /// \param[in] adcsel Selects the ADC input to measure. One of RF22_ADCSEL_*. Defaults to the
- /// internal temperature sensor
- /// \param[in] adcref Specifies the refernce voltage to use. One of RF22_ADCREF_*.
- /// Defaults to the internal bandgap voltage.
- /// \param[in] adcgain Amplifier gain selection.
- /// \param[in] adcoffs Amplifier offseet (0 to 15).
- /// \return The analog value. 0 to 255.
- uint8_t adcRead(uint8_t adcsel = RF22_ADCSEL_INTERNAL_TEMPERATURE_SENSOR,
- uint8_t adcref = RF22_ADCREF_BANDGAP_VOLTAGE,
- uint8_t adcgain = 0,
- uint8_t adcoffs = 0);
-
- /// Reads the on-chip temperature sensoer
- /// \param[in] tsrange Specifies the temperature range to use. One of RF22_TSRANGE_*
- /// \param[in] tvoffs Specifies the temperature value offset. This is actually signed value
- /// added to the measured temperature value
- /// \return The measured temperature.
- uint8_t temperatureRead(uint8_t tsrange = RF22_TSRANGE_M64_64C, uint8_t tvoffs = 0);
-
- /// Reads the wakeup timer value in registers RF22_REG_17_WAKEUP_TIMER_VALUE1
- /// and RF22_REG_18_WAKEUP_TIMER_VALUE2
- /// \return The wakeup timer value
- uint16_t wutRead();
-
- /// Sets the wakeup timer period registers RF22_REG_14_WAKEUP_TIMER_PERIOD1,
- /// RF22_REG_15_WAKEUP_TIMER_PERIOD2 and RF22_REG_16_WAKEUP_TIMER_PERIOD3
- /// \param[in] wtm Wakeup timer mantissa value
- /// \param[in] wtr Wakeup timer exponent R value
- /// \param[in] wtd Wakeup timer exponent D value
- void setWutPeriod(uint16_t wtm, uint8_t wtr = 0, uint8_t wtd = 0);
-
- /// Sets the transmitter and receiver centre frequency
- /// \param[in] centre Frequency in MHz. 240.0 to 960.0. Caution, some versions of RF22 and derivatives
- /// implemented more restricted frequency ranges.
- /// \return true if the selected frquency centre + (fhch * fhs) is within range
- boolean setFrequency(float centre);
-
- /// Sets the frequency hopping step size.
- /// \param[in] fhs Frequency Hopping step size in 10kHz increments
- /// \return true if centre + (fhch * fhs) is within limits
- boolean setFHStepSize(uint8_t fhs);
-
- /// Sets the frequncy hopping channel. Adds fhch * fhs to centre frequency
- /// \param[in] fhch The channel number
- /// \return true if the selected frquency centre + (fhch * fhs) is within range
- boolean setFHChannel(uint8_t fhch);
-
- /// Reads and returns the current RSSI value from register RF22_REG_26_RSSI
- /// \return The current RSSI value
- uint8_t rssiRead();
-
- /// Reads and returns the current EZMAC value from register RF22_REG_31_EZMAC_STATUS
- /// \return The current EZMAC value
- uint8_t ezmacStatusRead();
-
- /// Sets the parameters for the RF22 Idle mode in register RF22_REG_07_OPERATING_MODE.
- /// Idle mode is the mode the RF22 wil be in when not transmitting or receiving. The default idle mode
- /// is RF22_XTON ie READY mode.
- /// \param[in] mode MAsk of mode bits, using RF22_SWRES, RF22_ENLBD, RF22_ENWT,
- /// RF22_X32KSEL, RF22_PLLON, RF22_XTON.
- void setMode(uint8_t mode);
-
- /// If current mode is Rx or Tx changes it to Idle. If the transmitter or receiver is running,
- /// disables them.
- void setModeIdle();
-
- /// If current mode is Tx or Idle, changes it to Rx.
- /// Starts the receiver in the RF22.
- void setModeRx();
-
- /// If current mode is Rx or Idle, changes it to Rx.
- /// Starts the transmitter in the RF22.
- void setModeTx();
-
- /// Sets the transmitter power output level in register RF22_REG_6D_TX_POWER.
- /// Be a good neighbour and set the lowest power level you need.
- /// After init(), the power wil be set to RF22_TXPOW_8DBM.
- /// Caution: In some countries you may only select RF22_TXPOW_17DBM if you
- /// are also using frequency hopping.
- /// \param[in] power Transmitter power level, one of RF22_TXPOW_*
- void setTxPower(uint8_t power);
-
- /// Sets all the registered required to configure the data modem in the RF22, including the data rate,
- /// bandwidths etc. You cas use this to configure the modem with custom configuraitons if none of the
- /// canned configurations in ModemConfigChoice suit you.
- /// \param[in] config A ModemConfig structure containing values for the modem configuration registers.
- void setModemRegisters(ModemConfig* config);
-
- /// Select one of the predefined modem configurations. If you need a modem configuration not provided
- /// here, use setModemRegisters() with your own ModemConfig.
- /// \param[in] index The configuration choice.
- /// \return true if index is a valid choice.
- boolean setModemConfig(ModemConfigChoice index);
-
- /// Starts the receiver and checks whether a received message is available.
- /// This can be called multiple times in a timeout loop
- /// \return true if a complete, valid message has been received and is able to be retrieved by
- /// recv()
- boolean available();
-
- /// Starts the receiver and blocks until a valid received
- /// message is available.
- void waitAvailable();
-
- /// Starts the receiver and blocks until a received message is available or a timeout
- /// \param[in] timeout Maximum time to wait in milliseconds.
- /// \return true if a message is available
- bool waitAvailableTimeout(uint16_t timeout);
-
- /// Turns the receiver on if it not already on.
- /// If there is a valid message available, copy it to buf and return true
- /// else return false.
- /// If a message is copied, *len is set to the length (Caution, 0 length messages are permitted).
- /// You should be sure to call this function frequently enough to not miss any messages
- /// It is recommended that you call it in your main loop.
- /// \param[in] buf Location to copy the received message
- /// \param[in,out] len Pointer to available space in buf. Set to the actual number of octets copied.
- /// \return true if a valid message was copied to buf
- boolean recv(uint8_t* buf, uint8_t* len);
-
- /// Loads a message into the transmitter and starts the transmitter. Note that a message length
- /// of 0 is permitted, in which case data may be NULL.
- /// \param[in] data Array of data to be sent
- /// \param[in] len Number of bytes of data to send.
- /// \return true
- boolean send(uint8_t* data, uint8_t len);
-
- /// Blocks until the current message
- /// (if any) has been completely sent
- void waitPacketSent();
-
- /// Tells the receiver to accept messages with any TO address, not just messages
- /// addressed to this node or the broadcast address
- /// \param[in] promiscuous true if you wish to receive messages with any TO address
- void setPromiscuous(boolean promiscuous);
-
- /// Returns the TO header of the last received message
- /// \return The TO header
- uint8_t headerTo();
-
- /// Returns the FROM header of the last received message
- /// \return The FROM header
- /// \return
- uint8_t headerFrom();
-
- /// Returns the ID header of the last received message
- /// \return The ID header
- /// \return
- uint8_t headerId();
-
- /// Returns the FLAGS header of the last received message
- /// \return The FLAGS header
- /// \return
- uint8_t headerFlags();
-
- /// Returns the RSSI (Receiver Signal Strength Indicator)
- /// of the last received message. This measurement is taken when
- /// the preamble has been received. It is a (non-linear) measure of the received signal strength.
- /// \return The RSSI
- uint8_t lastRssi();
-
-protected:
- /// Sets the message preamble length in RF22_REG_34_PREAMBLE_LENGTH
- /// \param[in] nibbles Preamble length in nibbles of 4 bits each.
- void setPreambleLength(uint8_t nibbles);
-
- /// Sets the sync words for transmit and receive in registers RF22_REG_36_SYNC_WORD3
- /// to RF22_REG_39_SYNC_WORD0
- /// \param[in] syncWords Array of sync words
- /// \param[in] len Number of sync words to set
- void setSyncWords(uint8_t* syncWords, uint8_t len);
-
- /// This is a low level function to handle the interrupts for one instance of RF22.
- /// Called automatically by isr0() and isr1()
- /// Should not need to be called.
- void handleInterrupt();
-
- /// Clears the receiver buffer.
- /// Internal use only
- void clearRxBuf();
-
- /// Clears the transmitter buffer
- /// Internal use only
- void clearTxBuf();
-
- /// Fills the transmitter buffer with the data of a mesage to be sent
- /// \param[in] data Array of data bytes to be sent (0 to 255)
- /// \param[in] len Number of data bytes in data
- /// \return true
- boolean fillTxBuf(uint8_t* data, uint8_t len);
-
- /// Appends the transmitter buffer with the data of a mesage to be sent
- /// \param[in] data Array of data bytes to be sent (0 to 255)
- /// \param[in] len Number of data bytes in data
- /// \return false if the resulting message would exceed RF22_MAX_MESSAGE_LEN, else true
- boolean appendTxBuf(uint8_t* data, uint8_t len);
-
- /// Internal function to load the next fragment of
- /// the current message into the transmitter FIFO
- /// Internal use only
- void sendNextFragment();
-
- /// function to copy the next fragment from
- /// the receiver FIF) into the receiver buffer
- void readNextFragment();
-
- /// Clears the RF22 Rx and Tx FIFOs
- /// Internal use only
- void resetFifos();
-
- /// Clears the RF22 Rx FIFO
- /// Internal use only
- void resetRxFifo();
-
- /// Clears the RF22 Tx FIFO
- /// Internal use only
- void resetTxFifo();
-
- /// This function will be called by handleInterrupt() if an RF22 external interrupt occurs.
- /// This can only happen if external interrupts are enabled in the RF22
- /// (which they are not by default).
- /// Subclasses may override this function to get control when an RF22 external interrupt occurs.
- virtual void handleExternalInterrupt();
-
- /// This function will be called by handleInterrupt() if an RF22 wakeup timer interrupt occurs.
- /// This can only happen if wakeup timer interrupts are enabled in the RF22
- /// (which they are not by default).
- /// Subclasses may override this function to get control when an RF22 wakeup timer interrupt occurs.
- virtual void handleWakeupTimerInterrupt();
-
- /// Sets the TO header to be sent in all subsequent messages
- /// \param[in] to The new TO header value
- void setHeaderTo(uint8_t to);
-
- /// Sets the FROM header to be sent in all subsequent messages
- /// \param[in] from The new FROM header value
- void setHeaderFrom(uint8_t from);
-
- /// Sets the ID header to be sent in all subsequent messages
- /// \param[in] id The new ID header value
- void setHeaderId(uint8_t id);
-
- /// Sets the FLAGS header to be sent in all subsequent messages
- /// \param[in] flags The new FLAGS header value
- void setHeaderFlags(uint8_t flags);
-
- /// Start the transmission of the contents
- /// of the Tx buffer
- void startTransmit();
-
- /// ReStart the transmission of the contents
- /// of the Tx buffer after a atransmission failure
- void restartTransmit();
-
-//private:
- /// Low level interrupt service routine for RF22 connected to interrupt 0
- //static void isr0();
- void isr0();
-
- /// Low level interrupt service routine for RF22 connected to interrupt 1
- //static void isr1();
-private:
- /// Array of instances connected to interrupts 0 and 1
- //static RF22* _RF22ForInterrupt[];
-
-
- uint8_t _mode; // One of RF22_MODE_*
-
- uint8_t _idleMode;
- DigitalOut _slaveSelectPin;
- SPI _spi;
- InterruptIn _interrupt;
- uint8_t _deviceType;
-
- DigitalOut led1;
- DigitalOut led2;
- DigitalOut led3;
- DigitalOut led4;
-
- // These volatile members may get changed in the interrupt service routine
- uint8_t _buf[RF22_MAX_MESSAGE_LEN];
- volatile uint8_t _bufLen;
-
- volatile boolean _rxBufValid;
-
- volatile boolean _txPacketSent;
- volatile uint8_t _txBufSentIndex;
-
- volatile uint16_t _rxBad;
- volatile uint16_t _rxGood;
- volatile uint16_t _txGood;
-
- volatile uint8_t _lastRssi;
-
-};
-
-
-#endif
--- a/TextLCD.lib Wed Jan 18 20:09:21 2012 +0000 +++ b/TextLCD.lib Tue Aug 20 20:22:43 2013 +0000 @@ -1,1 +1,1 @@ -http://mbed.org/users/benyun/libraries/TextLCD/lvao0n \ No newline at end of file +http://mbed.org/users/benyun/code/TextLCD/#7dd9751172e1
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TextLCDScroll.lib Tue Aug 20 20:22:43 2013 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/charly/code/TextLCDScroll/#e3b565c4190c
--- a/mRotaryEncoder.lib Wed Jan 18 20:09:21 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1 +0,0 @@ -http://mbed.org/users/charly/libraries/mRotaryEncoder/lmcj2u \ No newline at end of file
--- a/main.cpp Wed Jan 18 20:09:21 2012 +0000
+++ b/main.cpp Tue Aug 20 20:22:43 2013 +0000
@@ -1,434 +1,432 @@
-
-// Test code used during library development, showing how
-// to do various things, and how to call various functions
-// ported to mbed by Karl Zweimueller
+// Testprogramm for RFM22B with RF22-Library to read ELV MAX! window Shutter-Contacts
#include "mbed.h"
+#include <RF22.h>
-#include <RF22.h>
-#include "TextLCD.h"
-#include "mRotaryEncoder.h"
+#include "TextLCDScroll.h"
+
+
+#define lengthof(x) (sizeof(x) / sizeof(*x))
Serial pc(USBTX, USBRX);
-TextLCD lcd(p30, p29, p28, p27, p26, p25, TextLCD::LCD16x2); // rs, e, d4-d7
-
-//mRotaryEncoder(PinName pinA, PinName pinB, PinName pinSW, PinMode pullMode=PullUp, int debounceTime_us=1500)
-mRotaryEncoder wheel(p21, p22, p23, PullUp, 1500);
-
-volatile bool enc_pressed = false; // Button of rotaryencoder was pressed
-volatile bool enc_rotated = false; // rotary encoder was totaded left or right
+//TextLCDScroll lcd(p30, p29, p28, p27, p26, p25, TextLCD::LCD16x2); // rs, e, d4-d7
+TextLCDScroll lcd(p30, p29, p28, p27, p26, p25, TextLCD::LCD16x2); // rs, e, d4-d7
// mbed LEDs
-//DigitalOut led1(LED1);
-//DigitalOut led2(LED2);
-//DigitalOut led3(LED3);
-//DigitalOut led4(LED4);
+DigitalOut led1(LED1);
+DigitalOut led2(LED2);
+DigitalOut led3(LED3);
+DigitalOut led4(LED4);
// Singleton instance of the radio
//rf22(PinName slaveSelectPin , PinName mosi, PinName miso, PinName sclk, PinName interrupt );
RF22 rf22(p14,p11,p12,p13,p15);
-int counter = 1;
-float frequence = 869.50; // frequence for sender
-const float f_offset = -0.01; // frequence-offset for receiver
+const RF22::ModemConfig config = { // for MAX! protocol
+ .reg_1c = 0x01,
+ .reg_1f = 0x03,
+ .reg_20 = 0x90,
+ .reg_21 = 0x20,
+ .reg_22 = 0x51,
+ .reg_23 = 0xea,
+ .reg_24 = 0x00,
+ .reg_25 = 0x58,
+ /* 2c - 2e are only for OOK */
+ .reg_2c = 0x00,
+ .reg_2d = 0x00,
+ .reg_2e = 0x00,
+ .reg_58 = 0x80, /* Copied from RF22 defaults */
+ .reg_69 = 0x60, /* Copied from RF22 defaults */
+ .reg_6e = 0x08,
+ .reg_6f = 0x31,
+ .reg_70 = 0x24,
+ .reg_71 = RF22_DTMOD_FIFO | RF22_MODTYP_FSK,
+ .reg_72 = 0x1e,
+};
+
+/* Sync words to send / check for. Don't forget to update RF22_SYNCLEN
+* below if changing the length of this array. */
+const uint8_t sync_words[] = {
+ 0xc6,
+ 0x26,
+ 0xc6,
+ 0x26,
+};
+
+enum modes {MODE_AUTO, MODE_MANUAL, MODE_TEMPORARY, MODE_BOOST};
+const char *mode_str[] = {
+ [MODE_AUTO] = "auto",
+ [MODE_MANUAL] = "manual",
+ [MODE_TEMPORARY] = "temporary",
+ [MODE_BOOST] = "boost"
+};
-
-//interrup-Handler for button on rotary-encoder - no function
-void trigger_sw() {
- enc_pressed = true; // just set the flag, rest is done outside isr
+char *type_str(uint8_t type)
+{
+ switch(type) {
+ case 0x00:
+ return "PairPing";
+ case 0x01:
+ return "PairPong";
+ case 0x02:
+ return "Ack";
+ case 0x03:
+ return "TimeInformation";
+ case 0x10:
+ return "ConfigWeekProfile";
+ case 0x11:
+ return "ConfigTemperatures";
+ case 0x12:
+ return "ConfigValve";
+ case 0x20:
+ return "AddLinkPartner";
+ case 0x21:
+ return "RemoveLinkPartner";
+ case 0x22:
+ return "SetGroupId";
+ case 0x23:
+ return "RemoveGroupId";
+ case 0x30:
+ return "ShutterContactState";
+ case 0x40:
+ return "SetTemperature";
+ case 0x42:
+ return "WallThermostatState";
+ case 0x43:
+ return "SetComfortTemperature";
+ case 0x44:
+ return "SetEcoTemperature";
+ case 0x50:
+ return "PushButtonState";
+ case 0x60:
+ return "ThermostatState";
+ case 0x82:
+ return "SetDisplayActualTemperature";
+ case 0xF1:
+ return "WakeUp";
+ case 0xF0:
+ return "Reset";
+ }
+ return "Unknown";
}
-//interrup-Handler for rotary-encoder rotation - change frequence
-void trigger_rotated() {
- frequence = wheel.Get()/1000.0;
- lcd.locate(0,1);
- lcd.printf("%4.3fMHz ",frequence);
- if (!rf22.setFrequency(frequence)) // set the new frequence
- pc.printf("setFrequency failed");
-}
+
+/* First 255 bytes of PN9 sequence used for data whitening by the CC1101
+* chip. The RF22 chip is documented to support the same data whitening
+* algorithm, but in practice seems to use a different sequence.
+*
+* Data was generated using the following python snippet:
+*
+import itertools
+def pn9(state):
+ while True:
+ yield hex(state & 0xff)
+ # The pn9 generator is clocked 8 times while shifting in the
+ # next data byte
+ for i in range(8):
+ state = (state >> 1) + (((state & 1) ^ (state >> 5) & 1) << 8)
+print(list(itertools.islice(pn9(0x1ff), 255)))
+*/
-void setup() {
+const uint8_t pn9[] = {
+ 0xff, 0xe1, 0x1d, 0x9a, 0xed, 0x85, 0x33, 0x24,
+ 0xea, 0x7a, 0xd2, 0x39, 0x70, 0x97, 0x57, 0x0a,
+ 0x54, 0x7d, 0x2d, 0xd8, 0x6d, 0x0d, 0xba, 0x8f,
+ 0x67, 0x59, 0xc7, 0xa2, 0xbf, 0x34, 0xca, 0x18,
+ 0x30, 0x53, 0x93, 0xdf, 0x92, 0xec, 0xa7, 0x15,
+ 0x8a, 0xdc, 0xf4, 0x86, 0x55, 0x4e, 0x18, 0x21,
+ 0x40, 0xc4, 0xc4, 0xd5, 0xc6, 0x91, 0x8a, 0xcd,
+ 0xe7, 0xd1, 0x4e, 0x09, 0x32, 0x17, 0xdf, 0x83,
+ 0xff, 0xf0, 0x0e, 0xcd, 0xf6, 0xc2, 0x19, 0x12,
+ 0x75, 0x3d, 0xe9, 0x1c, 0xb8, 0xcb, 0x2b, 0x05,
+ 0xaa, 0xbe, 0x16, 0xec, 0xb6, 0x06, 0xdd, 0xc7,
+ 0xb3, 0xac, 0x63, 0xd1, 0x5f, 0x1a, 0x65, 0x0c,
+ 0x98, 0xa9, 0xc9, 0x6f, 0x49, 0xf6, 0xd3, 0x0a,
+ 0x45, 0x6e, 0x7a, 0xc3, 0x2a, 0x27, 0x8c, 0x10,
+ 0x20, 0x62, 0xe2, 0x6a, 0xe3, 0x48, 0xc5, 0xe6,
+ 0xf3, 0x68, 0xa7, 0x04, 0x99, 0x8b, 0xef, 0xc1,
+ 0x7f, 0x78, 0x87, 0x66, 0x7b, 0xe1, 0x0c, 0x89,
+ 0xba, 0x9e, 0x74, 0x0e, 0xdc, 0xe5, 0x95, 0x02,
+ 0x55, 0x5f, 0x0b, 0x76, 0x5b, 0x83, 0xee, 0xe3,
+ 0x59, 0xd6, 0xb1, 0xe8, 0x2f, 0x8d, 0x32, 0x06,
+ 0xcc, 0xd4, 0xe4, 0xb7, 0x24, 0xfb, 0x69, 0x85,
+ 0x22, 0x37, 0xbd, 0x61, 0x95, 0x13, 0x46, 0x08,
+ 0x10, 0x31, 0x71, 0xb5, 0x71, 0xa4, 0x62, 0xf3,
+ 0x79, 0xb4, 0x53, 0x82, 0xcc, 0xc5, 0xf7, 0xe0,
+ 0x3f, 0xbc, 0x43, 0xb3, 0xbd, 0x70, 0x86, 0x44,
+ 0x5d, 0x4f, 0x3a, 0x07, 0xee, 0xf2, 0x4a, 0x81,
+ 0xaa, 0xaf, 0x05, 0xbb, 0xad, 0x41, 0xf7, 0xf1,
+ 0x2c, 0xeb, 0x58, 0xf4, 0x97, 0x46, 0x19, 0x03,
+ 0x66, 0x6a, 0xf2, 0x5b, 0x92, 0xfd, 0xb4, 0x42,
+ 0x91, 0x9b, 0xde, 0xb0, 0xca, 0x09, 0x23, 0x04,
+ 0x88, 0x98, 0xb8, 0xda, 0x38, 0x52, 0xb1, 0xf9,
+ 0x3c, 0xda, 0x29, 0x41, 0xe6, 0xe2, 0x7b
+};
- if (!rf22.init())
- pc.printf("RF22 init failed\n\r");
+/**
+* CRC code based on example from Texas Instruments DN502, matches
+* CC1101 implementation
+*/
+#define CRC16_POLY 0x8005
+uint16_t calc_crc_step(uint8_t crcData, uint16_t crcReg)
+{
+ uint8_t i;
+ for (i = 0; i < 8; i++) {
+ if (((crcReg & 0x8000) >> 8) ^ (crcData & 0x80))
+ crcReg = (crcReg << 1) ^ CRC16_POLY;
+ else
+ crcReg = (crcReg << 1);
+ crcData <<= 1;
+ }
+ return crcReg;
+} // culCalcCRC
+
+#define CRC_INIT 0xFFFF
+uint16_t calc_crc(uint8_t *buf, size_t len)
+{
+ uint16_t checksum;
+ checksum = CRC_INIT;
+ // Init value for CRC calculation
+ for (size_t i = 0; i < len; i++)
+ checksum = calc_crc_step(buf[i], checksum);
+ return checksum;
}
-void
-test_read_write() {
- uint8_t val;
- rf22.spiWrite(RF22_REG_42_CHECK_HEADER0, 10);
- val = rf22.spiRead(RF22_REG_42_CHECK_HEADER0);
- pc.printf("%n\r\n",val);
+void printHex(uint8_t *buf, size_t len, bool nl)
+{
+ for (size_t i = 0; i < len; i++) {
+ pc.printf("%02X ",buf[i]);
+ }
+ if (nl)
+ pc.printf("\n\r");
+}
+
+void printUntil(uint8_t *buf)
+{
+ uint8_t year = buf[1] & 0x3f;
+ uint8_t month = ((buf[0] & 0xE0) >> 4) | (buf[1] >> 7);
+ uint8_t day = buf[0] & 0x1f;
+ /* In 30-minute increments */
+ uint8_t time = buf[2] & 0x3f;
- rf22.spiWrite(RF22_REG_42_CHECK_HEADER0, 5);
- val = rf22.spiRead(RF22_REG_42_CHECK_HEADER0);
- pc.printf("%n\r\n", val);
- pc.printf("-----");
+ pc.printf("Until: 20");
+ if (year < 10) pc.printf("0");
+ pc.printf("%i",year);
+ pc.printf(".");
+ if (month < 10) pc.printf("0");
+ pc.printf("%i",month);
+ pc.printf(".");
+ if (day < 10) pc.printf("0");
+ pc.printf("%i",day);
+ pc.printf(" ");
+ if (time < 20) pc.printf("0");
+ pc.printf("%i",time / 2);
+ if (time % 2)
+ pc.printf(":30");
+ else
+ pc.printf(":00");
+ pc.printf("\n\r");
}
-void
-test_adc() {
- uint8_t val = rf22.adcRead(RF22_ADCSEL_GND);
- pc.printf("%n\r\n", val);
-}
+
+void max_rx_loop()
+{
+ uint8_t buf[RF22_MAX_MESSAGE_LEN];
+ uint8_t len = sizeof(buf);
+
+ if (rf22.recv(buf, &len)) {
+ pc.printf("Recv: ");
+ pc.printf("len: %i\n\r",len);
+ len = 30; // limit message to 30 Bytes as device receives all 255 Bytes
+
+ //pc.printf("buf: >%s<\n\r",(char*)buf);
+ printHex(buf, len, true);
+
+ /* Dewhiten data */
+ for (int i = 0; i < len; i++)
+ buf[i] ^= pn9[i];
+
+ // now read the real length
+ len = buf[0]+3; // 1 length-Byte + 2 CRC
+ pc.printf("len: %i\n\r",len);
+
+ if (len < 3 || len > lengthof(pn9)) {
+ pc.printf("Packet length too short/long (%i)\n\r",len);
+ return;
+ }
+ pc.printf("dewhiten: ");
+ printHex(buf, len, true);
+
+ /* Calculate CRC (but don't include the CRC itself) */
+ uint16_t crc = calc_crc(buf, len - 2);
+ if (buf[len - 1] != (crc & 0xff) || buf[len - 2] != (crc >> 8)) {
+ pc.printf("CRC error\n\r");
+ return;
+ }
+
+ /* Don't use the CRC as data */
+ len -= 2;
+
+ uint8_t type = buf[3];
+#if 1
+ pc.printf("Message count: ");
+ printHex(buf + 1, 1, true);
+ pc.printf("Flags: ");
+ printHex(buf + 2, 1, true);
+ pc.printf("Packet type: ");
+ printHex(&type, 1, false);
+ pc.printf(" (");
+ pc.printf(type_str(type));
+ pc.printf(")\n\r");
+ pc.printf("Packet from: ");
+ printHex(buf + 4, 3, true);
+ pc.printf("Packet to: ");
+ printHex(buf + 7, 3, true);
+ pc.printf("GroupID: ");
+ printHex(buf + 10, 1, true);
+ pc.printf("Payload: ");
+ printHex(buf + 11, len-11, true);
-void test_temp() {
- float val = rf22.temperatureRead();
- pc.printf("%3.1f\r\n", (val/2)-64);
-}
+ if (type == 0x30 && len >= 11) { //ShutterContactState
+ bool baterry_low = (buf[11] >> 7) & 0x1;
+ bool state = (buf[11]>>1) & 0x1;
+ pc.printf("State: ");
+ if (state) {
+ pc.printf("open\n\r");
+ lcd.setLine(1,"open ");
+ } else {
+ pc.printf("closed\n\r");
+ lcd.setLine(1,"closed ");
+ }
+ pc.printf("Battery: ");
+ if (baterry_low) {
+ pc.printf("low\n\r");
+ } else {
+ pc.printf("good\n\r");
+ }
+
+ }
+
+ /*
+ else if (type == 0x60 && len >= 13) { // ThermostatState
+ uint8_t mode = buf[11] & 0x3;
+ bool dst = (buf[11] >> 2) & 0x1;
+ bool locked = (buf[11] >> 5) & 0x1;
+ bool baterry_low = (buf[11] >> 7) & 0x1;
+ // 0 - 64
+ uint8_t valve = buf[12];
+ uint8_t set_temp = buf[13];
+
+ pc.printf("Mode: ");
+ pc.printf(mode_str[mode]);
+
+ pc.printf("Valve pos: %i%",100 * valve / 64);
+
+ pc.printf("Set temp: %2.1i",set_temp / 2);
-void
-test_burst_read() {
- uint8_t buf[127];
- rf22.spiBurstRead(0, buf, sizeof(buf));
- uint8_t i;
- for (i = 0; i < 127; i++) {
- pc.printf("%x : %x\n\r",i,buf[i]);
+ if (len > 15 && mode != MODE_TEMPORARY) {
+ // In tenths of degrees
+ uint8_t actual_temp = ((buf[14] & 0x1) << 8) + buf[15];
+ pc.printf("Actual temp: ");
+ pc.printf(actual_temp / 10);
+ pc.printf(".");
+ pc.printf(actual_temp % 10);
+ }
+ if (len > 16 && mode == MODE_TEMPORARY) {
+ printUntil(buf + 14);
+ }
+ } else if (type == 0x40 && len >= 11) { // SetTemperature
+ uint8_t set_temp = buf[11] & 0x3f;
+ uint8_t mode = buf[11] >> 6;
+
+ pc.printf("Mode: ");
+ pc.printf(mode_str[mode]);
+
+ pc.print("Set temp: ");
+ pc.printf(set_temp / 2);
+ pc.printf(set_temp % 2 ? ".5" : ".0");
+ if (len > 14) {
+ printUntil(buf + 12);
+ }
+ }
+
+ // Print the data
+ int i, j;
+ for (i = 0; i < len; i += 16) {
+ // Hex
+ for (j = 0; j < 16 && i+j < len; j++) {
+ if (buf[i+j] < 16)
+ pc.print("0"); // Sigh, pc.print does not know how to pad hex
+ pc.print(buf[i+j], HEX);
+ pc.print(" ");
+ }
+ // Padding on last block
+ while (j++ < 16)
+ pc.print(" ");
+
+ pc.print(" ");
+ // ASCII
+ for (j = 0; j < 16 && i+j < len; j++)
+ pc.write(isprint(buf[i+j]) ? buf[i+j] : '.');
+ pc.println("");
+ }
+ */
+ pc.printf("\n\r");
+#endif
}
}
-void test_burst_write() {
- uint8_t buf[] = "Hello";
- rf22.spiBurstWrite(RF22_REG_7F_FIFO_ACCESS, buf, sizeof(buf));
-}
-
-void
-test_wut() {
- pc.printf("WUT Start");
- rf22.setWutPeriod(10000); // 10000, 0, 0 -> 1 secs
- rf22.spiWrite(RF22_REG_07_OPERATING_MODE1, RF22_ENWT);
- // Wait for the interrupt to occur
- while (1) {
- uint8_t val = rf22.spiRead(RF22_REG_04_INTERRUPT_STATUS2);
- if (val & RF22_IWUT)
- break;
- }
- rf22.spiWrite(RF22_REG_07_OPERATING_MODE1, 0);
-
- pc.printf("WUT Interrupt bit detected OK");
-}
-
-void
-test_set_frequency() {
- if (!rf22.setFHStepSize(0))
- pc.printf("setFHStepSize 1 Fail");
- if (!rf22.setFHChannel(0))
- pc.printf("setFHChannel 1 Fail");
- if (!rf22.setFrequency(434.0))
- pc.printf("setFrequency 1 Fail");
- if (!rf22.setFrequency(240.0))
- pc.printf("setFrequency 2 Fail");
- if (!rf22.setFrequency(929.9999)) // Higher than this produces FREQERR on my 06 silicon
- pc.printf("setFrequency 3 Fail");
- if (rf22.setFrequency(960.1)) // Should fail
- pc.printf("setFrequency 4 Fail");
-
- pc.printf("-------------");
-}
-
-void
-test_rssi() {
- rf22.setModeRx();
- pc.printf("Start\n\r");
- float f = 848.0;
- while (f < 888.0) {
- rf22.setFrequency(f);
- wait_ms(200); // Wait for freq to settle
- uint8_t rssi = rf22.rssiRead();
-
- pc.printf("%f: %i\n\r",f,rssi);
- f += 1.0;
- }
- pc.printf("End\n\r");
- rf22.setModeIdle();
- pc.printf("\n\r-------------\n\r");
-}
-
-// Sends 0.5 secs of PN9 modulated with with GFSK at full power
-void test_tx_pn9() {
- rf22.setFrequency(434.0);
- rf22.setTxPower(RF22_TXPOW_17DBM);
- rf22.setModeRx();
- // Takes a little while to start
- wait(1);
- pc.printf("%x \n\r",rf22.statusRead());
- rf22.setModemConfig(RF22::FSK_PN9_Rb2Fd5);
-// rf22.setModemConfig(RF22::UnmodulatedCarrier);
- rf22.setModeTx(); // Turns off Rx
- // Takes a little while to start
- wait(1);
- pc.printf("%x \n\r",rf22.statusRead());
- wait_ms(500);
- rf22.setModeIdle();
- // Takes a little while to turn off the transmitter
- wait_ms(10);
- pc.printf("%x \n\r",rf22.statusRead());
- pc.printf("-------------");
- wait_ms(500);
-}
-
-// Connect analog test points to GPIO1 and GPIO2
-void test_analog_gpio() {
- rf22.setFrequency(434.0);
- rf22.setModeRx();
- // GPIO1 for Test N output
- rf22.spiWrite(RF22_REG_0C_GPIO_CONFIGURATION1, 0x0c);
- // GPIO2 for Test P output
- rf22.spiWrite(RF22_REG_0D_GPIO_CONFIGURATION2, 0x0d);
- rf22.spiWrite(RF22_REG_50_ANALOG_TEST_BUS_SELECT, 15); // Detector?
- while (1);
-}
-
-void test_modem_config() {
- if (rf22.setModemConfig((RF22::ModemConfigChoice)255)) // Should fail
- pc.printf("setModemConfig 1 failed");
- if (!rf22.setModemConfig(RF22::FSK_Rb2Fd5))
- pc.printf("setModemConfig 2 failed");
- if (!rf22.setModemConfig(RF22::FSK_Rb2_4Fd36))
- pc.printf("setModemConfig 3 failed");
- if (!rf22.setModemConfig(RF22::GFSK_Rb2_4Fd36))
- pc.printf("setModemConfig 3 failed");
- if (!rf22.setModemConfig(RF22::OOK_Rb40Bw335))
- pc.printf("setModemConfig 4 failed");
-
- pc.printf("-------------");
-}
-
-// This works with test_rx below
-void test_tx() {
- pc.printf("Start Send...\n\r");
- if (!rf22.setFrequency(869.50))
- pc.printf("setFrequency failed");
- if (!rf22.setModemConfig(RF22::GFSK_Rb2Fd5))
- pc.printf("setModemConfig failed");
- //uint8_t data[] = "hello";
- // 255 octets:
- //uint8_t data[] = "12345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012345";
- uint8_t data[32] = "";
- sprintf((char*)data,"Message-Nr: %d",counter);
- rf22.send(data, sizeof(data));
- rf22.waitPacketSent();
- pc.printf("Send OK\n\r");
-
-}
-
-// This works with test_tx above
-void test_rx() {
- pc.printf("Start Receive...\n\r");
- //if (!rf22.setFrequency(869.50))
- if (!rf22.setFrequency(869.49)) // sending frequence doesn't work!!! Offset! Seems to be a problem if combining RFM22B-S1 with -S2
- pc.printf("setFrequency failed\n\r");
- if (!rf22.setModemConfig(RF22::GFSK_Rb2Fd5))
- pc.printf("setModemConfig failed\n\r");
-
- //while (1) {
- uint8_t buf[RF22_MAX_MESSAGE_LEN];
- uint8_t len = sizeof(buf);
- if (rf22.recv(buf, &len)) // Should fail, no message available
- pc.printf("recv 1 failed\n\r");
-
- //rf22.waitAvailable();
- if (rf22.waitAvailableTimeout(6000)) {
- if (rf22.recv(buf, &len)) {
- pc.printf("got one in user: >%s<\n\r",(char*)buf);
- lcd.locate(0,0);
- lcd.printf("%16s",(char*)buf);
- } else
- pc.printf("recv 2 failed\n\r");
- } else
- pc.printf("recv timeout\n\r");
-
- //}
-}
-
-void loop() {
-// test_read_write();
-// test_adc();
-// test_temp();
-// test_burst_read();
-// test_burst_write();
-// test_wut();
-// test_set_frequency();
-// test_rssi();
- test_tx_pn9();
-// test_analog_gpio();
-// test_modem_config();
-// test_tx();
-// test_rx();
-
-// while (1);
- wait_ms(1000);
-}
-
-/*float start = 868.0;
- float end = 868.8;
-*/
-//869,40 - 869,65 Allgemein
-float start = 869.4;
-float end = 869.65;
-float step = 0.02;
-
-
-
-void spec() {
- rf22.setModeRx();
- float freq;
- pc.printf("\033[H"); // Home
- pc.printf("\033[2J"); // Clear Screen
- for (freq = start; freq < end; freq += step) {
- rf22.setFrequency(freq);
- wait_ms(10); // Let the freq settle
- uint8_t rssi = rf22.rssiRead();
- uint8_t stars = rssi / 8;
-
- pc.printf("%f: ",freq);
-
-// Serial.print(rssi, DEC);
- uint8_t i;
- for (i = 0; i < stars; i++)
- pc.putc('*');
- pc.printf("\033[K\n\r"); // DElete to EOL
-
- }
- pc.printf("------------------\n\r");
-}
-
-void send_loop() {
- uint8_t data[32] = "";
-
- while (1) {
- //uint8_t data[] = "hello";
- // 255 octets:
- //uint8_t data[] = "12345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012345";
-
- sprintf((char*)data,"Message-Nr: %d",counter++);
- rf22.send(data, sizeof(data));
- rf22.waitPacketSent();
- pc.printf("Send OK: %s\n\r",(char*)data);
-
- wait(2); // Wait 2 Seconds
- }
-}
-
-void receive_loop() {
- while (1) {
- uint8_t buf[RF22_MAX_MESSAGE_LEN];
- uint8_t len = sizeof(buf);
-
- rf22.waitAvailable();
- if (rf22.recv(buf, &len)) {
- pc.printf("got one in user: >%s<\n\r",(char*)buf);
- lcd.cls();
- lcd.locate(0,0);
- lcd.printf("%16s",(char*)buf);
- } else {
- lcd.printf("recv failed");
- pc.printf("recv failed\n\r");
- }
- }
-}
-
-int main() {
-
-//#define sender; // are we sender?
+int main()
+{
pc.baud(115200);
pc.printf("\n\rConnected to mbed\n\r");
- lcd.locate(0,0); // 2nd cls needed, as otherwise it doesn't init correctly!!???
- lcd.printf("RF22-Test-V1.0");
-
- pc.printf("Pre-setup|");
- setup();
- pc.printf("Post-setup\n\r");
-
-
- //pc.printf("Pre-test_temp|");
- //test_temp();
- //pc.printf("Post-test_temp\n\r");
-
- //pc.printf("Pre-test_set_frequency|");
- //test_set_frequency();
- //pc.printf("Post-test_set_frequency\n\r");
- /* while (1){
- pc.printf("Pre-test_rssi|");
- test_rssi();
- pc.printf("Post-test_rssi\n\r");
- }
+ char version_str [80] = "RF22-MAX!-V1.1";
+ lcd.cls();
+ lcd.setLine(0,version_str);
+ pc.printf("%s\n\r",version_str);
- while (1) {
- spec();
- }
- */
- /*
- while (1) {
- lcd.cls();
- test_tx();
- rf22.setModeRx();
- wait(0.5);
- test_rx();
- wait(2);
- spec();
- }
- */
-
- if (!rf22.setModemConfig(RF22::GFSK_Rb19_2Fd9_6))
- pc.printf("setModemConfig failed");
+ pc.printf("Pre-init|");
+ if (!rf22.init())
+ pc.printf("RF22 init failed\n\r");
+ pc.printf("Post-init\n\r");
-// Test activation of AFC: not enough for combination -S1/-S2 Modules!
+ // try to detect Window-Shutter
-// RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE 0x1d
-// RF22_AFC_EN 0x40
- rf22.spiWrite(RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE, RF22_AFC_EN);
+ rf22.setModemRegisters(&config);
+ rf22.setFrequency(868.3, 0.035);
+ /* Disable TX packet control, since the RF22 doesn't do proper
+ * whitening so can't read the length header or CRC. We need RX packet
+ * control so the RF22 actually sends pkvalid interrupts when the
+ * manually set packet length is reached. */
+ rf22.spiWrite(RF22_REG_30_DATA_ACCESS_CONTROL, RF22_MSBFRST | RF22_ENPACRX);
+ /* No packet headers, 4 sync words, fixed packet length */
+ rf22.spiWrite(RF22_REG_32_HEADER_CONTROL1, RF22_BCEN_NONE | RF22_HDCH_NONE);
+ rf22.spiWrite(RF22_REG_33_HEADER_CONTROL2, RF22_HDLEN_0 | RF22_FIXPKLEN | RF22_SYNCLEN_4);
+ rf22.setSyncWords(sync_words, lengthof(sync_words));
+ /* Detect preamble after 4 nibbles */
+ rf22.spiWrite(RF22_REG_35_PREAMBLE_DETECTION_CONTROL1, (0x4 << 3));
+ /* Send 8 bytes of preamble */
+ rf22.setPreambleLength(8); // in nibbles
+ rf22.spiWrite(RF22_REG_3E_PACKET_LENGTH, 20);
-// Reg RF22_REG_1E_AFC_TIMING_CONTROL 0x1e
-// RF22_AFC_TC 0x0a
- rf22.spiWrite(RF22_REG_1E_AFC_TIMING_CONTROL, RF22_AFC_TC );
-
-// Reg RF22_REG_2A_AFC_LIMITER 0x2a
-// RF22_AFC_LIMIT 0x50
- rf22.spiWrite(RF22_REG_2A_AFC_LIMITER, RF22_AFC_LIMIT);
-
-#ifndef sender
- frequence+=f_offset;
-#endif
+ rf22.setModeRx();
- wheel.Set(frequence*1000); // 3 digits after period
-
- // call trigger_rot() when the shaft is rotaded left or right - change frequence
- wheel.attachROT(&trigger_rotated);
-
- lcd.locate(0,1);
- lcd.printf("%fMHz",frequence);
- wait(10);
- lcd.cls();
-
- if (!rf22.setFrequency(frequence))
- pc.printf("setFrequency failed");
-#ifdef sender
- // Code for sending
-
-
- send_loop(); // start sending
-#endif
+ //wait forever and see if interrrupt occurs(led1)
+ while (1) {
-#ifndef sender
- // Code for receiving
-
- receive_loop(); // start receiving
-
-#endif
-
- //pc.printf("Ready.\n\r");
+ max_rx_loop();
+ };
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Tue Aug 20 20:22:43 2013 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/mbed/builds/e3affc9e7238 \ No newline at end of file
--- a/mbed.lib Wed Jan 18 20:09:21 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1 +0,0 @@ -http://mbed.org/projects/libraries/svn/mbed/trunk@35 \ No newline at end of file