A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol
C arduinobluetoothcan-busdebuggingeepromesp32flipperzerogpiohardware-hackingi2cjtagopenocdprotocolspwmradiorfidspisubghzuartwifi
#include "I2cController.h"
/*
Constructor
*/
I2cController::I2cController(
ITerminalView& terminalView,
IInput& terminalInput,
I2cService& i2cService,
ArgTransformer& argTransformer,
UserInputManager& userInputManager,
I2cEepromShell& eepromShell,
HelpShell& helpShell
)
: terminalView(terminalView),
terminalInput(terminalInput),
i2cService(i2cService),
argTransformer(argTransformer),
userInputManager(userInputManager),
eepromShell(eepromShell),
helpShell(helpShell)
{}
/*
Entry point to handle I2C command
*/
void I2cController::handleCommand(const TerminalCommand& cmd) {
if (cmd.getRoot() == "scan") handleScan();
else if (cmd.getRoot() == "discovery") handleDiscover();
else if (cmd.getRoot() == "sniff") handleSniff();
else if (cmd.getRoot() == "ping") handlePing(cmd);
else if (cmd.getRoot() == "identify") handleIdentify(cmd);
else if (cmd.getRoot() == "write") handleWrite(cmd);
else if (cmd.getRoot() == "read") handleRead(cmd);
else if (cmd.getRoot() == "dump") handleDump(cmd);
else if (cmd.getRoot() == "slave") handleSlave(cmd);
else if (cmd.getRoot() == "glitch") handleGlitch(cmd);
else if (cmd.getRoot() == "flood") handleFlood(cmd);
else if (cmd.getRoot() == "jam") handleJam();
else if (cmd.getRoot() == "eeprom") handleEeprom(cmd);
else if (cmd.getRoot() == "recover") handleRecover();
else if (cmd.getRoot() == "monitor") handleMonitor(cmd);
else if (cmd.getRoot() == "swap") handleSwap();
else if (cmd.getRoot() == "health") handleHealth(cmd);
else if (cmd.getRoot() == "config") handleConfig();
else handleHelp();
}
/*
Entry point to handle I2C instruction
*/
void I2cController::handleInstruction(const std::vector<ByteCode>& bytecodes) {
auto result = i2cService.executeByteCode(bytecodes);
if (!result.empty()) {
terminalView.println("I2C Read:\n");
terminalView.println(result);
}
}
/*
Scan
*/
void I2cController::handleScan() {
terminalView.println("I2C Scan: Scanning I2C bus... Press [ENTER] to stop");
terminalView.println("");
bool found = false;
for (uint8_t addr = 1; addr < 127; ++addr) {
char key = terminalInput.readChar();
if (key == '\r' || key == '\n') {
terminalView.println("I2C Scan: Cancelled by user.");
return;
}
i2cService.beginTransmission(addr);
if (i2cService.endTransmission() == 0) {
std::stringstream ss;
ss << "Found device at 0x" << std::hex << std::uppercase << (int)addr;
terminalView.println(ss.str());
found = true;
}
}
if (!found) {
terminalView.println("I2C Scan: No I2C devices found.");
}
terminalView.println("");
}
/*
Sniff
*/
void I2cController::handleSniff() {
terminalView.println("I2C Sniffer: Listening on SCL/SDA... Press [ENTER] to stop.\n");
i2c_sniffer_begin(state.getI2cSclPin(), state.getI2cSdaPin()); // dont need freq to work
i2c_sniffer_setup();
std::string line;
while (true) {
char key = terminalInput.readChar();
if (key == '\r' || key == '\n') break;
while (i2c_sniffer_available()) {
char c = i2c_sniffer_read();
if (c == '\n') {
line += " ";
terminalView.println(line);
line.clear();
} else {
line += c;
}
}
delayMicroseconds(100);
}
i2c_sniffer_reset_buffer();
i2c_sniffer_stop();
i2cService.configure(state.getI2cSdaPin(), state.getI2cSclPin(), state.getI2cFrequency());
terminalView.println("\n\nI2C Sniffer: Stopped.");
}
/*
Ping
*/
void I2cController::handlePing(const TerminalCommand& cmd) {
if (cmd.getSubcommand().empty()) {
terminalView.println("Usage: ping <I2C address>");
return;
}
const std::string& arg = cmd.getSubcommand();
uint8_t address = 0;
std::stringstream ss(arg);
int temp = 0;
// Detect hex prefix
if (arg.rfind("0x", 0) == 0 || arg.rfind("0X", 0) == 0) {
ss >> std::hex >> temp;
} else {
ss >> std::dec >> temp;
}
if (ss.fail() || temp < 0 || temp > 127) {
terminalView.println("I2C Ping: Invalid address format. Use hex (e.g. 0x3C).");
return;
}
address = static_cast<uint8_t>(temp);
std::stringstream result;
result << "Ping 0x" << std::hex << std::uppercase << (int)address << ": ";
i2cService.beginTransmission(address);
uint8_t i2cResult = i2cService.endTransmission();
if (i2cResult == 0) {
result << "I2C Ping: ACK received! Device is present.";
} else {
result << "I2C Ping: No response (NACK or error).";
}
terminalView.println(result.str());
}
/*
Write
*/
void I2cController::handleWrite(const TerminalCommand& cmd) {
auto args = argTransformer.splitArgs(cmd.getArgs());
// addr
if (cmd.getSubcommand().empty()) {
terminalView.println("Usage: write <addr> [reg] [val]");
return;
}
const std::string& addrStr = cmd.getSubcommand();
if (!argTransformer.isValidNumber(addrStr)) {
terminalView.println("Error: Invalid address. Use decimal or 0x-prefixed hex.");
return;
}
uint8_t addr = argTransformer.parseHexOrDec(addrStr);
// reg
uint8_t reg = 0;
if (args.size() >= 1) {
if (!argTransformer.isValidNumber(args[0])) {
terminalView.println("Error: Invalid register. Use decimal or 0x-prefixed hex.");
return;
}
reg = argTransformer.parseHexOrDec(args[0]);
} else {
reg = (uint8_t)userInputManager.readValidatedByte("Register to write", 0, true);
}
// val
uint8_t val = 0;
if (args.size() >= 2) {
if (!argTransformer.isValidNumber(args[1])) {
terminalView.println("Error: Invalid value. Use decimal or 0x-prefixed hex.");
return;
}
val = argTransformer.parseHexOrDec(args[1]);
} else {
val = (uint8_t)userInputManager.readValidatedByte("Value to write", 0, true);
}
// Ping addr
i2cService.beginTransmission(addr);
uint8_t pingResult = i2cService.endTransmission();
if (pingResult != 0) {
terminalView.println("I2C Ping: 0x" + argTransformer.toHex(addr) + " no response. Aborting write.");
return;
}
// Write
i2cService.beginTransmission(addr);
i2cService.write(reg);
i2cService.write(val);
i2cService.endTransmission(true);
terminalView.println(
"I2C Write: 0x" + argTransformer.toHex(val) +
" -> reg 0x" + argTransformer.toHex(reg) +
" @ dev 0x" + argTransformer.toHex(addr) + "."
);
}
/*
Read
*/
void I2cController::handleRead(const TerminalCommand& cmd) {
// addr
if (cmd.getSubcommand().empty()) {
terminalView.println("Usage: read <addr> [reg]");
return;
}
const std::string& addrStr = cmd.getSubcommand();
if (!argTransformer.isValidNumber(addrStr)) {
terminalView.println("Error: Invalid address. Use decimal or 0x-prefixed hex.");
return;
}
uint8_t addr = argTransformer.parseHexOrDec(addrStr);
// reg
uint8_t reg = 0;
if (!cmd.getArgs().empty()) {
if (!argTransformer.isValidNumber(cmd.getArgs())) {
terminalView.println("Error: Invalid register. Use decimal or 0x-prefixed hex.");
return;
}
reg = argTransformer.parseHexOrDec(cmd.getArgs());
} else {
reg = (uint8_t)userInputManager.readValidatedByte("Register to read", 0, true);
}
// Check I2C device presence
i2cService.beginTransmission(addr);
if (i2cService.endTransmission()) {
terminalView.println("I2C Read: No device found at 0x" + argTransformer.toHex(addr));
return;
}
// Write register address first
i2cService.beginTransmission(addr);
i2cService.write(reg);
i2cService.endTransmission(false);
i2cService.requestFrom(addr, 1);
if (i2cService.available()) {
uint8_t value = (uint8_t)i2cService.read();
terminalView.println(
"I2C Read: 0x" + argTransformer.toHex(value) +
" (" + std::to_string((int)value) + ")" +
" from reg 0x" + argTransformer.toHex(reg) +
" @ dev 0x" + argTransformer.toHex(addr) + "."
);
} else {
terminalView.println("I2C Read: No data available.");
}
}
/*
Config
*/
void I2cController::handleConfig() {
terminalView.println("I2C Configuration:");
const auto& forbidden = state.getProtectedPins();
uint8_t sda = userInputManager.readValidatedPinNumber("SDA pin", state.getI2cSdaPin(), forbidden);
state.setI2cSdaPin(sda);
uint8_t scl = userInputManager.readValidatedPinNumber("SCL pin", state.getI2cSclPin(), forbidden);
state.setI2cSclPin(scl);
uint32_t freq = userInputManager.readValidatedUint32("Frequency", state.getI2cFrequency());
state.setI2cFrequency(freq);
i2cService.configure(sda, scl, freq);
terminalView.println("I2C configured.\n");
}
/*
Slave
*/
void I2cController::handleSlave(const TerminalCommand& cmd) {
if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
terminalView.println("Usage: slave <addr>");
return;
}
// Parse arg
uint8_t addr = argTransformer.parseHexOrDec(cmd.getSubcommand());
uint8_t sda = state.getI2cSdaPin();
uint8_t scl = state.getI2cSclPin();
// Validate arg
if (addr < 0x08 || addr > 0x77) {
terminalView.println("I2C Slave: Invalid address. Must be between 0x08 and 0x77.");
return;
}
terminalView.println("I2C Slave: Listening on address 0x" + argTransformer.toHex(addr) +
"... Press [ENTER] to stop.\n");
// Start slave
i2cService.clearSlaveLog();
i2cService.beginSlave(addr, sda, scl);
std::vector<std::string> currentLog;
currentLog.reserve(I2cService::SLAVE_LOG_MAX);
uint32_t lastLogCount = 0;
std::vector<std::string> lastLog;
while (true) {
// Enter press
char key = terminalInput.readChar();
if (key == '\r' || key == '\n') break;
// Get master log from slave and display it
currentLog = i2cService.getSlaveLog();
uint32_t count = i2cService.getSlaveLogCount();
if (count != lastLogCount) {
currentLog = i2cService.getSlaveLog();
uint32_t delta = count - lastLogCount;
if (delta > currentLog.size()) delta = currentLog.size(); // cap
// DIsplay new entries
size_t start = currentLog.size() - delta;
for (size_t i = start; i < currentLog.size(); ++i) {
terminalView.println(currentLog[i]);
}
lastLogCount = count;
}
}
// Close slave
i2cService.endSlave();
i2cService.clearSlaveLog();
ensureConfigured();
terminalView.println("\nI2S Slave: Stopped by user.");
}
/*
Dump
*/
void I2cController::handleDump(const TerminalCommand& cmd) {
// Validate sub
if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
terminalView.println("Usage: dump <addr> [length]");
return;
}
// Parse addr
uint8_t addr = argTransformer.parseHexOrDec(cmd.getSubcommand());
uint16_t start = 0x00;
uint16_t len = 256;
// Check I2C device presence
i2cService.beginTransmission(addr);
if (i2cService.endTransmission()) {
terminalView.println("I2C Dump: No device found at " + cmd.getSubcommand());
return;
}
// Validate and parse arg
auto args = argTransformer.splitArgs(cmd.getArgs());
if (args.size() >= 1 && argTransformer.isValidNumber(args[0])) {
len = argTransformer.parseHexOrDec16(args[0]);
}
std::vector<uint8_t> values(len, 0xFF);
std::vector<bool> valid(len, false);
// Device registers are readable
if (i2cService.isReadableDevice(addr, start)) {
terminalView.println("I2C Dump: 0x" + argTransformer.toHex(addr) +
" from 0x" + argTransformer.toHex(start) +
" for " + std::to_string(len) + " bytes... Press [ENTER] to stop.\n");
performRegisterRead(addr, start, len, values, valid);
// Not readable
} else {
terminalView.println("I2C Dump: Device at 0x" + argTransformer.toHex(addr) +
" may not use standard register access — trying raw read...");
performRawRead(addr, start, len, values, valid);
}
// Not able to read any data
if (std::all_of(valid.begin(), valid.end(), [](bool b) { return !b; })) {
terminalView.println("I2C Dump: Unable to read any data — device NACKed or unsupported protocol.\n");
return;
}
printHexDump(start, len, values, valid);
}
void I2cController::performRegisterRead(uint8_t addr, uint16_t start, uint16_t len,
std::vector<uint8_t>& values, std::vector<bool>& valid) {
const uint8_t CHUNK_SIZE = 16;
const bool use16bitAddr = (start + len - 1) > 0xFF;
int consecutiveErrors = 0;
for (uint16_t offset = 0; offset < len; offset += CHUNK_SIZE) {
if (consecutiveErrors >= 3) {
terminalView.println("I2C Dump: Aborted after 3 consecutive errors.");
return;
}
uint16_t reg = start + offset;
uint8_t toRead = (offset + CHUNK_SIZE <= len) ? CHUNK_SIZE : (len - offset);
// Write register address (1 or 2 bytes)
i2cService.beginTransmission(addr);
if (use16bitAddr) {
i2cService.write((reg >> 8) & 0xFF); // MSB
i2cService.write(reg & 0xFF); // LSB
} else {
i2cService.write((uint8_t)(reg & 0xFF));
}
bool writeOk = (i2cService.endTransmission(false) == 0); // No stop
if (!writeOk) {
consecutiveErrors++;
continue;
}
// Read chunk
uint8_t received = i2cService.requestFrom(addr, toRead, true);
if (received == toRead) {
for (uint8_t i = 0; i < toRead; ++i) {
char key = terminalInput.readChar();
if (key == '\r' || key == '\n') {
terminalView.println("I2C Dump: Cancelled by user.");
return;
}
if (i2cService.available()) {
values[offset + i] = i2cService.read();
valid[offset + i] = true;
}
}
consecutiveErrors = 0;
} else {
while (i2cService.available()) i2cService.read(); // Flush
consecutiveErrors++;
}
delay(1);
}
}
void I2cController::performRawRead(uint8_t addr, uint16_t start,
uint16_t len,
std::vector<uint8_t>& values,
std::vector<bool>& valid) {
values.assign(len, 0xFF);
valid.assign(len, false);
terminalView.println("I2C Dump: Trying read raw...");
// Write start register
i2cService.beginTransmission(addr);
i2cService.write(start);
if (i2cService.endTransmission(false) != 0) {
return; // NACK
}
// Read len from register addr
uint16_t received = i2cService.requestFrom(addr, (uint8_t)len, true);
for (uint16_t i = 0; i < received && i < len; ++i) {
auto key = terminalInput.readChar();
if (key == '\r' || key == '\n') {
terminalView.println("I2C Dump: Cancelled by user.");
return;
}
if (i2cService.available()) {
values[i] = i2cService.read();
valid[i] = true;
}
}
while (i2cService.available()) i2cService.read();
}
void I2cController::printHexDump(uint16_t start, uint16_t len,
const std::vector<uint8_t>& values, const std::vector<bool>& valid) {
for (uint16_t lineStart = 0; lineStart < len; lineStart += 16) {
std::string line;
char addrStr[8];
snprintf(addrStr, sizeof(addrStr), "%02X:", start + lineStart);
line += addrStr;
for (uint8_t i = 0; i < 16; ++i) {
uint16_t idx = lineStart + i;
if (idx < len) {
if (valid[idx]) {
char hex[4];
snprintf(hex, sizeof(hex), " %02X", values[idx]);
line += hex;
} else {
line += " ??";
}
} else {
line += " ";
}
}
line += " ";
for (uint8_t i = 0; i < 16; ++i) {
uint16_t idx = lineStart + i;
if (idx < len && valid[idx]) {
char c = values[idx];
line += (c >= 32 && c <= 126) ? c : '.';
} else {
line += '.';
}
}
terminalView.println(line);
}
terminalView.println("");
}
/*
Identify
*/
void I2cController::handleIdentify(const TerminalCommand& cmd) {
if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
terminalView.println("Usage: identify <addr>");
return;
}
uint8_t address = argTransformer.parseHexOrDec(cmd.getSubcommand());
terminalView.println(identifyToString(address, true));
}
/*
Recover
*/
void I2cController::handleRecover() {
uint8_t sda = state.getI2cSdaPin();
uint8_t scl = state.getI2cSclPin();
uint32_t freq = state.getI2cFrequency();
terminalView.println("I2C Reset: Attempting to recover I2C bus...");
// Release I2C bus
i2cService.end();
// 16 clock pulse + STOP condition
bool success = i2cService.i2cBitBangRecoverBus(scl, sda, freq);
// Reconfigure I2C
i2cService.configure(sda, scl, freq);
if (success) {
terminalView.println("\nI2C Reset: SDA released. Bus recovery successful.");
} else {
terminalView.println("\nI2C Reset: SDA still LOW after recovery, bus may remain stuck.");
}
}
/*
Glitch
*/
void I2cController::handleGlitch(const TerminalCommand& cmd) {
// Validate arg
if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
terminalView.println("Usage: glitch <addr>");
return;
}
// Parse and get I2C default config
uint8_t addr = argTransformer.parseHexOrDec(cmd.getSubcommand());
uint8_t scl = state.getI2cSclPin();
uint8_t sda = state.getI2cSdaPin();
uint32_t freqHz = state.getI2cFrequency();
// Check I2C device presence
i2cService.beginTransmission(addr);
if (i2cService.endTransmission()) {
terminalView.println("I2C Glitch: No device found at " + cmd.getSubcommand());
return;
}
terminalView.println("I2C Glitch: Attacking device at 0x" + argTransformer.toHex(addr) + "...\n");
delay(500);
terminalView.println(" 1. Flooding with random junk...");
i2cService.floodRandom(addr, freqHz, scl, sda);
delay(50);
terminalView.println(" 2. Flooding START sequences...");
i2cService.floodStart(addr, freqHz, scl, sda);
delay(50);
terminalView.println(" 3. Over-read (read more bytes than expected)...");
i2cService.overReadAttack(addr, freqHz, scl, sda);
delay(50);
terminalView.println(" 4. Reading invalid/unmapped registers...");
i2cService.invalidRegisterRead(addr, freqHz, scl, sda);
delay(50);
terminalView.println(" 5. Simulating clock stretch confusion...");
i2cService.simulateClockStretch(addr, freqHz, scl, sda);
delay(50);
terminalView.println(" 6. Rapid START/STOP sequences...");
i2cService.rapidStartStop(addr, freqHz, scl, sda);
delay(50);
terminalView.println(" 7. Glitching ACK phase...");
i2cService.glitchAckInjection(addr, freqHz, scl, sda);
delay(50);
terminalView.println(" 8. Injecting random noise on SCL/SDA...");
i2cService.randomClockPulseNoise(scl, sda, freqHz);
delay(50);
ensureConfigured();
terminalView.println("\nI2C Glitch: Done. Target may be unresponsive or corrupted.");
}
/*
Flood
*/
void I2cController::handleFlood(const TerminalCommand& cmd) {
// Validate arg
if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
terminalView.println("Usage: flood <addr>");
return;
}
// Parse arg
uint8_t addr = argTransformer.parseHexOrDec(cmd.getSubcommand());
// Check device presence
i2cService.beginTransmission(addr);
if (i2cService.endTransmission()) {
terminalView.println("I2C Flood: No device found at " + cmd.getSubcommand());
return;
}
terminalView.println("I2C Flood: Streaming read to 0x" + argTransformer.toHex(addr) + "... Press [ENTER] to stop.");
while (true) {
// Enter to stop
char key = terminalInput.readChar();
if (key == '\r' || key == '\n') {
terminalView.println("\nI2C Flood: Stopped by user.");
break;
}
// Random register address
uint8_t reg = esp_random() & 0xFF;
// Transmit only register
i2cService.beginTransmission(addr);
i2cService.write(reg);
i2cService.endTransmission(true);
}
}
/*
Jam
*/
void I2cController::handleJam() {
uint8_t scl = state.getI2cSclPin();
uint8_t sda = state.getI2cSdaPin();
uint32_t freqHz = state.getI2cFrequency();
terminalView.println("I2C Jam: Perturbing bus SCL/SDA... Press [ENTER] to stop.\n");
// Release I2C bus
i2cService.end();
while (true) {
char key = terminalInput.readChar();
if (key == '\r' || key == '\n') break;
i2cService.injectRandomGlitch(scl, sda, freqHz);
}
// Try recovering bus after jamming
i2cService.i2cBitBangRecoverBus(scl, sda, freqHz);
// Reconfigure I2C
ensureConfigured();
terminalView.println("\nI2C Jam: Stopped by user.\n");
}
/*
Monitor
*/
void I2cController::handleMonitor(const TerminalCommand& cmd) {
if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
terminalView.println("Usage: monitor <addr> [delay_ms]");
return;
}
uint8_t addr = argTransformer.parseHexOrDec(cmd.getSubcommand());
uint16_t len = 256;
uint32_t delayMs = 500;
// Optional delay
auto args = argTransformer.splitArgs(cmd.getArgs());
if (!args.empty() && argTransformer.isValidNumber(args[0])) {
delayMs = argTransformer.parseHexOrDec32(args[0]);
}
// Check device presence
i2cService.beginTransmission(addr);
if (i2cService.endTransmission()) {
terminalView.println("I2C Monitor: No device found at 0x" + argTransformer.toHex(addr));
return;
}
terminalView.println("I2C Monitor: Monitoring register changes at 0x" + argTransformer.toHex(addr) + "... Press [ENTER] to stop.\n");
std::vector<uint8_t> prev(len, 0xFF);
std::vector<uint8_t> curr(len, 0xFF);
std::vector<bool> valid(len, false);
// First read to initialize prev
if (i2cService.isReadableDevice(addr, 0x00)) {
performRegisterRead(addr, 0x00, len, prev, valid);
} else {
performRawRead(addr, 0x00, len, prev, valid);
}
while (true) {
// Try register read
if (i2cService.isReadableDevice(addr, 0x00)) {
performRegisterRead(addr, 0x00, len, curr, valid);
} else {
performRawRead(addr, 0x00, len, curr, valid);
}
// Compare and show changes
for (uint16_t i = 0; i < len; ++i) {
if (valid[i] && curr[i] != prev[i]) {
std::stringstream ss;
ss << "0x" << std::hex << std::uppercase << std::setw(2) << std::setfill('0') << i
<< ": 0x" << std::setw(2) << (int)prev[i]
<< " -> 0x" << std::setw(2) << (int)curr[i];
terminalView.println(ss.str());
prev[i] = curr[i];
}
}
// Check for user input to stop
uint32_t elapsed = 0;
while (elapsed < delayMs) {
char key = terminalInput.readChar();
if (key == '\r' || key == '\n') {
terminalView.println("\nI2C Monitor: Stopped by user.");
return;
}
delay(10);
elapsed += 10;
}
}
terminalView.println("\nI2C Monitor: Stopped.");
}
/*
EEPROM
*/
void I2cController::handleEeprom(const TerminalCommand& cmd) {
uint8_t addr = 0x50; // Default EEPROM I2C address
auto sub = cmd.getSubcommand();
if (!sub.empty()) {
if (!argTransformer.isValidNumber(sub)) {
terminalView.println("Usage: eeprom [addr]");
return;
}
auto parsed = argTransformer.parseHexOrDec(sub);
if (parsed < 0x03 || parsed > 0x77) { // plage valide I2C 7-bit
terminalView.println("❌ Invalid I2C address. Must be between 0x03 and 0x77.");
return;
}
addr = parsed;
}
eepromShell.run(addr);
ensureConfigured();
}
/*
Help
*/
void I2cController::handleHelp() {
terminalView.println("\nUnknown command. Available I2C commands:");
helpShell.run(state.getCurrentMode(), false);
}
/*
Swap SDA and SCL pins
*/
void I2cController::handleSwap() {
uint8_t sda = state.getI2cSdaPin();
uint8_t scl = state.getI2cSclPin();
// Swap in state
state.setI2cSdaPin(scl);
state.setI2cSclPin(sda);
// Reconfigure I2C with swapped pins
i2cService.configure(state.getI2cSdaPin(), state.getI2cSclPin(), state.getI2cFrequency());
terminalView.println(
"I2C Swap: SDA/SCL swapped. SDA=" + std::to_string(state.getI2cSdaPin()) +
" SCL=" + std::to_string(state.getI2cSclPin())
);
terminalView.println("");
}
/*
Health
*/
void I2cController::handleHealth(const TerminalCommand& cmd) {
// Validate subcommand (addr)
if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
terminalView.println("Usage: health <addr>");
return;
}
uint8_t addr = argTransformer.parseHexOrDec(cmd.getSubcommand());
terminalView.println("I2C Health: Analyzing @ 0x" + argTransformer.toHex(addr) + "... Press [ENTER] to stop.\n");
auto stoppedByUser = [&]() -> bool {
char key = terminalInput.readChar();
return (key == '\r' || key == '\n');
};
/* PING ANALYZE */
terminalView.println("[ACK latency (ping)]");
// Warm up
uint32_t warmDt = 0;
(void)i2cService.ping(addr, true, &warmDt);
delay(1);
const int PING_TRIES = 50;
Stats ping;
for (int i = 0; i < PING_TRIES; ++i) {
if (stoppedByUser()) {
terminalView.println("\nI2C Health: Stopped by user.");
return;
}
uint32_t dt = 0;
bool ok = i2cService.ping(addr, true, &dt);
ping.add(ok, dt);
delay(1);
}
if (ping.ok == 0) {
terminalView.println(" ❌ No ACK received.\n");
return;
}
terminalView.println(" Tries: " + std::to_string(PING_TRIES) +
" Ok: " + std::to_string(ping.ok) +
" Nack: " + std::to_string(ping.nack));
terminalView.println(" Min: " + std::to_string(ping.minUs) + " µs Avg: " +
std::to_string(ping.avgUs()) + " µs Max: " +
std::to_string(ping.maxUs) + " µs\n\r Jitter: " +
std::to_string(ping.jitterUs()) + " µs\n");
/* REGISTER READ ANALYZE */
terminalView.println("[Register read probe]");
uint8_t probeVal = 0;
uint32_t probeDt = 0;
bool regSupported = i2cService.readReg(addr, 0x00, &probeVal, &probeDt);
terminalView.println(std::string(" Supported: ") + (regSupported ? "yes" : "no\n"));
const int READ_TRIES = 50;
Stats rd;
if (regSupported) {
rd.add(true, probeDt);
for (int i = 1; i < READ_TRIES; ++i) {
if (stoppedByUser()) {
terminalView.println("\nI2C Health: Stopped by user.");
return;
}
uint8_t val = 0;
uint32_t dt = 0;
bool ok = i2cService.readReg(addr, 0x00, &val, &dt);
rd.add(ok, dt);
delay(1);
}
if (rd.ok > 0) {
terminalView.println(" Tries: " + std::to_string(READ_TRIES) +
" Ok: " + std::to_string(rd.ok) +
" Nack: " + std::to_string(rd.nack));
terminalView.println(" Min: " + std::to_string(rd.minUs) + " µs Avg: " +
std::to_string(rd.avgUs()) + " µs Max: " +
std::to_string(rd.maxUs) + " µs\n\r Jitter: " +
std::to_string(rd.jitterUs()) + " µs\n");
} else {
terminalView.println(" ❌ No successful register reads\n");
}
}
/* REPORT */
terminalView.println("[Health report for 0x" + argTransformer.toHex(addr) + "]");
uint32_t freq = state.getI2cFrequency();
uint32_t bitUs = (freq > 0) ? (1000000UL / freq) : 10; // fallback 10us
uint32_t pingJ = ping.jitterUs();
uint32_t readJ = (rd.ok > 0) ? rd.jitterUs() : 0;
uint32_t pingThr = 20 * bitUs;
uint32_t readThr = 40 * bitUs;
bool pingStable = (ping.ok > 0) && (ping.nack == 0) && (pingJ <= pingThr);
terminalView.println(pingStable ? " ✅ Stable ACK" : " ⚠️ ACK variability");
if (!regSupported) {
terminalView.println(" Skipped reads (non-standard device)");
} else {
bool readStable = (rd.ok > 0) && (rd.nack == 0) && (readJ <= readThr);
terminalView.println(readStable ? " ✅ Stable reads" : " ⚠️ Read variability");
}
terminalView.println(" Freq=" + std::to_string(freq) + " Hz bit=" + std::to_string(bitUs) + " µs");
if (ping.nack == 0 && pingJ > (200 * bitUs)) {
terminalView.println(" No NACKs but high latency variance.");
}
if (rd.ok > 0 && rd.nack == 0 && readJ > (300 * bitUs)) {
terminalView.println(" Reads are reliable but variable.");
}
terminalView.println("");
}
void I2cController::handleDiscover() {
auto stoppedByUser = [&]() -> bool {
char key = terminalInput.readChar();
return (key == '\r' || key == '\n');
};
terminalView.println("I2C Discover: scanning bus... Press [ENTER] to stop.\n");
/* SCAN */
std::vector<uint8_t> found;
found.reserve(16);
for (uint8_t addr = 1; addr < 0x7F; ++addr) {
if (stoppedByUser()) {
terminalView.println("\nI2C Discover: Stopped by user.");
return;
}
uint32_t dt = 0;
bool ok = i2cService.ping(addr, true, &dt);
if (ok) {
found.push_back(addr);
}
delay(1);
}
if (found.empty()) {
terminalView.println("No I2C device detected.\n");
return;
}
terminalView.println("Found " + std::to_string((int)found.size()) + " device(s):");
for (auto a : found) {
terminalView.println(" - 0x" + argTransformer.toHex(a));
}
terminalView.println("");
/* IDENTIFY */
const int PING_TRIES = 50;
for (size_t idx = 0; idx < found.size(); ++idx) {
uint8_t addr = found[idx];
if (stoppedByUser()) {
terminalView.println("\nI2C Discover: Stopped by user.");
return;
}
terminalView.println("[" + std::to_string((int)(idx + 1)) + "/" +
std::to_string((int)found.size()) + "] Device @ 0x" +
argTransformer.toHex(addr));
std::string info = identifyToString(addr, false);
terminalView.println(info);
// Ping timing
// Warmup
uint32_t warmDt = 0;
(void)i2cService.ping(addr, true, &warmDt);
delay(1);
Stats s;
for (int i = 0; i < PING_TRIES; ++i) {
if (stoppedByUser()) {
terminalView.println("\nI2C Discover: Stopped by user.");
return;
}
uint32_t dt = 0;
bool ok = i2cService.ping(addr, true, &dt);
s.add(ok, dt);
delay(1);
}
terminalView.println(" Ping timing (" + std::to_string(PING_TRIES) + "x):");
terminalView.println(" Ok: " + std::to_string(s.ok) + " Nack: " + std::to_string(s.nack));
if (s.ok > 0) {
terminalView.println(" Min: " + std::to_string(s.minUs) + " µs Avg: " +
std::to_string(s.avgUs()) + " µs Max: " +
std::to_string(s.maxUs) + " µs");
terminalView.println(" Jitter: " + std::to_string(s.jitterUs()) + " µs");
} else {
terminalView.println(" ❌ No ACK during timing run");
}
terminalView.println("");
}
terminalView.println("I2C Discover: done.\n");
}
std::string I2cController::identifyToString(uint8_t address, bool includeHeader) {
std::stringstream ss;
if (includeHeader) {
ss << "\n\r 📟 I2C 0x" + argTransformer.toHex(address) + " Identification Result\n";
}
bool matchFound = false;
for (size_t i = 0; i < i2cknownAddressesCount; ++i) {
if (i2cKnownAddresses[i].address == address) {
matchFound = true;
ss << "\r ➤ Could be: - [" << i2cKnownAddresses[i].type << "] "
<< i2cKnownAddresses[i].component << "\n";
}
}
if (!matchFound) {
ss << "\r ➤ No match found for address 0x" << argTransformer.toHex(address) << "\n";
}
return ss.str();
}
/*
Config
*/
void I2cController::ensureConfigured() {
if (!configured) {
handleConfig();
configured = true;
return;
}
// User could have set the same pin to a different usage
// eg. select I2C then select UART then select I2C
// Always reconfigure pins before use
i2cService.end();
uint8_t sda = state.getI2cSdaPin();
uint8_t scl = state.getI2cSclPin();
uint32_t freq = state.getI2cFrequency();
i2cService.configure(sda, scl, freq);
}