RF69 - Added hardware AES support

examples/RF69_Receive_AES/RF69_Receive_AES.ino

@@ -0,0 +1,80 @@
+/*
+ * KiteLib RF69 Receive with AES Example
+ * 
+ * This example receives packets using RF69 FSK radio module.
+ * Packets are decrypted using hardware AES.
+ * NOTE: When using address filtering, the address byte is NOT encrypted!
+ */
+
+// include the library
+#include <KiteLib.h>
+
+// RF69 module is in slot A on the shield
+RF69 rf = Kite.ModuleA;
+
+void setup() {
+  Serial.begin(9600);
+
+  // initialize RF69 with default settings
+  Serial.print(F("[RF69] Initializing ... "));
+  // carrier frequency:                   434.0 MHz
+  // bit rate:                            48.0 kbps
+  // Rx bandwidth:                        125.0 kHz
+  // frequency deviation:                 50.0 kHz
+  // output power:                        13 dBm
+  // sync word:                           0x2D  0x01
+  byte state = rf.begin();
+  if(state == ERR_NONE) {
+    Serial.println(F("success!"));
+  } else {
+    Serial.print(F("failed, code 0x"));
+    Serial.println(state, HEX);
+    while(true);
+  }
+
+  // set AES key that will be used to decrypt the packet
+  // NOTE: the key must be exactly 16 bytes long!
+  uint8_t key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+                   0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
+  rf.setAESKey(key);
+
+  // enable AES encryption
+  rf.enableAES();
+
+  // AES encryption can also be disabled
+  /*
+  rf.disableAES();
+  */
+}
+
+void loop() {
+  Serial.print(F("[RF69] Waiting for incoming transmission ... "));
+
+  // you can receive data as an Arduino String
+  String str;
+  byte state = rf.receive(str);
+
+  // you can also receive data as byte array
+  /*
+  byte byteArr[8];
+  byte state = rf.receive(byteArr, 8);
+  */
+
+  if(state == ERR_NONE) {
+    // packet was successfully received
+    Serial.println(F("success!"));
+
+    // print the data of the packet
+    Serial.print(F("[RF69] Data:\t\t"));
+    Serial.println(str);
+    
+  } else if(state == ERR_RX_TIMEOUT) {
+    // timeout occurred while waiting for a packet
+    Serial.println(F("timeout!"));
+    
+  } else if(state == ERR_CRC_MISMATCH) {
+    // packet was received, but is malformed
+    Serial.println(F("CRC error!"));
+    
+  }
+}

examples/RF69_Transmit_AES/RF69_Transmit_AES.ino

@@ -0,0 +1,74 @@
+/*
+ * KiteLib RF69 Transmit with AES Example
+ * 
+ * This example transmits packets using RF69 FSK radio module.
+ * Packets are encrypted using hardware AES.
+ * NOTE: When using address filtering, the address byte is NOT encrypted!
+ */
+
+// include the library
+#include <KiteLib.h>
+
+// RF69 module is in slot A on the shield
+RF69 rf = Kite.ModuleA;
+
+void setup() {
+  Serial.begin(9600);
+
+  // initialize RF69 with default settings
+  Serial.print(F("[RF69] Initializing ... "));
+  // carrier frequency:                   434.0 MHz
+  // bit rate:                            48.0 kbps
+  // Rx bandwidth:                        125.0 kHz
+  // frequency deviation:                 50.0 kHz
+  // output power:                        13 dBm
+  // sync word:                           0x2D  0x01
+  byte state = rf.begin();
+  if(state == ERR_NONE) {
+    Serial.println(F("success!"));
+  } else {
+    Serial.print(F("failed, code 0x"));
+    Serial.println(state, HEX);
+    while(true);
+  }
+
+  // set AES key to encrypt the packet
+  // NOTE: the key must be exactly 16 bytes long!
+  uint8_t key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+                   0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
+  rf.setAESKey(key);
+
+  // enable AES encryption
+  rf.enableAES();
+
+  // AES encryption can also be disabled
+  /*
+  rf.disableAES();
+  */
+}
+
+void loop() {
+  Serial.print(F("[RF69] Transmitting packet ... "));
+
+  // you can transmit C-string or Arduino string up to 64 characters long
+  byte state = rf.transmit("Hello World!");
+  
+  // you can also transmit byte array up to 64 bytes long
+  /*
+  byte byteArr[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
+  byte state = rf.transmit(byteArr, 8);
+  */
+  
+  if(state == ERR_NONE) {
+    // the packet was successfully transmitted
+    Serial.println(" success!");
+    
+  } else if(state == ERR_PACKET_TOO_LONG) {
+    // the supplied packet was longer than 256 bytes
+    Serial.println(" too long!");
+    
+  }
+
+  // wait for a second before transmitting again
+  delay(1000);
+}

keywords.txt

@@ -56,6 +56,9 @@ setFrequencyDeviation	KEYWORD2
 setNodeAddress	KEYWORD2
 setBroadcastAddress	KEYWORD2
 disableAddressFiltering	KEYWORD2
+setAESKey	KEYWORD2
+enableAES	KEYWORD2
+disableAES	KEYWORD2
 
 # ESP8266
 join	KEYWORD2

src/modules/RF69.cpp

@@ -207,6 +207,18 @@ uint8_t RF69::standby() {
   return(setMode(RF69_STANDBY));
 }
 
+void RF69::setAESKey(uint8_t* key) {
+  _mod->SPIwriteRegisterBurst(RF69_REG_AES_KEY_1, key, 16);
+}
+
+uint8_t RF69::enableAES() {
+  return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_AES_ON, 0, 0));
+}
+
+uint8_t RF69::disableAES() {
+  return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_AES_OFF, 0, 0));
+}
+
 uint8_t RF69::setFrequency(float freq) {
   // check allowed frequency range
   if(!((freq > 290.0) && (freq < 340.0) ||

src/modules/RF69.h

@@ -427,6 +427,11 @@ class RF69 {
     uint8_t sleep();
     uint8_t standby();
     
+    // hardware AES support
+    void setAESKey(uint8_t* key);
+    uint8_t enableAES();
+    uint8_t disableAES();
+    
     // configuration methods
     uint8_t setFrequency(float freq);
     uint8_t setBitRate(float br);