Kettenoeler/Software/src/debugger.cpp

347 lines
11 KiB
C++
Raw Normal View History

2023-02-23 23:14:58 +01:00
#include "debugger.h"
2023-02-24 00:05:51 +01:00
DebugStatus_t DebuggerStatus[dbg_cntElements];
2023-02-23 23:14:58 +01:00
String IpAddress2String(const IPAddress &ipAddress);
2023-03-14 23:30:26 +01:00
void processCmdDebug(String command);
2023-02-24 00:52:51 +01:00
void Debug_formatCFG();
void Debug_formatPersistence();
void Debug_printSystemInfo();
void Debug_printWifiInfo();
void Debug_CheckEEPOM();
void Debug_dumpConfig();
void Debug_dumpPersistance();
void Debug_ShowDTCs();
void Debug_dumpGlobals();
2023-03-14 23:30:26 +01:00
void Debug_printHelp();
2023-02-23 23:14:58 +01:00
void initDebugger()
{
2023-02-24 00:05:51 +01:00
DebuggerStatus[dbg_Serial] = disabled;
DebuggerStatus[dbg_Webui] = disabled;
2023-02-23 23:14:58 +01:00
Serial.setDebugOutput(false);
}
2023-03-14 23:30:26 +01:00
void Debug_Process()
{
typedef enum InputProcessed_e
{
IDLE,
CMD_COMPLETE,
CMD_ABORT,
CMD_OVERFLOW
} InputProcessed_t;
2023-09-27 09:59:35 +02:00
static unsigned int inputCnt = 0;
2023-03-14 23:30:26 +01:00
static char inputBuffer[32];
InputProcessed_t InputProcessed = IDLE;
if (Serial.available())
{
char inputChar = Serial.read();
switch (inputChar)
{
case '\n':
inputBuffer[inputCnt] = 0; // terminate the String
inputCnt = 0;
InputProcessed = CMD_COMPLETE;
break;
case 0x1B: // Esc
inputBuffer[0] = 0;
inputCnt = 0;
InputProcessed = CMD_ABORT;
break;
case 0x21 ... 0x7E: // its a real letter or sign and not some control-chars
inputBuffer[inputCnt] = inputChar;
inputCnt++;
break;
default:
break;
}
if (inputCnt > sizeof(inputBuffer))
{
inputCnt = 0;
inputBuffer[sizeof(inputBuffer) - 1] = 0; // terminate the String
InputProcessed = CMD_OVERFLOW;
}
}
switch (InputProcessed)
{
case CMD_ABORT:
Debug_pushMessage("Abort\n");
break;
case CMD_COMPLETE:
processCmdDebug(String(inputBuffer));
break;
case CMD_OVERFLOW:
Debug_pushMessage("input Buffer overflow\n");
break;
default:
break;
}
InputProcessed = IDLE;
}
2023-02-24 00:05:51 +01:00
void SetDebugportStatus(DebugPorts_t port, DebugStatus_t status)
2023-02-23 23:14:58 +01:00
{
2023-02-24 00:05:51 +01:00
if (status == disabled)
2023-03-14 23:30:26 +01:00
Debug_pushMessage("disable DebugPort %s\n", sDebugPorts[port]);
2023-02-24 00:52:51 +01:00
2023-02-24 00:05:51 +01:00
DebuggerStatus[port] = status;
2023-02-23 23:14:58 +01:00
2023-02-24 00:05:51 +01:00
if (status == enabled)
2023-03-14 23:30:26 +01:00
Debug_pushMessage("enabled DebugPort %s\n", sDebugPorts[port]);
2023-02-24 00:05:51 +01:00
}
void Debug_pushMessage(const char *format, ...)
{
if ((DebuggerStatus[dbg_Serial] == enabled) || (DebuggerStatus[dbg_Webui] == enabled))
2023-02-23 23:14:58 +01:00
{
2023-02-24 00:05:51 +01:00
char buff[64];
va_list arg;
va_start(arg, format);
vsnprintf(buff, sizeof(buff), format, arg);
va_end(arg);
if (DebuggerStatus[dbg_Serial] == enabled)
{
Serial.print(buff);
}
if (DebuggerStatus[dbg_Webui] == enabled)
{
Websocket_PushLiveDebug(String(buff));
}
2023-02-23 23:14:58 +01:00
}
}
2023-02-24 00:05:51 +01:00
void pushCANDebug(uint32_t id, uint8_t dlc, uint8_t *data)
2023-02-23 23:14:58 +01:00
{
2023-02-24 00:05:51 +01:00
if ((DebuggerStatus[dbg_Serial] == enabled) || (DebuggerStatus[dbg_Webui] == enabled))
2023-02-23 23:14:58 +01:00
{
char buff[100];
char *p = buff;
p += snprintf(p, sizeof(buff), "CAN: 0x%08X | %d | ", id, dlc);
for (int i = 0; i < dlc; i++)
{
p += snprintf(p, sizeof(buff) - (p - buff), "%02X ", data[i]);
}
*(p++) = '\n';
*p = '\0';
2023-02-24 00:05:51 +01:00
if (DebuggerStatus[dbg_Serial] == enabled)
{
Serial.print(buff);
}
if (DebuggerStatus[dbg_Webui] == enabled)
{
Websocket_PushLiveDebug(String(buff));
}
2023-02-23 23:14:58 +01:00
}
}
2023-02-24 00:52:51 +01:00
void processCmdDebug(String command)
2023-02-23 23:14:58 +01:00
{
2023-03-14 23:30:26 +01:00
if (command == "help")
Debug_printHelp();
else if (command == "sysinfo")
2023-02-24 00:52:51 +01:00
Debug_printSystemInfo();
else if (command == "netinfo")
Debug_printWifiInfo();
else if (command == "formatCFG")
Debug_formatCFG();
else if (command == "formatPDS")
Debug_formatPersistence();
else if (command == "checkEE")
Debug_CheckEEPOM();
else if (command == "dumpEE1k")
2023-02-23 23:14:58 +01:00
dumpEEPROM(0, 1024);
2023-02-24 00:52:51 +01:00
else if (command == "dumpEE")
2023-02-23 23:14:58 +01:00
dumpEEPROM(0, EEPROM_SIZE_BYTES);
2023-02-24 00:52:51 +01:00
else if (command == "resetPageEE")
2023-02-23 23:14:58 +01:00
MovePersistencePage_EEPROM(true);
2023-02-24 00:52:51 +01:00
else if (command == "dumpCFG")
Debug_dumpConfig();
else if (command == "dumpPDS")
Debug_dumpPersistance();
else if (command == "saveEE")
2023-02-23 23:14:58 +01:00
globals.requestEEAction = EE_ALL_SAVE;
2023-02-24 00:52:51 +01:00
else if (command == "dumpGlobals")
Debug_dumpGlobals();
2023-03-14 23:30:26 +01:00
else if (command == "sdbg")
SetDebugportStatus(dbg_Serial, enabled);
2023-12-04 02:18:16 +01:00
else if (command == "dtc_show")
Debug_ShowDTCs();
else if (command == "dtc_clear")
ClearAllDTC();
else if (command == "dtc_crit")
MaintainDTC(DTC_FAKE_DTC_CRIT, true, millis());
else if (command == "dtc_warn")
MaintainDTC(DTC_FAKE_DTC_WARN, true, millis());
else if (command == "dtc_info")
MaintainDTC(DTC_FAKE_DTC_INFO, true, millis());
2023-03-14 23:30:26 +01:00
else
Debug_pushMessage("unknown Command\n");
2023-02-23 23:14:58 +01:00
}
2023-02-24 00:52:51 +01:00
void Debug_formatCFG()
2023-02-23 23:14:58 +01:00
{
2023-03-14 23:30:26 +01:00
Debug_pushMessage("Formatting Config-EEPROM and reseting to default\n");
2023-02-23 23:14:58 +01:00
FormatConfig_EEPROM();
}
2023-02-24 00:52:51 +01:00
void Debug_formatPersistence()
2023-02-23 23:14:58 +01:00
{
2023-03-14 23:30:26 +01:00
Debug_pushMessage("Formatting Persistence-EEPROM and reseting to default\n");
2023-02-23 23:14:58 +01:00
FormatPersistence_EEPROM();
}
2023-03-14 23:30:26 +01:00
void Debug_printSystemInfo()
2023-02-23 23:14:58 +01:00
{
2023-03-14 23:30:26 +01:00
Debug_pushMessage("Souko's ChainOiler Mk1\n");
Debug_pushMessage("Hostname: %s\n", globals.DeviceName);
2023-02-23 23:14:58 +01:00
FlashMode_t ideMode = ESP.getFlashChipMode();
2023-03-14 23:30:26 +01:00
Debug_pushMessage("Sdk version: %s\n", ESP.getSdkVersion());
Debug_pushMessage("Core Version: %s\n", ESP.getCoreVersion().c_str());
Debug_pushMessage("Boot Version: %u\n", ESP.getBootVersion());
Debug_pushMessage("Boot Mode: %u\n", ESP.getBootMode());
Debug_pushMessage("CPU Frequency: %u MHz\n", ESP.getCpuFreqMHz());
Debug_pushMessage("Reset reason: %s\n", ESP.getResetReason().c_str());
Debug_pushMessage("Flash Size: %d\n", ESP.getFlashChipRealSize());
Debug_pushMessage("Flash Size IDE: %d\n", ESP.getFlashChipSize());
Debug_pushMessage("Flash ide mode: %s\n", (ideMode == FM_QIO ? "QIO" : ideMode == FM_QOUT ? "QOUT"
2023-12-04 02:18:16 +01:00
: ideMode == FM_DIO ? "DIO"
: ideMode == FM_DOUT ? "DOUT"
: "UNKNOWN"));
2023-03-14 23:30:26 +01:00
Debug_pushMessage("OTA-Pass: %s\n", QUOTE(ADMIN_PASSWORD));
Debug_pushMessage("Git-Revison: %s\n", constants.GitHash);
Debug_pushMessage("Sw-Version: %d.%02d\n", constants.FW_Version_major, constants.FW_Version_minor);
2023-02-23 23:14:58 +01:00
}
2023-02-24 00:52:51 +01:00
void Debug_dumpConfig()
2023-02-23 23:14:58 +01:00
{
2023-03-14 23:30:26 +01:00
Debug_pushMessage("DistancePerLube_Default: %d\n", LubeConfig.DistancePerLube_Default);
Debug_pushMessage("DistancePerLube_Rain: %d\n", LubeConfig.DistancePerLube_Rain);
Debug_pushMessage("tankCapacity_ml: %d\n", LubeConfig.tankCapacity_ml);
Debug_pushMessage("amountPerDose_microL: %d\n", LubeConfig.amountPerDose_microL);
Debug_pushMessage("TankRemindAtPercentage: %d\n", LubeConfig.TankRemindAtPercentage);
Debug_pushMessage("PulsePerRevolution: %d\n", LubeConfig.PulsePerRevolution);
Debug_pushMessage("TireWidth_mm: %d\n", LubeConfig.TireWidth_mm);
Debug_pushMessage("TireWidthHeight_Ratio: %d\n", LubeConfig.TireWidth_mm);
Debug_pushMessage("RimDiameter_Inch: %d\n", LubeConfig.RimDiameter_Inch);
Debug_pushMessage("DistancePerRevolution_mm: %d\n", LubeConfig.DistancePerRevolution_mm);
Debug_pushMessage("BleedingPulses: %d\n", LubeConfig.BleedingPulses);
Debug_pushMessage("SpeedSource: %d\n", LubeConfig.SpeedSource);
Debug_pushMessage("GPSBaudRate: %d\n", LubeConfig.GPSBaudRate);
Debug_pushMessage("CANSource: %d\n", LubeConfig.CANSource);
Debug_pushMessage("checksum: 0x%08X\n", LubeConfig.checksum);
2023-02-23 23:14:58 +01:00
}
2023-02-24 00:52:51 +01:00
void Debug_dumpGlobals()
2023-02-23 23:14:58 +01:00
{
2023-03-14 23:30:26 +01:00
Debug_pushMessage("systemStatus: %d\n", globals.systemStatus);
Debug_pushMessage("resumeStatus: %d\n", globals.resumeStatus);
Debug_pushMessage("systemStatustxt: %s\n", globals.systemStatustxt);
Debug_pushMessage("purgePulses: %d\n", globals.purgePulses);
Debug_pushMessage("requestEEAction: %d\n", globals.requestEEAction);
Debug_pushMessage("DeviceName: %s\n", globals.DeviceName);
Debug_pushMessage("FlashVersion: %s\n", globals.FlashVersion);
Debug_pushMessage("eePersistanceAdress: %d\n", globals.eePersistanceAdress);
Debug_pushMessage("TankPercentage: %d\n", globals.TankPercentage);
Debug_pushMessage("hasDTC: %d\n", globals.hasDTC);
2023-02-23 23:14:58 +01:00
}
2023-02-24 00:52:51 +01:00
void Debug_dumpPersistance()
2023-02-23 23:14:58 +01:00
{
2023-03-14 23:30:26 +01:00
Debug_pushMessage("writeCycleCounter: %d\n", PersistenceData.writeCycleCounter);
Debug_pushMessage("tankRemain_microL: %d\n", PersistenceData.tankRemain_microL);
Debug_pushMessage("TravelDistance_highRes_mm: %d\n", PersistenceData.TravelDistance_highRes_mm);
Debug_pushMessage("checksum: %d\n", PersistenceData.checksum);
Debug_pushMessage("PSD Adress: 0x%04X\n", globals.eePersistanceAdress);
2023-02-23 23:14:58 +01:00
}
2023-02-24 00:52:51 +01:00
void Debug_printWifiInfo()
2023-02-23 23:14:58 +01:00
{
}
2023-02-24 00:52:51 +01:00
void Debug_CheckEEPOM()
2023-02-23 23:14:58 +01:00
{
uint32_t checksum = PersistenceData.checksum;
PersistenceData.checksum = 0;
if (Checksum_EEPROM((uint8_t *)&PersistenceData, sizeof(PersistenceData)) == checksum)
{
2023-02-24 00:52:51 +01:00
Debug_pushMessage("PersistenceData EEPROM Checksum OK\n");
2023-02-23 23:14:58 +01:00
}
else
{
2023-02-24 00:52:51 +01:00
Debug_pushMessage("PersistenceData EEPROM Checksum BAD\n");
2023-02-23 23:14:58 +01:00
}
PersistenceData.checksum = checksum;
checksum = LubeConfig.checksum;
LubeConfig.checksum = 0;
if (Checksum_EEPROM((uint8_t *)&LubeConfig, sizeof(LubeConfig)) == checksum)
{
2023-02-24 00:52:51 +01:00
Debug_pushMessage("LubeConfig EEPROM Checksum OK\n");
2023-02-23 23:14:58 +01:00
}
else
{
2023-02-24 00:52:51 +01:00
Debug_pushMessage("LubeConfig EEPROM Checksum BAD\n");
2023-02-23 23:14:58 +01:00
}
LubeConfig.checksum = checksum;
}
2023-02-24 00:52:51 +01:00
void Debug_ShowDTCs()
2023-02-23 23:14:58 +01:00
{
char buff_timestamp[16]; // Format: DD-hh:mm:ss:xxx
char buff_active[9];
2023-03-18 15:20:16 +01:00
Debug_pushMessage("\n timestamp | DTC-Nr. | status | severity\n");
2023-02-23 23:14:58 +01:00
for (uint32_t i = 0; i < MAX_DTC_STORAGE; i++)
{
if (DTCStorage[i].Number < DTC_LAST_DTC)
{
sprintf(buff_timestamp, "%02d-%02d:%02d:%02d:%03d",
DTCStorage[i].timestamp / 86400000, // Days
DTCStorage[i].timestamp / 360000 % 24, // Hours
DTCStorage[i].timestamp / 60000 % 60, // Minutes
DTCStorage[i].timestamp / 1000 % 60, // Seconds
DTCStorage[i].timestamp % 1000); // milliseconds
if (DTCStorage[i].active == DTC_ACTIVE)
strcpy(buff_active, "active");
else if (DTCStorage[i].active == DTC_PREVIOUS)
strcpy(buff_active, "previous");
else
strcpy(buff_active, "none");
2023-09-27 19:13:54 +02:00
Debug_pushMessage("%s %7d %8s %8d\n", buff_timestamp, DTCStorage[i].Number, buff_active);
2023-02-23 23:14:58 +01:00
}
}
2023-03-14 23:30:26 +01:00
}
void Debug_printHelp()
{
char buff[64];
2023-09-27 09:59:35 +02:00
for (unsigned int i = sizeof(helpCmd) / 63; i < sizeof(helpCmd) / 63; i++)
2023-03-14 23:30:26 +01:00
{
memcpy_P(buff, (helpCmd + (i * 63)), 63);
buff[63] = 0;
Debug_pushMessage(buff);
}
2023-02-24 00:52:51 +01:00
}