/** * @file debugger.cpp * @brief Implementation of debugging functions for monitoring and diagnostics. * * This file contains the implementation of various debugging functions to monitor * and diagnose the system. It includes functions to print system information, WiFi * details, EEPROM status, dump configuration settings, dump persistence data, show * Diagnostic Trouble Codes (DTCs), and more. * * @author Marcel Peterkau * @date 09.04.2024 */ #include "debugger.h" DebugStatus_t DebuggerStatus[dbg_cntElements]; void processCmdDebug(String command); void Debug_formatCFG(); void Debug_formatPersistence(); void Debug_printSystemInfo(); void Debug_printWifiInfo(); void Debug_CheckEEPOM(bool autocorrect); void Debug_dumpConfig(); void Debug_dumpPersistance(); void Debug_ShowDTCs(); void Debug_dumpGlobals(); void Debug_printHelp(); const char *uint32_to_binary_string(uint32_t num); /** * @brief Initializes the debugger by setting the initial status for different debug ports. * Serial debug output is turned off. */ void initDebugger() { // Set the initial status of debug ports DebuggerStatus[dbg_Serial] = disabled; DebuggerStatus[dbg_Webui] = disabled; // Disable serial debug output Serial.setDebugOutput(false); } /** * @brief Processes incoming debug commands from the Serial interface. * It reads characters from Serial and interprets them as commands. * The recognized commands are processed accordingly. */ void Debug_Process() { // Enumeration for tracking the state of input processing typedef enum InputProcessed_e { IDLE, ///< No command processing is in progress CMD_COMPLETE, ///< Received a complete command CMD_ABORT, ///< Received an abort command (Esc) CMD_OVERFLOW ///< Input buffer overflow occurred } InputProcessed_t; static unsigned int inputCnt = 0; ///< Counter for characters in the input buffer static char inputBuffer[32]; ///< Buffer to store the received characters InputProcessed_t InputProcessed = IDLE; ///< State variable for input processing // Check if there are characters available in the Serial input buffer if (Serial.available()) { char inputChar = Serial.read(); // Process the received character based on its value switch (inputChar) { case '\n': inputBuffer[inputCnt] = 0; // terminate the String inputCnt = 0; InputProcessed = CMD_COMPLETE; Serial.write(inputChar); break; case 0x1B: // Esc inputBuffer[0] = 0; inputCnt = 0; InputProcessed = CMD_ABORT; break; case 0x21 ... 0x7E: // it's a real letter or sign and not some control-chars inputBuffer[inputCnt] = inputChar; inputCnt++; Serial.write(inputChar); break; default: break; } // Check for input buffer overflow if (inputCnt > sizeof(inputBuffer)) { inputCnt = 0; inputBuffer[sizeof(inputBuffer) - 1] = 0; // terminate the String InputProcessed = CMD_OVERFLOW; } } // Process the command based on the detected state of input processing 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; } if (InputProcessed != IDLE) Serial.print(">"); InputProcessed = IDLE; } /** * @brief Sets the status of a specific debug port (Serial or WebUI). * Updates the status in the DebuggerStatus array and provides debug messages. * * @param port The debug port to set the status for (dbg_Serial or dbg_Webui). * @param status The status to set (enabled or disabled). */ void SetDebugportStatus(DebugPorts_t port, DebugStatus_t status) { // Display a debug message based on the provided status if (status == disabled) Debug_pushMessage("Disable DebugPort %s\n", sDebugPorts[port]); // Update the status in the DebuggerStatus array DebuggerStatus[port] = status; // Display a debug message based on the updated status if (status == enabled) Debug_pushMessage("Enabled DebugPort %s\n", sDebugPorts[port]); } /** * @brief Pushes a formatted debug message to the enabled debug ports (Serial or WebUI). * * @param format The format string for the debug message. * @param ... Additional arguments for formatting the message. */ void Debug_pushMessage(const char *format, ...) { // Check if either the Serial or WebUI debug port is enabled if ((DebuggerStatus[dbg_Serial] == enabled) || (DebuggerStatus[dbg_Webui] == enabled)) { char buff[128]; // Buffer to hold the formatted message va_list arg; // Variable argument list for vsnprintf va_start(arg, format); // Format the message and store it in the buffer vsnprintf(buff, sizeof(buff), format, arg); va_end(arg); // Send the message to the Serial debug port if enabled if (DebuggerStatus[dbg_Serial] == enabled) { Serial.print(buff); } // Push the message to the WebUI debug port if enabled if (DebuggerStatus[dbg_Webui] == enabled) { Websocket_PushLiveDebug(String(buff)); } } } /** * @brief Processes a debug command and performs corresponding actions. * * @param command The debug command to be processed. */ void processCmdDebug(String command) { // Check the received command and execute corresponding actions if (command == "help") Debug_printHelp(); else if (command == "sysinfo") 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(false); else if (command == "checkEEfix") Debug_CheckEEPOM(true); else if (command == "dumpEE1k") dumpEEPROM(0, 1024); else if (command == "dumpEE") dumpEEPROM(0, EEPROM_SIZE_BYTES); else if (command == "killEE") writeSequentialToEEPROM(0, 1024); else if (command == "zeroEE") writeZeroToEEPROM(0, 1024); else if (command == "resetPageEE") MovePersistencePage_EEPROM(true); else if (command == "dumpCFG") Debug_dumpConfig(); else if (command == "dumpPDS") Debug_dumpPersistance(); else if (command == "saveEE") globals.requestEEAction = EE_ALL_SAVE; else if (command == "dumpGlobals") Debug_dumpGlobals(); else if (command == "sdbg") SetDebugportStatus(dbg_Serial, enabled); 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()); else if (command == "notify_error") Websocket_PushNotification("Debug Error Notification", error); else if (command == "notify_warning") Websocket_PushNotification("Debug Warning Notification", warning); else if (command == "notify_success") Websocket_PushNotification("Debug Success Notification", success); else if (command == "notify_info") Websocket_PushNotification("Debug Info Notification", info); else Debug_pushMessage("unknown Command\n"); } /** * @brief Formats the Config-EEPROM and resets it to default values. * Prints a debug message after formatting. */ void Debug_formatCFG() { Debug_pushMessage("Formatting Config-EEPROM and resetting to default\n"); FormatConfig_EEPROM(); } /** * @brief Formats the Persistence-EEPROM and resets it to default values. * Prints a debug message after formatting. */ void Debug_formatPersistence() { Debug_pushMessage("Formatting Persistence-EEPROM and resetting to default\n"); FormatPersistence_EEPROM(); } /** * @brief Prints system information and status to the debug output. */ void Debug_printSystemInfo() { Debug_pushMessage("Hostname: %s\n", globals.DeviceName); FlashMode_t ideMode = ESP.getFlashChipMode(); 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" : ideMode == FM_DIO ? "DIO" : ideMode == FM_DOUT ? "DOUT" : "UNKNOWN")); Debug_pushMessage("OTA-Pass: %s\n", QUOTE(ADMIN_PASSWORD)); Debug_pushMessage("Git-Revision: %s\n", constants.GitHash); Debug_pushMessage("Sw-Version: %d.%02d\n", constants.FW_Version_major, constants.FW_Version_minor); } /** * @brief Dumps the current configuration parameters to the debug output. */ void Debug_dumpConfig() { Debug_pushMessage("batteryType: %d\n", ConfigData.batteryType); Debug_pushMessage("Faction_1_Name: %s\n", ConfigData.Faction_1_Name); Debug_pushMessage("Faction_1_Name: %s\n", ConfigData.Faction_2_Name); Debug_pushMessage("Faction_1_Name: %s\n", ConfigData.Faction_3_Name); Debug_pushMessage("active_faction_on_reboot: %d\n", ConfigData.active_faction_on_reboot); Debug_pushMessage("wifi_autoconnect: %d\n", ConfigData.wifi_autoconnect); Debug_pushMessage("wifi_ap_password: %s\n", ConfigData.wifi_ap_password); Debug_pushMessage("wifi_ap_ssid: %s\n", ConfigData.wifi_ap_ssid); Debug_pushMessage("wifi_client_ssid: %s\n", ConfigData.wifi_client_ssid); Debug_pushMessage("wifi_client_password: %s\n", ConfigData.wifi_client_password); Debug_pushMessage("EEPROM_Version: %d\n", ConfigData.EEPROM_Version); Debug_pushMessage("checksum: 0x%08X\n", ConfigData.checksum); } /** * @brief Dumps the global variables and their values to the debug output. */ void Debug_dumpGlobals() { Debug_pushMessage("systemStatus: %d\n", globals.systemStatus); Debug_pushMessage("battery_level: %d\n", globals.battery_level); Debug_pushMessage("loadvoltage_mV: %d\n", globals.loadvoltage_mV); 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("hasDTC: %d\n", globals.hasDTC); } /** * @brief Dumps the persistence data variables and their values to the debug output. */ void Debug_dumpPersistance() { Debug_pushMessage("writeCycleCounter: %d\n", PersistenceData.writeCycleCounter); Debug_pushMessage("activeFaction: %d\n", PersistenceData.activeFaction); Debug_pushMessage("faction_1_timer: %d\n", PersistenceData.faction_1_timer); Debug_pushMessage("faction_2_timer: %d\n", PersistenceData.faction_2_timer); Debug_pushMessage("faction_3_timer: %d\n", PersistenceData.faction_3_timer); Debug_pushMessage("checksum: %d\n", PersistenceData.checksum); Debug_pushMessage("PSD Adress: 0x%04X\n", globals.eePersistanceAdress); } /** * @brief Prints information related to WiFi to the debug output. */ void Debug_printWifiInfo() { Debug_pushMessage("IP Adress: %s\n", WiFi.localIP().toString().c_str()); } /** * @brief Checks the EEPROM data integrity by calculating and comparing checksums. * Prints the result to the debug output. */ void Debug_CheckEEPOM(bool autocorrect) { // Check PersistenceData EEPROM checksum uint32_t checksum = PersistenceData.checksum; PersistenceData.checksum = 0; if (Checksum_EEPROM((uint8_t *)&PersistenceData, sizeof(PersistenceData)) == checksum) { Debug_pushMessage("PersistenceData EEPROM Checksum OK\n"); } else { Debug_pushMessage("PersistenceData EEPROM Checksum BAD\n"); } PersistenceData.checksum = checksum; // Check ConfigData EEPROM checksum checksum = ConfigData.checksum; ConfigData.checksum = 0; if (Checksum_EEPROM((uint8_t *)&ConfigData, sizeof(ConfigData)) == checksum) { Debug_pushMessage("ConfigData EEPROM Checksum OK\n"); } else { Debug_pushMessage("ConfigData EEPROM Checksum BAD\n"); } ConfigData.checksum = checksum; uint32_t sanitycheck = ConfigSanityCheck(autocorrect); if (sanitycheck == 0) { Debug_pushMessage("ConfigData Sanity Check OK\n"); } else { Debug_pushMessage("ConfigData Sanity Check BAD: %s\n", uint32_to_binary_string(sanitycheck)); } } /** * @brief Displays Diagnostic Trouble Codes (DTCs) along with their timestamps, * status, and severity in a formatted manner. */ void Debug_ShowDTCs() { char buff_timestamp[16]; // Format: DD-hh:mm:ss:xxx char buff_active[9]; // Header for the DTC display Debug_pushMessage("\n timestamp | DTC-Nr. | status | severity\n"); // Iterate through DTCStorage and display each entry for (uint32_t i = 0; i < MAX_DTC_STORAGE; i++) { if (DTCStorage[i].Number < DTC_LAST_DTC) { // Format timestamp 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 // Determine DTC status 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"); // Display DTC information Debug_pushMessage("%s %7d %8s %8d\n", buff_timestamp, DTCStorage[i].Number, buff_active); } } } /** * @brief Displays the help commands for debugging through Serial or WebUI. * Each command is printed individually in a formatted manner. */ void Debug_printHelp() { char buff[64]; // Iterate through helpCmd and display each command for (unsigned int i = 0; i < sizeof(helpCmd) / 63; i++) { // Copy a portion of helpCmd to buff for display memcpy_P(buff, (helpCmd + (i * 63)), 63); buff[63] = 0; // Display the help command Debug_pushMessage(buff); } } /** * @brief Convert a uint32_t value to a binary string with nibbles separated by a space. * * This function takes a uint32_t value and converts it to a binary string * representation. The binary string is stored in a static buffer and returned * as a const char pointer. Each nibble (4 bits) in the binary representation * is separated by a space. The buffer is overwritten on subsequent calls to * this function. * * @param num The uint32_t value to convert. * @return A pointer to a const char string containing the binary representation * of the input number with nibbles separated by a space. */ const char *uint32_to_binary_string(uint32_t num) { static char binary_str[65]; // 32 bits + 31 spaces + null terminator int i, j; for (i = 31, j = 0; i >= 0; i--, j++) { binary_str[j] = ((num >> i) & 1) ? '1' : '0'; if (i % 4 == 0 && i != 0) { binary_str[++j] = ' '; // Insert space after every nibble } } binary_str[j] = '\0'; // Null terminator return binary_str; }