diff --git a/RFM69.cpp b/RFM69.cpp index f000fe7..2418250 100644 --- a/RFM69.cpp +++ b/RFM69.cpp @@ -32,55 +32,55 @@ #include #include -volatile byte RFM69::DATA[RF69_MAX_DATA_LEN]; -volatile byte RFM69::_mode; // current transceiver state -volatile byte RFM69::DATALEN; -volatile byte RFM69::SENDERID; -volatile byte RFM69::TARGETID; // should match _address -volatile byte RFM69::PAYLOADLEN; -volatile byte RFM69::ACK_REQUESTED; -volatile byte RFM69::ACK_RECEIVED; // should be polled immediately after sending a packet with ACK request -volatile int RFM69::RSSI; // most accurate RSSI during reception (closest to the reception) +volatile uint8_t RFM69::DATA[RF69_MAX_DATA_LEN]; +volatile uint8_t RFM69::_mode; // current transceiver state +volatile uint8_t RFM69::DATALEN; +volatile uint8_t RFM69::SENDERID; +volatile uint8_t RFM69::TARGETID; // should match _address +volatile uint8_t RFM69::PAYLOADLEN; +volatile uint8_t RFM69::ACK_REQUESTED; +volatile uint8_t RFM69::ACK_RECEIVED; // should be polled immediately after sending a packet with ACK request +volatile int16_t RFM69::RSSI; // most accurate RSSI during reception (closest to the reception) RFM69* RFM69::selfPointer; -bool RFM69::initialize(byte freqBand, byte nodeID, byte networkID) +bool RFM69::initialize(uint8_t freqBand, uint8_t nodeID, uint8_t networkID) { - const byte CONFIG[][2] = + const uint8_t CONFIG[][2] = { /* 0x01 */ { REG_OPMODE, RF_OPMODE_SEQUENCER_ON | RF_OPMODE_LISTEN_OFF | RF_OPMODE_STANDBY }, /* 0x02 */ { REG_DATAMODUL, RF_DATAMODUL_DATAMODE_PACKET | RF_DATAMODUL_MODULATIONTYPE_FSK | RF_DATAMODUL_MODULATIONSHAPING_00 }, // no shaping - /* 0x03 */ { REG_BITRATEMSB, RF_BITRATEMSB_55555}, // default:4.8 KBPS + /* 0x03 */ { REG_BITRATEMSB, RF_BITRATEMSB_55555}, // default: 4.8 KBPS /* 0x04 */ { REG_BITRATELSB, RF_BITRATELSB_55555}, - /* 0x05 */ { REG_FDEVMSB, RF_FDEVMSB_50000}, // default:5khz, (FDEV + BitRate/2 <= 500Khz) + /* 0x05 */ { REG_FDEVMSB, RF_FDEVMSB_50000}, // default: 5KHz, (FDEV + BitRate / 2 <= 500KHz) /* 0x06 */ { REG_FDEVLSB, RF_FDEVLSB_50000}, - /* 0x07 */ { REG_FRFMSB, (freqBand==RF69_315MHZ ? RF_FRFMSB_315 : (freqBand==RF69_433MHZ ? RF_FRFMSB_433 : (freqBand==RF69_868MHZ ? RF_FRFMSB_868 : RF_FRFMSB_915))) }, - /* 0x08 */ { REG_FRFMID, (freqBand==RF69_315MHZ ? RF_FRFMID_315 : (freqBand==RF69_433MHZ ? RF_FRFMID_433 : (freqBand==RF69_868MHZ ? RF_FRFMID_868 : RF_FRFMID_915))) }, - /* 0x09 */ { REG_FRFLSB, (freqBand==RF69_315MHZ ? RF_FRFLSB_315 : (freqBand==RF69_433MHZ ? RF_FRFLSB_433 : (freqBand==RF69_868MHZ ? RF_FRFLSB_868 : RF_FRFLSB_915))) }, + /* 0x07 */ { REG_FRFMSB, (uint8_t) (freqBand==RF69_315MHZ ? RF_FRFMSB_315 : (freqBand==RF69_433MHZ ? RF_FRFMSB_433 : (freqBand==RF69_868MHZ ? RF_FRFMSB_868 : RF_FRFMSB_915))) }, + /* 0x08 */ { REG_FRFMID, (uint8_t) (freqBand==RF69_315MHZ ? RF_FRFMID_315 : (freqBand==RF69_433MHZ ? RF_FRFMID_433 : (freqBand==RF69_868MHZ ? RF_FRFMID_868 : RF_FRFMID_915))) }, + /* 0x09 */ { REG_FRFLSB, (uint8_t) (freqBand==RF69_315MHZ ? RF_FRFLSB_315 : (freqBand==RF69_433MHZ ? RF_FRFLSB_433 : (freqBand==RF69_868MHZ ? RF_FRFLSB_868 : RF_FRFLSB_915))) }, // looks like PA1 and PA2 are not implemented on RFM69W, hence the max output power is 13dBm // +17dBm and +20dBm are possible on RFM69HW - // +13dBm formula: Pout=-18+OutputPower (with PA0 or PA1**) - // +17dBm formula: Pout=-14+OutputPower (with PA1 and PA2)** - // +20dBm formula: Pout=-11+OutputPower (with PA1 and PA2)** and high power PA settings (section 3.3.7 in datasheet) + // +13dBm formula: Pout = -18 + OutputPower (with PA0 or PA1**) + // +17dBm formula: Pout = -14 + OutputPower (with PA1 and PA2)** + // +20dBm formula: Pout = -11 + OutputPower (with PA1 and PA2)** and high power PA settings (section 3.3.7 in datasheet) ///* 0x11 */ { REG_PALEVEL, RF_PALEVEL_PA0_ON | RF_PALEVEL_PA1_OFF | RF_PALEVEL_PA2_OFF | RF_PALEVEL_OUTPUTPOWER_11111}, ///* 0x13 */ { REG_OCP, RF_OCP_ON | RF_OCP_TRIM_95 }, // over current protection (default is 95mA) - // RXBW defaults are { REG_RXBW, RF_RXBW_DCCFREQ_010 | RF_RXBW_MANT_24 | RF_RXBW_EXP_5} (RxBw: 10.4khz) + // RXBW defaults are { REG_RXBW, RF_RXBW_DCCFREQ_010 | RF_RXBW_MANT_24 | RF_RXBW_EXP_5} (RxBw: 10.4KHz) /* 0x19 */ { REG_RXBW, RF_RXBW_DCCFREQ_010 | RF_RXBW_MANT_16 | RF_RXBW_EXP_2 }, // (BitRate < 2 * RxBw) //for BR-19200: /* 0x19 */ { REG_RXBW, RF_RXBW_DCCFREQ_010 | RF_RXBW_MANT_24 | RF_RXBW_EXP_3 }, /* 0x25 */ { REG_DIOMAPPING1, RF_DIOMAPPING1_DIO0_01 }, // DIO0 is the only IRQ we're using - /* 0x29 */ { REG_RSSITHRESH, 220 }, // must be set to dBm = (-Sensitivity / 2) - default is 0xE4=228 so -114dBm - ///* 0x2d */ { REG_PREAMBLELSB, RF_PREAMBLESIZE_LSB_VALUE } // default 3 preamble bytes 0xAAAAAA - /* 0x2e */ { REG_SYNCCONFIG, RF_SYNC_ON | RF_SYNC_FIFOFILL_AUTO | RF_SYNC_SIZE_2 | RF_SYNC_TOL_0 }, - /* 0x2f */ { REG_SYNCVALUE1, 0x2D }, // attempt to make this compatible with sync1 byte of RFM12B lib + /* 0x29 */ { REG_RSSITHRESH, 220 }, // must be set to dBm = (-Sensitivity / 2), default is 0xE4 = 228 so -114dBm + ///* 0x2D */ { REG_PREAMBLELSB, RF_PREAMBLESIZE_LSB_VALUE } // default 3 preamble bytes 0xAAAAAA + /* 0x2E */ { REG_SYNCCONFIG, RF_SYNC_ON | RF_SYNC_FIFOFILL_AUTO | RF_SYNC_SIZE_2 | RF_SYNC_TOL_0 }, + /* 0x2F */ { REG_SYNCVALUE1, 0x2D }, // attempt to make this compatible with sync1 byte of RFM12B lib /* 0x30 */ { REG_SYNCVALUE2, networkID }, // NETWORK ID /* 0x37 */ { REG_PACKETCONFIG1, RF_PACKET1_FORMAT_VARIABLE | RF_PACKET1_DCFREE_OFF | RF_PACKET1_CRC_ON | RF_PACKET1_CRCAUTOCLEAR_ON | RF_PACKET1_ADRSFILTERING_OFF }, /* 0x38 */ { REG_PAYLOADLENGTH, 66 }, // in variable length mode: the max frame size, not used in TX ///* 0x39 */ { REG_NODEADRS, nodeID }, // turned off because we're not using address filtering /* 0x3C */ { REG_FIFOTHRESH, RF_FIFOTHRESH_TXSTART_FIFONOTEMPTY | RF_FIFOTHRESH_VALUE }, // TX on FIFO not empty - /* 0x3d */ { REG_PACKETCONFIG2, RF_PACKET2_RXRESTARTDELAY_2BITS | RF_PACKET2_AUTORXRESTART_ON | RF_PACKET2_AES_OFF }, // RXRESTARTDELAY must match transmitter PA ramp-down time (bitrate dependent) - //for BR-19200: /* 0x3d */ { REG_PACKETCONFIG2, RF_PACKET2_RXRESTARTDELAY_NONE | RF_PACKET2_AUTORXRESTART_ON | RF_PACKET2_AES_OFF }, // RXRESTARTDELAY must match transmitter PA ramp-down time (bitrate dependent) + /* 0x3D */ { REG_PACKETCONFIG2, RF_PACKET2_RXRESTARTDELAY_2BITS | RF_PACKET2_AUTORXRESTART_ON | RF_PACKET2_AES_OFF }, // RXRESTARTDELAY must match transmitter PA ramp-down time (bitrate dependent) + //for BR-19200: /* 0x3D */ { REG_PACKETCONFIG2, RF_PACKET2_RXRESTARTDELAY_NONE | RF_PACKET2_AUTORXRESTART_ON | RF_PACKET2_AES_OFF }, // RXRESTARTDELAY must match transmitter PA ramp-down time (bitrate dependent) ///* 0x6F */ { REG_TESTDAGC, RF_DAGC_CONTINUOUS }, // run DAGC continuously in RX mode /* 0x6F */ { REG_TESTDAGC, RF_DAGC_IMPROVED_LOWBETA0 }, // run DAGC continuously in RX mode, recommended default for AfcLowBetaOn=0 {255, 0} @@ -89,10 +89,10 @@ bool RFM69::initialize(byte freqBand, byte nodeID, byte networkID) pinMode(_slaveSelectPin, OUTPUT); SPI.begin(); - do writeReg(REG_SYNCVALUE1, 0xaa); while (readReg(REG_SYNCVALUE1) != 0xaa); + do writeReg(REG_SYNCVALUE1, 0xAA); while (readReg(REG_SYNCVALUE1) != 0xAA); do writeReg(REG_SYNCVALUE1, 0x55); while (readReg(REG_SYNCVALUE1) != 0x55); - for (byte i = 0; CONFIG[i][0] != 255; i++) + for (uint8_t i = 0; CONFIG[i][0] != 255; i++) writeReg(CONFIG[i][0], CONFIG[i][1]); // Encryption is persistent between resets and can trip you up during debugging. @@ -112,20 +112,20 @@ bool RFM69::initialize(byte freqBand, byte nodeID, byte networkID) // return the frequency (in Hz) uint32_t RFM69::getFrequency() { - return RF69_FSTEP * (((uint32_t)readReg(REG_FRFMSB)<<16) + ((uint16_t)readReg(REG_FRFMID)<<8) + readReg(REG_FRFLSB)); + return RF69_FSTEP * (((uint32_t) readReg(REG_FRFMSB) << 16) + ((uint16_t) readReg(REG_FRFMID) << 8) + readReg(REG_FRFLSB)); } // set the frequency (in Hz) void RFM69::setFrequency(uint32_t freqHz) { - // TODO: p38 hopping sequence may need to be followed in some cases + // TODO: datasheet p38 hopping sequence may need to be followed in some cases freqHz /= RF69_FSTEP; // divide down by FSTEP to get FRF writeReg(REG_FRFMSB, freqHz >> 16); writeReg(REG_FRFMID, freqHz >> 8); writeReg(REG_FRFLSB, freqHz); } -void RFM69::setMode(byte newMode) +void RFM69::setMode(uint8_t newMode) { if (newMode == _mode) return; // TODO: can remove this? @@ -161,20 +161,20 @@ void RFM69::sleep() { setMode(RF69_MODE_SLEEP); } -void RFM69::setAddress(byte addr) +void RFM69::setAddress(uint8_t addr) { _address = addr; writeReg(REG_NODEADRS, _address); } -void RFM69::setNetwork(byte networkID) +void RFM69::setNetwork(uint8_t networkID) { writeReg(REG_SYNCVALUE2, networkID); } -// set output power: 0=min, 31=max +// set output power: 0 = min, 31 = max // this results in a "weaker" transmitted signal, and directly results in a lower RSSI at the receiver -void RFM69::setPowerLevel(byte powerLevel) +void RFM69::setPowerLevel(uint8_t powerLevel) { _powerLevel = powerLevel; writeReg(REG_PALEVEL, (readReg(REG_PALEVEL) & 0xE0) | (_powerLevel > 31 ? 31 : _powerLevel)); @@ -190,11 +190,11 @@ bool RFM69::canSend() return false; } -void RFM69::send(byte toAddress, const void* buffer, byte bufferSize, bool requestACK) +void RFM69::send(uint8_t toAddress, const void* buffer, uint8_t bufferSize, bool requestACK) { writeReg(REG_PACKETCONFIG2, (readReg(REG_PACKETCONFIG2) & 0xFB) | RF_PACKET2_RXRESTART); // avoid RX deadlocks - unsigned long now = millis(); - while (!canSend() && millis()-now < RF69_CSMA_LIMIT_MS) receiveDone(); + uint32_t now = millis(); + while (!canSend() && millis() - now < RF69_CSMA_LIMIT_MS) receiveDone(); sendFrame(toAddress, buffer, bufferSize, requestACK, false); } @@ -203,28 +203,28 @@ void RFM69::send(byte toAddress, const void* buffer, byte bufferSize, bool reque // The only twist is that you have to manually listen to ACK requests on the other side and send back the ACKs // The reason for the semi-automaton is that the lib is interrupt driven and // requires user action to read the received data and decide what to do with it -// replies usually take only 5-8ms at 50kbps@915Mhz -bool RFM69::sendWithRetry(byte toAddress, const void* buffer, byte bufferSize, byte retries, byte retryWaitTime) { - unsigned long sentTime; - for (byte i = 0; i <= retries; i++) +// replies usually take only 5..8ms at 50kbps@915MHz +bool RFM69::sendWithRetry(uint8_t toAddress, const void* buffer, uint8_t bufferSize, uint8_t retries, uint8_t retryWaitTime) { + uint32_t sentTime; + for (uint8_t i = 0; i <= retries; i++) { send(toAddress, buffer, bufferSize, true); sentTime = millis(); - while (millis()-sentTime 66 ? 66 : PAYLOADLEN; // precaution TARGETID = SPI.transfer(0); @@ -303,16 +303,16 @@ void RFM69::interruptHandler() { DATALEN = PAYLOADLEN - 3; SENDERID = SPI.transfer(0); - byte CTLbyte = SPI.transfer(0); + uint8_t CTLbyte = SPI.transfer(0); ACK_RECEIVED = CTLbyte & 0x80; // extract ACK-received flag ACK_REQUESTED = CTLbyte & 0x40; // extract ACK-requested flag - for (byte i = 0; i < DATALEN; i++) + for (uint8_t i = 0; i < DATALEN; i++) { DATA[i] = SPI.transfer(0); } - if (DATALEN0) + if (_mode == RF69_MODE_RX && PAYLOADLEN > 0) { setMode(RF69_MODE_STANDBY); // enables interrupts return true; } - else if (_mode == RF69_MODE_RX) // already in RX no payload yet + else if (_mode == RF69_MODE_RX) // already in RX no payload yet { interrupts(); // explicitly re-enable interrupts return false; @@ -364,15 +364,15 @@ void RFM69::encrypt(const char* key) { { select(); SPI.transfer(REG_AESKEY1 | 0x80); - for (byte i = 0; i < 16; i++) + for (uint8_t i = 0; i < 16; i++) SPI.transfer(key[i]); unselect(); } writeReg(REG_PACKETCONFIG2, (readReg(REG_PACKETCONFIG2) & 0xFE) | (key ? 1 : 0)); } -int RFM69::readRSSI(bool forceTrigger) { - int rssi = 0; +int16_t RFM69::readRSSI(bool forceTrigger) { + int16_t rssi = 0; if (forceTrigger) { // RSSI trigger not needed if DAGC is in continuous mode @@ -384,16 +384,16 @@ int RFM69::readRSSI(bool forceTrigger) { return rssi; } -byte RFM69::readReg(byte addr) +uint8_t RFM69::readReg(uint8_t addr) { select(); SPI.transfer(addr & 0x7F); - byte regval = SPI.transfer(0); + uint8_t regval = SPI.transfer(0); unselect(); return regval; } -void RFM69::writeReg(byte addr, byte value) +void RFM69::writeReg(uint8_t addr, uint8_t value) { select(); SPI.transfer(addr | 0x80); @@ -424,7 +424,7 @@ void RFM69::unselect() { } // ON = disable filtering to capture all frames on network -// OFF = enable node+broadcast filtering to capture only frames sent to this/broadcast address +// OFF = enable node/broadcast filtering to capture only frames sent to this/broadcast address void RFM69::promiscuous(bool onOff) { _promiscuousMode = onOff; //writeReg(REG_PACKETCONFIG1, (readReg(REG_PACKETCONFIG1) & 0xF9) | (onOff ? RF_PACKET1_ADRSFILTERING_OFF : RF_PACKET1_ADRSFILTERING_NODEBROADCAST)); @@ -444,7 +444,7 @@ void RFM69::setHighPowerRegs(bool onOff) { writeReg(REG_TESTPA2, onOff ? 0x7C : 0x70); } -void RFM69::setCS(byte newSPISlaveSelect) { +void RFM69::setCS(uint8_t newSPISlaveSelect) { _slaveSelectPin = newSPISlaveSelect; pinMode(_slaveSelectPin, OUTPUT); } @@ -452,12 +452,12 @@ void RFM69::setCS(byte newSPISlaveSelect) { // for debugging void RFM69::readAllRegs() { - byte regVal; + uint8_t regVal; - for (byte regAddr = 1; regAddr <= 0x4F; regAddr++) + for (uint8_t regAddr = 1; regAddr <= 0x4F; regAddr++) { select(); - SPI.transfer(regAddr & 0x7f); // send address + r/w bit + SPI.transfer(regAddr & 0x7F); // send address + r/w bit regVal = SPI.transfer(0); unselect(); @@ -470,12 +470,12 @@ void RFM69::readAllRegs() unselect(); } -byte RFM69::readTemperature(byte calFactor) // returns centigrade +uint8_t RFM69::readTemperature(uint8_t calFactor) // returns centigrade { setMode(RF69_MODE_STANDBY); writeReg(REG_TEMP1, RF_TEMP1_MEAS_START); while ((readReg(REG_TEMP1) & RF_TEMP1_MEAS_RUNNING)); - return ~readReg(REG_TEMP2) + COURSE_TEMP_COEF + calFactor; // 'complement'corrects the slope, rising temp = rising val + return ~readReg(REG_TEMP2) + COURSE_TEMP_COEF + calFactor; // 'complement' corrects the slope, rising temp = rising val } // COURSE_TEMP_COEF puts reading in the ballpark, user can add additional correction void RFM69::rcCalibration() diff --git a/RFM69.h b/RFM69.h index b5957a9..7e49c68 100644 --- a/RFM69.h +++ b/RFM69.h @@ -32,10 +32,10 @@ #define RFM69_h #include // assumes Arduino IDE v1.0 or greater -#define RF69_MAX_DATA_LEN 61 // to take advantage of the built in AES/CRC we want to limit the frame size to the internal FIFO size (66 bytes - 3 bytes overhead) -#define RF69_SPI_CS SS // SS is the SPI slave select pin, for instance D10 on atmega328 +#define RF69_MAX_DATA_LEN 61 // to take advantage of the built in AES/CRC we want to limit the frame size to the internal FIFO size (66 bytes - 3 bytes overhead - 2 bytes crc) +#define RF69_SPI_CS SS // SS is the SPI slave select pin, for instance D10 on ATmega328 -// INT0 on AVRs should be connected to RFM69's DIO0 (ex on Atmega328 it's D2, on Atmega644/1284 it's D2) +// INT0 on AVRs should be connected to RFM69's DIO0 (ex on ATmega328 it's D2, on ATmega644/1284 it's D2) #if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega88) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega88__) #define RF69_IRQ_PIN 2 #define RF69_IRQ_NUM 0 @@ -50,7 +50,7 @@ #define CSMA_LIMIT -90 // upper RX signal sensitivity threshold in dBm for carrier sense access #define RF69_MODE_SLEEP 0 // XTAL OFF -#define RF69_MODE_STANDBY 1 // XTAL ON +#define RF69_MODE_STANDBY 1 // XTAL ON #define RF69_MODE_SYNTH 2 // PLL ON #define RF69_MODE_RX 3 // RX MODE #define RF69_MODE_TX 4 // TX MODE @@ -66,21 +66,21 @@ #define RF69_BROADCAST_ADDR 255 #define RF69_CSMA_LIMIT_MS 1000 #define RF69_TX_LIMIT_MS 1000 -#define RF69_FSTEP 61.03515625 // == FXOSC/2^19 = 32mhz/2^19 (p13 in DS) +#define RF69_FSTEP 61.03515625 // == FXOSC / 2^19 = 32MHz / 2^19 (p13 in datasheet) class RFM69 { public: - static volatile byte DATA[RF69_MAX_DATA_LEN]; // recv/xmit buf, including hdr & crc bytes - static volatile byte DATALEN; - static volatile byte SENDERID; - static volatile byte TARGETID; // should match _address - static volatile byte PAYLOADLEN; - static volatile byte ACK_REQUESTED; - static volatile byte ACK_RECEIVED; // Should be polled immediately after sending a packet with ACK request - static volatile int RSSI; // most accurate RSSI during reception (closest to the reception) - static volatile byte _mode; // should be protected? + static volatile uint8_t DATA[RF69_MAX_DATA_LEN]; // recv/xmit buf, including header & crc bytes + static volatile uint8_t DATALEN; + static volatile uint8_t SENDERID; + static volatile uint8_t TARGETID; // should match _address + static volatile uint8_t PAYLOADLEN; + static volatile uint8_t ACK_REQUESTED; + static volatile uint8_t ACK_RECEIVED; // should be polled immediately after sending a packet with ACK request + static volatile int16_t RSSI; // most accurate RSSI during reception (closest to the reception) + static volatile uint8_t _mode; // should be protected? - RFM69(byte slaveSelectPin=RF69_SPI_CS, byte interruptPin=RF69_IRQ_PIN, bool isRFM69HW=false, byte interruptNum=RF69_IRQ_NUM) { + RFM69(uint8_t slaveSelectPin=RF69_SPI_CS, uint8_t interruptPin=RF69_IRQ_PIN, bool isRFM69HW=false, uint8_t interruptNum=RF69_IRQ_NUM) { _slaveSelectPin = slaveSelectPin; _interruptPin = interruptPin; _interruptNum = interruptNum; @@ -90,51 +90,51 @@ class RFM69 { _isRFM69HW = isRFM69HW; } - bool initialize(byte freqBand, byte ID, byte networkID=1); - void setAddress(byte addr); - void setNetwork(byte networkID); + bool initialize(uint8_t freqBand, uint8_t ID, uint8_t networkID=1); + void setAddress(uint8_t addr); + void setNetwork(uint8_t networkID); bool canSend(); - void send(byte toAddress, const void* buffer, byte bufferSize, bool requestACK=false); - bool sendWithRetry(byte toAddress, const void* buffer, byte bufferSize, byte retries=2, byte retryWaitTime=40); // 40ms roundtrip req for 61byte packets + void send(uint8_t toAddress, const void* buffer, uint8_t bufferSize, bool requestACK=false); + bool sendWithRetry(uint8_t toAddress, const void* buffer, uint8_t bufferSize, uint8_t retries=2, uint8_t retryWaitTime=40); // 40ms roundtrip req for 61byte packets bool receiveDone(); - bool ACKReceived(byte fromNodeID); + bool ACKReceived(uint8_t fromNodeID); bool ACKRequested(); void sendACK(const void* buffer = "", uint8_t bufferSize=0); uint32_t getFrequency(); void setFrequency(uint32_t freqHz); void encrypt(const char* key); - void setCS(byte newSPISlaveSelect); - int readRSSI(bool forceTrigger=false); + void setCS(uint8_t newSPISlaveSelect); + int16_t readRSSI(bool forceTrigger=false); void promiscuous(bool onOff=true); - void setHighPower(bool onOFF=true); // have to call it after initialize for RFM69HW - void setPowerLevel(byte level); // reduce/increase transmit power level + void setHighPower(bool onOFF=true); // has to be called after initialize() for RFM69HW + void setPowerLevel(uint8_t level); // reduce/increase transmit power level void sleep(); - byte readTemperature(byte calFactor=0); // get CMOS temperature (8bit) + uint8_t readTemperature(uint8_t calFactor=0); // get CMOS temperature (8bit) void rcCalibration(); // calibrate the internal RC oscillator for use in wide temperature variations - see datasheet section [4.3.5. RC Timer Accuracy] // allow hacking registers by making these public - byte readReg(byte addr); - void writeReg(byte addr, byte val); + uint8_t readReg(uint8_t addr); + void writeReg(uint8_t addr, uint8_t val); void readAllRegs(); protected: static void isr0(); void virtual interruptHandler(); - void sendFrame(byte toAddress, const void* buffer, byte size, bool requestACK=false, bool sendACK=false); + void sendFrame(uint8_t toAddress, const void* buffer, uint8_t size, bool requestACK=false, bool sendACK=false); static RFM69* selfPointer; - byte _slaveSelectPin; - byte _interruptPin; - byte _interruptNum; - byte _address; + uint8_t _slaveSelectPin; + uint8_t _interruptPin; + uint8_t _interruptNum; + uint8_t _address; bool _promiscuousMode; - byte _powerLevel; + uint8_t _powerLevel; bool _isRFM69HW; - byte _SPCR; - byte _SPSR; + uint8_t _SPCR; + uint8_t _SPSR; void receiveBegin(); - void setMode(byte mode); + void setMode(uint8_t mode); void setHighPowerRegs(bool onOff); void select(); void unselect();