Skip to content

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

22.0 KB
Raw Blame
#include "Controllers/DioController.h"
#include <sstream>
#include <algorithm>

/*
Constructor
*/
DioController::DioController(ITerminalView& terminalView, IInput& terminalInput, PinService& pinService, ArgTransformer& argTransformer, HelpShell& helpShell, UserInputManager& userInputManager)
    : terminalView(terminalView), terminalInput(terminalInput), pinService(pinService), argTransformer(argTransformer), helpShell(helpShell), userInputManager(userInputManager) {}

/*
Entry point to handle a DIO command
*/
void DioController::handleCommand(const TerminalCommand& cmd) {
    if (cmd.getRoot() == "sniff") handleSniff(cmd);
    else if (cmd.getRoot() == "read")   handleReadPin(cmd); 
    else if (cmd.getRoot() == "set")    handleSetPin(cmd);
    else if (cmd.getRoot() == "scan")   handleScan(cmd);
    else if (cmd.getRoot() == "pullup") handlePullup(cmd);
    else if (cmd.getRoot() == "pulldown") handlePulldown(cmd);
    else if (cmd.getRoot() == "pwm")    handlePwm(cmd);
    else if (cmd.getRoot() == "toggle") handleTogglePin(cmd);
    else if (cmd.getRoot() == "pulse")  handlePulse(cmd);
    else if (cmd.getRoot() == "measure") handleMeasure(cmd);
    else if (cmd.getRoot() == "servo")  handleServo(cmd);
    else if (cmd.getRoot() == "jam")    handleJamPin(cmd);
    else if (cmd.getRoot() == "reset")  handleResetPin(cmd);
    else                                handleHelp();
    
}

/*
Read
*/
void DioController::handleReadPin(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty() || !argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("Usage: read <pin>");
        return;
    }

    uint8_t pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Read")) return;
    int value = pinService.read(pin);
    terminalView.println("Pin " + std::to_string(pin) + " = " + std::to_string(value) + (value ? " (HIGH)" : " (LOW)"));
}

/*
Set
*/
void DioController::handleSetPin(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty() || !argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("Usage: set <pin> <IN/OUT/HI/LOW>");
        return;
    }

    std::string arg = cmd.getArgs();
    if (arg.empty()) {
        terminalView.println("DIO Set: Missing mode (IN/OUT/HI/LOW).");
        return;
    }

    uint8_t pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Set")) return;
    char c = std::toupper(arg[0]);

    switch (c) {
        case 'I':
            pinService.setInput(pin);
            terminalView.println("DIO Set: Pin " + std::to_string(pin) + " set to INPUT");
            break;
        case 'O':
            pinService.setOutput(pin);
            terminalView.println("DIO Set: Pin " + std::to_string(pin) + " set to OUTPUT");
            break;
        case 'H':
        case '1':
            pinService.setOutput(pin);
            pinService.setHigh(pin);
            terminalView.println("DIO Set: Pin " + std::to_string(pin) + " set to HIGH");
            break;
        case 'L':
        case '0':
            pinService.setOutput(pin);
            pinService.setLow(pin);
            terminalView.println("DIO Set: Pin " + std::to_string(pin) + " set to LOW");
            break;
        default:
            terminalView.println("Unknown command. Use I, O, H (1), or L (0).");
            break;
    }
}

/*
Scan
*/
void DioController::handleScan(const TerminalCommand& cmd) {

    // Default pins 
    std::vector<uint8_t> defaultPins = state.getJtagScanPins();

    // Protected
    const std::vector<uint8_t> protectedPins = state.getProtectedPins();

    // Select
    std::vector<uint8_t> pins = userInputManager.readValidatedPinGroup(
        "GPIOs to detect activity",
        defaultPins,
        protectedPins
    );

    // Limit
    if (pins.size() > 8) {
        terminalView.println("Too many pins selected, limiting to first 8.");
        pins.resize(8);
    }

    // Validate
    std::vector<uint8_t> validPins;
    for (uint8_t pin : pins) {
        if (isPinAllowed(pin, "Scan")) {
            validPins.push_back(pin);
        }
    }

    if (validPins.empty()) {
        terminalView.println("DIO Scan: No valid pins selected.");
        return;
    }

    terminalView.println("\nDIO Scan: Detecting activity... Press [ENTER] to stop.\n");

    // Configure pins as INPUT with existing pull
    for (uint8_t pin : validPins) {
        auto pull = pinService.getPullType(pin);
        if (pull == PinService::PULL_UP)        pinService.setInputPullup(pin);
        else if (pull == PinService::PULL_DOWN) pinService.setInputPullDown(pin);
        else                                    pinService.setInput(pin);
    }

    // Init maps
    std::map<uint8_t, int> lastState;
    std::map<uint8_t, uint32_t> edgeCount;

    // high/low sample counters
    std::map<uint8_t, uint32_t> highSamples;
    std::map<uint8_t, uint32_t> lowSamples;

    for (uint8_t pin : validPins) {
        int v = pinService.read(pin);
        lastState[pin] = v;
        edgeCount[pin] = 0;
        highSamples[pin] = (v ? 1 : 0);
        lowSamples[pin]  = (v ? 0 : 1);
    }

    unsigned long lastPrint = millis();

    while (true) {

        // Stop if ENTER
        char c = terminalInput.readChar();
        if (c == '\r' || c == '\n') {
            terminalView.println("DIO Scan: Stopped by user.");
            break;
        }

        // Many samples per loop to have better stats 
        for (int i = 0; i < 256; i++) {
            for (uint8_t pin : validPins) {
                int cur = pinService.read(pin);

                if (cur) highSamples[pin]++; else lowSamples[pin]++;

                int& last = lastState[pin];
                if (cur != last) {
                    last = cur;
                    edgeCount[pin]++;
                }
            }
        }

        // Report each 2 sec
        unsigned long now = millis();
        if (now - lastPrint >= 2000) {
            lastPrint = now;

            terminalView.println("Active pins:");

            // Find max digits for align
            size_t maxEdgeDigits = 1;
            bool any = false;
            for (auto& [pin, edges] : edgeCount) {
                if (edges == 0) continue;
                any = true;

                // count digits
                uint32_t x = edges;
                size_t d = 1;
                while (x >= 10) { x /= 10; d++; }
                if (d > maxEdgeDigits) maxEdgeDigits = d;
            }

            if (!any) {
                terminalView.println("  (none)");
                terminalView.println("");
            } else {
                for (uint8_t pin : validPins) {
                    uint32_t edges = edgeCount[pin];
                    if (edges == 0) continue;

                    uint32_t hi = highSamples[pin];
                    uint32_t lo = lowSamples[pin];
                    uint32_t total = hi + lo;

                    // Percent
                    uint32_t hiPct = 0;
                    uint32_t loPct = 0;
                    if (total != 0) {
                        hiPct = (hi * 100u + (total / 2u)) / total;
                        loPct = 100u - hiPct; // keep sum to 100
                    }

                    // padding for edges alignment
                    // ex: edges=1 vs edges=32000
                    size_t digits = 1;
                    {
                        uint32_t x = edges;
                        while (x >= 10) { x /= 10; digits++; }
                    }
                    size_t pad = (maxEdgeDigits > digits) ? (maxEdgeDigits - digits) : 0;
                    std::string padSpaces(pad, ' ');

                    // Pad GPIO
                    std::string pinStr = std::to_string(pin);
                    if (pin < 10) pinStr += " ";

                    terminalView.println(
                        "  GPIO " + pinStr +
                        " | edges=" + padSpaces + std::to_string(edges) +
                        " | HIGH=" + std::to_string(hiPct) + "% LOW=" + std::to_string(loPct) + "%"
                    );
                }

                terminalView.println("");
            }

            // Reset window counters
            for (uint8_t pin : validPins) {
                edgeCount[pin] = 0;
                highSamples[pin] = 0;
                lowSamples[pin] = 0;
            }
        }
    }
}

/*
Pullup
*/
void DioController::handlePullup(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty() || !argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("Usage: pullup <pin>");
        return;
    }

    int pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Pullup")) return;
    pinService.setInputPullup(pin);

    terminalView.println("DIO Pullup: Set on pin " + std::to_string(pin));
}

/*
Pulldown
*/
void DioController::handlePulldown(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty() || !argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("Usage: pulldown <pin>");
        return;
    }

    int pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Pulldown")) return;
    pinService.setInputPullDown(pin);

    terminalView.println("DIO Pulldown: Set on pin " + std::to_string(pin));
}

/*
Sniff
*/
void DioController::handleSniff(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty() || !argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("Usage: sniff <pin>");
        return;
    }

    uint8_t pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Sniff")) return;

    // Apply existing pull config
    PinService::pullType pull = pinService.getPullType(pin);
    if (pull == PinService::PULL_UP)       pinService.setInputPullup(pin);
    else if (pull == PinService::PULL_DOWN) pinService.setInputPullDown(pin);
    else                                   pinService.setInput(pin);

    terminalView.println("DIO Sniff: Pin " + std::to_string(pin) + "... Press [ENTER] to stop");
    uint8_t last = pinService.read(pin);
    terminalView.println("\nInitial state: " + std::string(last ? "HIGH" : "LOW"));
    terminalView.println("");

    uint32_t lastEdgeUs = micros();
    uint32_t lastKeyPollMs = millis();

    while (true) {
        // check ENTER every 10ms
        if (millis() - lastKeyPollMs > 10) {
            lastKeyPollMs = millis();
            char c = terminalInput.readChar();
            if (c == '\r' || c == '\n') {
                terminalView.println("\nDIO Sniff: Stopped.");
                break;
            }
        }

        int current = pinService.read(pin);
        if (current != last) {
            uint32_t nowUs = micros();
            uint32_t dtUs = nowUs - lastEdgeUs;
            lastEdgeUs = nowUs;

            std::string transition = (last == 0 && current == 1)
                ? "LOW  -> HIGH"
                : "HIGH -> LOW ";

            terminalView.println(
                "Pin " + std::to_string(pin) + ": " + transition +
                " | delta=" + std::to_string(dtUs) + "us"
            );

            last = current;
        }
    }
}

/*
Pwm
*/
void DioController::handlePwm(const TerminalCommand& cmd) {
    auto sub = cmd.getSubcommand();
    auto args = argTransformer.splitArgs(cmd.getArgs());

    // Validate pin
    if (sub.empty() || !argTransformer.isValidNumber(sub)) {
        terminalView.println("Usage: pwm <pin> [frequency] [duty]");
        return;
    }

    uint8_t pin = argTransformer.toUint8(sub);
    if (!isPinAllowed(pin, "PWM")) return;

    // Defaults
    uint32_t freq = 1000;
    uint8_t duty = 50;

    // freq / duty  ?
    if (args.size() >= 1 && argTransformer.isValidNumber(args[0])) {
        freq = argTransformer.toUint32(args[0]);
    } else {
        // prompt freq 
        freq = userInputManager.readValidatedUint32("PWM frequency (Hz)", freq, false);
    }

    if (args.size() >= 2 && argTransformer.isValidNumber(args[1])) {
        duty = argTransformer.toUint8(args[1]);
    } else {
        // prompt duty
        duty = userInputManager.readValidatedUint8("PWM duty (%)", duty, 0, 100);
    }

    // Setup PWM
    bool ok = pinService.setupPwm(pin, freq, duty);
    if (!ok) {
        terminalView.println("DIO PWM: Cannot generate " + std::to_string(freq) +
                             " Hz. Try a higher frequency or use toggle command.");
        return;
    }

    terminalView.println("\nDIO PWM: Pin " + std::to_string(pin) +
                         " (" + std::to_string(freq) + "Hz, " +
                         std::to_string(duty) + "% duty)... Use 'reset " + 
                         std::to_string(pin) + "' to stop.\n");
}

/*
Measure edges
*/
void DioController::handleMeasure(const TerminalCommand& cmd) {
    auto args = argTransformer.splitArgs(cmd.getArgs());

    if (cmd.getSubcommand().empty()) {
        terminalView.println("Usage: measure <pin> [duration_ms]");
        return;
    }

    if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("DIO Measure: Invalid pin number.");
        return;
    }

    uint8_t pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Measure")) return;

    uint32_t durationMs = 1000;
    if (!args.empty() && argTransformer.isValidNumber(args[0])) {
        durationMs = std::min(argTransformer.toUint32(args[0]), 5000u);
        if (durationMs == 5000) {
            terminalView.println("Note: Duration limited to 5000 ms max.");
        }
    }

    terminalView.println("DIO Measure: Sampling pin " + std::to_string(pin) +
                         " for " + std::to_string(durationMs) + " ms...");

    PinService::pullType pull =  pinService.getPullType(pin);
    
    switch (pull)
    {
    case PinService::NOPULL:
        pinService.setInput(pin);
        break;
    case PinService::PULL_UP:
        pinService.setInputPullup(pin);
        break;
    case PinService::PULL_DOWN:
        pinService.setInputPullDown(pin);
        break;
    
    default:
        break;
    }
    
    int last = pinService.read(pin);
    uint32_t rising = 0, falling = 0;

    unsigned long startMs = millis();

    while (millis() - startMs < durationMs) {
        int current = pinService.read(pin);
        if (current != last) {
            if (last == 0 && current == 1) ++rising;
            else if (last == 1 && current == 0) ++falling;
            last = current;
        }
    }

    terminalView.println("");
    terminalView.println(" Results:");
    terminalView.println("  • Rising edges:     " + std::to_string(rising));
    terminalView.println("  • Falling edges:    " + std::to_string(falling));

    uint32_t totalEdges = rising + falling;
    float freqHz = (totalEdges / 2.0f) / (durationMs / 1000.0f);

    std::ostringstream oss;
    oss.precision(2);
    oss << std::fixed << "  • Approx. frequency: " << freqHz << " Hz\n";
    terminalView.println(oss.str());
}

/*
Toggle
*/
void DioController::handleTogglePin(const TerminalCommand& cmd) {
    
    auto args = argTransformer.splitArgs(cmd.getArgs());
    
    if (cmd.getSubcommand().empty() || args.empty()) {
        terminalView.println("Usage: toggle <pin> <ms>");
        return;
    }
    
    if (!argTransformer.isValidNumber(cmd.getSubcommand()) ||
    !argTransformer.isValidNumber(args[0])) {
        terminalView.println("DIO Toggle: Invalid arguments.");
        return;
    }
    
    uint8_t pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Toggle")) return;

    uint32_t intervalMs = argTransformer.toUint32(args[0]);
    
    pinService.setOutput(pin);
    bool state = false;

    terminalView.println("\nDIO Toggle: Pin " + std::to_string(pin) + " every " + std::to_string(intervalMs) + "ms...Press [ENTER] to stop.");
    terminalView.println("");

    unsigned long lastToggle = millis();
    unsigned long lastCheck = millis();

    while (true) {
        unsigned long now = millis();

        // check ENTER press every 10ms
        if (now - lastCheck > 10) {
            lastCheck = now;
            char c = terminalInput.readChar();
            if (c == '\r' || c == '\n') {
                terminalView.println("DIO Toggle: Stopped.");
                break;
            }
        }

        // toggle pin at defined interval
        if (now - lastToggle >= intervalMs) {
            lastToggle = now;
            state = !state;
            if (state) {
                pinService.setHigh(pin);
            } else {
                pinService.setLow(pin);
            }
        }
    }
}

/*
Reset
*/
void DioController::handleResetPin(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty()) {
        terminalView.println("Usage: reset <pin>");
        return;
    }

    if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("DIO Reset: Invalid pin number.");
        return;
    }

    uint8_t pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Reset")) return;

    // Detacher PWM
    ledcDetachPin(pin);

    // Reset Pullup
    pinService.setInput(pin);

    terminalView.println("DIO Reset: Pin " + std::to_string(pin) + " to INPUT (no pull-up, no PWM).");
}

void DioController::handleServo(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty() || cmd.getArgs().empty()) {
        terminalView.println("Usage: servo <pin> <angle>");
        return;
    }

    if (!argTransformer.isValidNumber(cmd.getSubcommand()) ||
        !argTransformer.isValidNumber(cmd.getArgs())) {
        terminalView.println("DIO Servo: Invalid arguments.");
        return;
    }

    uint8_t pin = argTransformer.parseHexOrDec(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Servo")) return;

    uint8_t angle = argTransformer.parseHexOrDec(cmd.getArgs());
    pinService.setServoAngle(pin, angle);
    terminalView.println("DIO Servo: Set pin " + std::to_string(pin) + " to angle " + std::to_string(angle) + ".");
}

/*
Pulse
*/
void DioController::handlePulse(const TerminalCommand& cmd) {
    if (cmd.getSubcommand().empty() || cmd.getArgs().empty()) {
        terminalView.println("Usage: pulse <pin> <duration_us>");
        return;
    }

    if (!argTransformer.isValidNumber(cmd.getSubcommand()) ||
        !argTransformer.isValidNumber(cmd.getArgs())) {
        terminalView.println("DIO Pulse: Invalid arguments.");
        return;
    }

    uint8_t pin = argTransformer.parseHexOrDec(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Pulse")) return;

    uint32_t durationUs = argTransformer.toUint32(cmd.getArgs());

    // Configure en sortie
    pinService.setOutput(pin);

    pinService.setHigh(pin);
    delayMicroseconds(durationUs);
    pinService.setLow(pin);

    terminalView.println("DIO Pulse: Pin " + std::to_string(pin) +
                         " HIGH for " + std::to_string(durationUs) + " µs.");
}

/*
Jam
*/
void DioController::handleJamPin(const TerminalCommand& cmd) {

    auto args = argTransformer.splitArgs(cmd.getArgs());
    uint32_t minUs = 5;
    uint32_t maxUs = 100;

    if (cmd.getSubcommand().empty() || !argTransformer.isValidNumber(cmd.getSubcommand())) {
        terminalView.println("Usage: jam <pin> [min_us] [max_us]");
        return;
    }

    uint8_t pin = argTransformer.toUint8(cmd.getSubcommand());
    if (!isPinAllowed(pin, "Jam")) return;


    if (args.size() >= 1 && argTransformer.isValidNumber(args[0])) {
        minUs = argTransformer.toUint32(args[0]);
    }
    if (args.size() >= 2 && argTransformer.isValidNumber(args[1])) {
        maxUs = argTransformer.toUint32(args[1]);
    }

    if (minUs < 1) minUs = 1;
    if (maxUs < minUs) maxUs = minUs;

    pinService.setOutput(pin);

    terminalView.println("DIO Jam: Pin " + std::to_string(pin) +
                         " random toggle [" + std::to_string(minUs) + ".." + std::to_string(maxUs) +
                         "] us... Press [ENTER] to stop.");
    terminalView.println("");

    bool state = false;
    unsigned long lastCheck = millis();

    while (true) {
        // check ENTER press every 10ms
        if (millis() - lastCheck > 10) {
            lastCheck = millis();
            char c = terminalInput.readChar();
            if (c == '\r' || c == '\n') {
                terminalView.println("DIO Jam: Stopped by user.");
                break;
            }
        }

        state = !state;
        if (state) pinService.setHigh(pin);
        else       pinService.setLow(pin);

        // random delay between minUs and maxUs
        uint32_t span = (maxUs - minUs);
        uint32_t waitUs = minUs + (span ? (esp_random() % (span + 1)) : 0);
        delayMicroseconds(waitUs);
    }
}

/*
Help
*/
void DioController::handleHelp() {
    terminalView.println("\nUnknown command. Available DIO commands:");
    helpShell.run(state.getCurrentMode(), false);
}

bool DioController::isPinAllowed(uint8_t pin, const std::string& context) {
    const auto& protectedPins = state.getProtectedPins();
    
    if (std::find(protectedPins.begin(), protectedPins.end(), pin) != protectedPins.end()) {
        terminalView.println("DIO " + context + ": Pin " + std::to_string(pin) + " is protected and cannot be used.");
        return false;
    }

    if (pin > 48 /* max pin for S3 */) {
        terminalView.println("DIO " + context + ": Pin " + std::to_string(pin) + " is out of range (0-48).");
        return false;
    }

    if (pin < 0) {
        terminalView.println("DIO " + context + ": Pin " + std::to_string(pin) + " is invalid.");
        return false;
    }

    return true;
}

std::vector<std::string> DioController::buildPullConfigLines() {
    std::vector<std::string> lines;

    auto pins = pinService.getConfiguredPullPins();
    std::sort(pins.begin(), pins.end());

    size_t total = 0;

    for (uint8_t pin : pins) {
        auto pull = pinService.getPullType(pin);

        if (pull == PinService::PULL_UP) {
            lines.push_back("GPIO " + std::to_string(pin) + " PULLUP");
        } 
        else if (pull == PinService::PULL_DOWN) {
            lines.push_back("GPIO " + std::to_string(pin) + " PULLDOWN");
        } else {
            continue;
        }

        ++total;

        // Limit to 4 displayable lines
        if (lines.size() == 4) {
            if (pins.size() > total) {
                lines.back() += " ...";
            }
            break;
        }
    }

    return lines;
}