Skip to content

A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol

create subghz controller

Geo2abc281ae5b5
diff --git a/src/Controllers/SubGhzController.cpp b/src/Controllers/SubGhzController.cpp
new file mode 100644
index 00000000..ad898a2d
--- /dev/null
+++ b/src/Controllers/SubGhzController.cpp
@@ -0,0 +1,240 @@
+#include "SubGhzController.h"
+
+/*
+Entry point for commands
+*/
+void SubGhzController::handleCommand(const TerminalCommand& cmd) {
+ const std::string root = cmd.getRoot();
+
+ if (root == "sniff") handleSniff(cmd);
+ else if (root == "scan") handleScan(cmd);
+ else if (root == "setfrequency") handleSetFrequency();
+ else if (root == "setfreq") handleSetFrequency();
+ else if (root == "config") handleConfig();
+ else handleHelp();
+}
+
+/*
+Sniff for signals
+*/
+void SubGhzController::handleSniff(const TerminalCommand&) {
+ float f = state.getSubGhzFrequency();
+ uint32_t count = 0;
+
+ if (!subGhzService.applySniffProfile(f)) {
+ terminalView.println("SUBGHZ: Not configured. Run 'config' first.");
+ return;
+ }
+
+ terminalView.println("SUBGHZ Sniff: Frequency @ " + std::to_string(f) + " MHz... Press [ENTER] to stop\n");
+
+ subGhzService.startRawSniffer(state.getSubGhzGdoPin());
+ while (true) {
+ char c = terminalInput.readChar();
+ if (c == '\n' || c == '\r') {
+ break;
+ }
+
+ auto raw = subGhzService.readRawPulses();
+ for (auto &line : raw) {
+ count++;
+ terminalView.println(line);
+ }
+ }
+ subGhzService.stopRawSniffer();
+
+ terminalView.println("\nSUBGHZ Sniff: Done. " + std::to_string(count) + " frames\n");
+}
+
+/*
+Scan for frequencies
+*/
+void SubGhzController::handleScan(const TerminalCommand& cmd) {
+ const auto& args = cmd.getArgs();
+ auto bands = subGhzService.getSupportedBand();
+
+ // Band selection
+ auto bandIndex = userInputManager.readValidatedChoiceIndex("Select frequency band:", bands, 0);
+ subGhzService.setScanBand(bands[bandIndex]);
+ std::vector<float> freqs = subGhzService.getSupportedFreq(bands[bandIndex]);
+
+ // RSSI threshold / hold time selection
+ int holdMs = userInputManager.readValidatedInt("Enter hold time per frequency (ms):", 4, 1, 5000);
+ int rssiThr = userInputManager.readValidatedInt("Enter RSSI threshold detection (dBm):", -67, -127, 0);
+
+ // Prepare the scan
+ if (!subGhzService.applyScanProfile(4.8f, 200.0f, 2 /* OOK */, true)) {
+ terminalView.println("SUBGHZ: Not configured. Run 'config' first.");
+ return;
+ }
+
+ terminalView.println("SUBGHZ Scan: Started. Hold=" + std::to_string(holdMs) +
+ " ms, Thr=" + std::to_string(rssiThr) + " dBm.... Pres [ENTER] to stop.\n");
+
+ std::vector<int> best(freqs.size(), -127);
+ std::vector<bool> wasAbove(freqs.size(), false);
+ bool stopRequested = false;
+
+ // Scanning
+ while (!stopRequested) {
+ for (size_t i = 0; i < freqs.size(); ++i) {
+ // User enter press
+ int c = terminalInput.readChar();
+ if (c == '\n' || c == '\r') { stopRequested = true; break; }
+
+ // Set the freq
+ float f = freqs[i];
+ subGhzService.tune(f);
+
+ // Measure peak on freq for ms
+ int peak = subGhzService.measurePeakRssi(holdMs);
+ if (peak > best[i]) best[i] = peak;
+
+ // Log spike if any
+ if (peak >= rssiThr && !wasAbove[i]) {
+ terminalView.println(" [PEAK] f=" + argTransformer.toFixed2(f) + " MHz RSSI=" + std::to_string(peak) + " dBm");
+ wasAbove[i] = true;
+ } else if (peak < rssiThr - 2) {
+ wasAbove[i] = false;
+ }
+ }
+ }
+
+ // Summary
+ std::vector<size_t> idx(freqs.size());
+ std::iota(idx.begin(), idx.end(), 0);
+ std::sort(idx.begin(), idx.end(), [&](size_t a, size_t b){ return best[a] > best[b]; });
+ terminalView.println("\n [SCAN] Best peaks:");
+ const size_t n = std::min<size_t>(5, idx.size());
+ for (size_t k = 0; k < n; ++k) {
+ size_t i = idx[k];
+ terminalView.println(" " + argTransformer.toFixed2(freqs[i]) + " MHz RSSI=" + std::to_string(best[i]) + " dBm");
+ }
+
+ // Ask to save best frequency if above threshold
+ if (!idx.empty() && best[idx[0]] > -120) {
+ auto confirm = userInputManager.readYesNo(" Save tuning to best frequency (" + argTransformer.toFixed2(freqs[idx[0]]) + " MHz)?", true);
+ if (!confirm) return;
+ subGhzService.tune(freqs[idx[0]]);
+ terminalView.println(" [FREQ] Saving to config: " + argTransformer.toFixed2(freqs[idx[0]]) + " MHz\n");
+ state.setSubGhzFrequency(freqs[idx[0]]);
+ } else {
+ subGhzService.tune(state.getSubGhzFrequency());
+ }
+}
+
+/*
+Set frequency
+*/
+void SubGhzController::handleSetFrequency() {
+ terminalView.println("");
+ terminalView.println("Select SubGHz Frequency:");
+
+ // Band selection
+ auto bands = subGhzService.getSupportedBand();
+ std::vector<std::string> displayBands = bands;
+ if (!displayBands.empty()) displayBands[0] = " Custom";
+ int bandIndex = userInputManager.readValidatedChoiceIndex("Frequency band", displayBands, 0);
+
+ // Custom frequency
+ if (bandIndex == 0) {
+ float mhz = userInputManager.readValidatedFloat("Enter custom frequency (MHz):", state.getSubGhzFrequency(), 0.0f, 1000.0f);
+ state.setSubGhzFrequency(mhz);
+ subGhzService.tune(mhz);
+ terminalView.println("SUBGHZ: Frequency changed to " + argTransformer.toFixed2(mhz) + " MHz\n");
+ return;
+ }
+
+ // Choose in predefined frequencies
+ subGhzService.setScanBand(bands[bandIndex]);
+ std::vector<float> freqs = subGhzService.getSupportedFreq(bands[bandIndex]);
+ int index = userInputManager.readValidatedChoiceIndex("Frequencies", freqs, 0);
+ float selected = freqs[index];
+
+ // Apply
+ state.setSubGhzFrequency(selected);
+ subGhzService.tune(selected);
+
+ terminalView.println("SUBGHZ: Frequency changed to " + argTransformer.toFixed2(selected) + " MHz\n");
+}
+
+/*
+Config CC1101
+*/
+void SubGhzController::handleConfig() {
+ terminalView.println("\nSubGHz Configuration:");
+
+ const auto& forbidden = state.getProtectedPins();
+
+ // CC1101 pins
+ uint8_t sck = userInputManager.readValidatedPinNumber("CC1101 SCK pin", state.getSubGhzSckPin(), forbidden);
+ state.setSubGhzSckPin(sck);
+
+ uint8_t miso = userInputManager.readValidatedPinNumber("CC1101 MISO pin", state.getSubGhzMisoPin(), forbidden);
+ state.setSubGhzMisoPin(miso);
+
+ uint8_t mosi = userInputManager.readValidatedPinNumber("CC1101 MOSI pin", state.getSubGhzMosiPin(), forbidden);
+ state.setSubGhzMosiPin(mosi);
+
+ uint8_t ss = userInputManager.readValidatedPinNumber("CC1101 SS/CS pin", state.getSubGhzCsPin(), forbidden);
+ state.setSubGhzCsPin(ss);
+
+ uint8_t gdo0 = userInputManager.readValidatedPinNumber("CC1101 GDO0 pin", state.getSubGhzGdoPin(), forbidden);
+ state.setSubGhzGdoPin(gdo0);
+
+ float freq = state.getSubGhzFrequency();
+
+ // Configure
+ auto isConfigured = subGhzService.configure(
+ sck, miso, mosi, ss,
+ gdo0,
+ freq
+ );
+
+ // CC1101 feedback
+ if (!isConfigured) {
+ terminalView.println("\nFailed to detect CC1101 module. Check wiring.\n");
+ } else {
+ terminalView.println("\n[INFO] For SubGHz features, use **USB Serial** connection.");
+ terminalView.println(" It offers lower latency and more reliable logging.");
+ terminalView.println(" The WiFi Web UI can introduce delays and miss pulses.\n");
+
+ // Apply settings
+ subGhzService.tune(freq);
+ subGhzService.applyScanProfile();
+ terminalView.println("CC1101 module detected and configured with default frequency.");
+ terminalView.println("Use 'setfrequency' or 'scan' to change the frequency.\n");
+ }
+
+ configured = true;
+}
+
+/*
+Ensure SubGHz is configured
+*/
+void SubGhzController::ensureConfigured() {
+ if (!configured) {
+ handleConfig();
+ configured = true;
+ };
+
+ uint8_t cs = state.getSubGhzCsPin();
+ uint8_t gdo0 = state.getSubGhzGdoPin();
+ uint8_t sck = state.getSubGhzSckPin();
+ uint8_t miso = state.getSubGhzMisoPin();
+ uint8_t mosi = state.getSubGhzMosiPin();
+ float freq = state.getSubGhzFrequency();
+
+ subGhzService.configure(sck, miso, mosi, cs, gdo0, freq);
+}
+
+/*
+Help
+*/
+void SubGhzController::handleHelp() {
+ terminalView.println("SubGHz commands:");
+ terminalView.println(" scan");
+ terminalView.println(" sniff");
+ terminalView.println(" setfrequency");
+ terminalView.println(" config");
+}
diff --git a/src/Controllers/SubGhzController.h b/src/Controllers/SubGhzController.h
new file mode 100644
index 00000000..f1764a51
--- /dev/null
+++ b/src/Controllers/SubGhzController.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <numeric>
+#include "Interfaces/ITerminalView.h"
+#include "Interfaces/IInput.h"
+#include "Models/TerminalCommand.h"
+#include "Models/ByteCode.h"
+#include "Transformers/ArgTransformer.h"
+#include "Managers/UserInputManager.h"
+#include "States/GlobalState.h"
+#include "Services/SubGhzService.h"
+#include <sstream>
+#include <cctype>
+
+class SubGhzController {
+public:
+ SubGhzController(ITerminalView& terminalView,
+ IInput& terminalInput,
+ SubGhzService& subGhzService,
+ ArgTransformer& argTransformer,
+ UserInputManager& userInputManager)
+ : terminalView(terminalView),
+ terminalInput(terminalInput),
+ subGhzService(subGhzService),
+ argTransformer(argTransformer),
+ userInputManager(userInputManager) {}
+
+ // Entry point for subghz commands
+ void handleCommand(const TerminalCommand& cmd);
+
+ // Ensure subghz mode is properly configured before use
+ void ensureConfigured();
+
+private:
+ // Sniff for signals
+ void handleSniff(const TerminalCommand& cmd);
+
+ // Scan for frequencies
+ void handleScan(const TerminalCommand& cmd);
+
+ // Set current frequency
+ void handleSetFrequency();
+
+ // Configure CC1101
+ void handleConfig();
+
+ // Available commands
+ void handleHelp();
+
+private:
+ ITerminalView& terminalView;
+ IInput& terminalInput;
+ SubGhzService& subGhzService;
+ ArgTransformer& argTransformer;
+ UserInputManager& userInputManager;
+ GlobalState& state = GlobalState::getInstance();
+
+ bool configured = false;
+};