diff --git a/MODULES/HVAC_M7_DataNonVolatile/VIN_DATA.c b/MODULES/HVAC_M7_DataNonVolatile/VIN_DATA.c new file mode 100644 index 0000000..a553977 --- /dev/null +++ b/MODULES/HVAC_M7_DataNonVolatile/VIN_DATA.c @@ -0,0 +1,77 @@ +// +// Created by cfif on 31.08.2026. +// +#include +#include "VIN_DATA.h" + +static uint8_t getVehicleTypeFromVin(const char* vin) { + + // Преобразуем два байта в 16-битное значение + uint16_t typeCode = ((uint16_t)(unsigned char)vin[3] << 8) | (unsigned char)vin[4]; + + // Определяем Vehicle TYPE по коду + switch (typeCode) { + // Vehicle TYPE = 1 + case VEHICLE_SEDAN_NON_ARMORED: + case VEHICLE_CABRIO: + case VEHICLE_SEDAN_4X2: + case VEHICLE_SEDAN_LONG: + case VEHICLE_CABRIO_SHOW: + return 1; + + // Vehicle TYPE = 2 + case VEHICLE_SEDAN_ARMORED: + case VEHICLE_SEDAN_LONG_ARMORED: + return 2; + + // Vehicle TYPE = 3 + case VEHICLE_LIMO_ARMORED_V12: + case VEHICLE_LIMO_ARMORED_V8: + case VEHICLE_LIMO_ARMORED_V8_CIVIL: + return 3; + + // Vehicle TYPE = 4 + case VEHICLE_SUV_NON_ARMORED: + case VEHICLE_SUV_ARMORED: + return 4; + + // Vehicle TYPE = 5 + case VEHICLE_MPV_NON_ARMORED_4SEAT: + case VEHICLE_MPV_ARMORED_8SEAT: + case VEHICLE_MPV_NON_ARMORED_9SEAT: + case VEHICLE_MPV_ARMORED_9SEAT: + case VEHICLE_MPV_ARMORED_4SEAT: + case VEHICLE_MPV_ORBITA: + case VEHICLE_MPV_TABLETKA: + return 5; + + default: + return 0; // Неизвестный тип + } +} + +uint8_t setVehicleTypeFromVinToCalib(const char* vin) { + uint8_t Vehicle_TYPE = getVehicleTypeFromVin(vin); + + // Определяем Vehicle TYPE по коду + switch (Vehicle_TYPE) { + case 1: + Rs_Cal_0_SedanL(); + return 1; + case 2: + Rs_Cal_1_SedanH(); + return 2; + case 3: + Rs_Cal_2_Limo(); + return 3; + case 4: + Rs_Cal_3_Suv(); + return 4; + case 5: + Rs_Cal_4_Mpv(); + return 5; + default: + Rs_Cal_0_SedanL(); + return 0; // Неизвестный тип + } +} \ No newline at end of file diff --git a/MODULES/HVAC_M7_DataNonVolatile/VIN_DATA.h b/MODULES/HVAC_M7_DataNonVolatile/VIN_DATA.h new file mode 100644 index 0000000..334eca6 --- /dev/null +++ b/MODULES/HVAC_M7_DataNonVolatile/VIN_DATA.h @@ -0,0 +1,51 @@ +// +// Created by cfif on 31.08.2026. +// +#ifndef HVAC_M7_VIN_DATA_H +#define HVAC_M7_VIN_DATA_H + +#include +#include +#include "Rs_Cal_0_SedanL.h" +#include "Rs_Cal_1_SedanH.h" +#include "Rs_Cal_2_Limo.h" +#include "Rs_Cal_3_Suv.h" +#include "Rs_Cal_4_Mpv.h" + +// Коды типов автомобилей +typedef enum { + VEHICLE_TYPE_UNKNOWN = 0x0000, + + // Vehicle TYPE = 1 + VEHICLE_SEDAN_NON_ARMORED = 0x3030, // '00' - Седан небронированный + VEHICLE_CABRIO = 0x3035, // '05' - Кабриолет + VEHICLE_SEDAN_4X2 = 0x3038, // '08' - Седан 4x2 (не используется в Phase1) + VEHICLE_SEDAN_LONG = 0x3039, // '09' - Седан длинный + VEHICLE_CABRIO_SHOW = 0x3042, // '0B' - Кабриолет шоу (не используется в Phase1) + + // Vehicle TYPE = 2 + VEHICLE_SEDAN_ARMORED = 0x3031, // '01' - Седан бронированный + VEHICLE_SEDAN_LONG_ARMORED = 0x3041, // '0A' - Седан длинный бронированный + + // Vehicle TYPE = 3 + VEHICLE_LIMO_ARMORED_V12 = 0x3033, // '03' - Лимузин бронированный V12 + VEHICLE_LIMO_ARMORED_V8 = 0x3034, // '04' - Лимузин бронированный V8 + VEHICLE_LIMO_ARMORED_V8_CIVIL = 0x3043, // '0C' - Лимузин бронированный V8 гражданский (не используется) + + // Vehicle TYPE = 4 + VEHICLE_SUV_NON_ARMORED = 0x3132, // '12' - Внедорожник небронированный + VEHICLE_SUV_ARMORED = 0x3133, // '13' - Внедорожник бронированный + + // Vehicle TYPE = 5 + VEHICLE_MPV_NON_ARMORED_4SEAT = 0x3230, // '20' - Минивэн небронированный 4-местный + VEHICLE_MPV_ARMORED_8SEAT = 0x3231, // '21' - Минивэн бронированный 8-местный + VEHICLE_MPV_NON_ARMORED_9SEAT = 0x3232, // '22' - Минивэн небронированный 9-местный + VEHICLE_MPV_ARMORED_9SEAT = 0x3233, // '23' - Минивэн бронированный 9-местный + VEHICLE_MPV_ARMORED_4SEAT = 0x3237, // '27' - Минивэн бронированный 4-местный + VEHICLE_MPV_ORBITA = 0x3238, // '28' - Минивэн "Орбита" + VEHICLE_MPV_TABLETKA = 0x3239, // '29' - Минивэн "Таблетка" +} VehicleType_t; + +uint8_t setVehicleTypeFromVinToCalib(const char* vin); + +#endif //HVAC_M7_VIN_DATA_H diff --git a/MODULES/HVAC_M7_DebugTesting/CheckReset.c b/MODULES/HVAC_M7_DebugTesting/CheckReset.c new file mode 100644 index 0000000..ae704a4 --- /dev/null +++ b/MODULES/HVAC_M7_DebugTesting/CheckReset.c @@ -0,0 +1,939 @@ +// +// Created by cfif on 31.08.2026. +// +/* +#include +#include +#include "MainModesArbiter_Private.h" +#include "core_cm7_regs.h" +#include "fc7240_rgm_regs.h" // Заголовочный файл RGM + +#define LOGGER &env->slog.logger + +const char LOG_TASK_MAIN[] = "Init"; + +// Макрос для проверки активности отладчика +#define CHECK_JTAG_DEBUG_ACTIVE ((CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk) != 0) + +// Источники сброса для Cortex-M7 +typedef enum { + RESET_SOURCE_UNKNOWN = 0, + RESET_SOURCE_POWER_ON, // Сброс при включении питания (POR) + RESET_SOURCE_EXTERNAL, // Сброс по внешнему сигналу (NRST) + RESET_SOURCE_WATCHDOG, // Сброс от сторожевого таймера + RESET_SOURCE_SOFTWARE, // Сброс по команде NVIC_SystemReset() + RESET_SOURCE_LOCKUP, // Сброс из-за блокировки ядра (Lockup) + RESET_SOURCE_DEBUG, // Сброс отладчиком + RESET_SOURCE_BROWNOUT, // Сброс при падении напряжения (LVR) + RESET_SOURCE_OPTION_BYTE, // Сброс из-за изменения option bytes + RESET_SOURCE_FIREWALL, // Сброс от Firewall + RESET_SOURCE_MPU, // Сброс из-за нарушения MPU + RESET_SOURCE_BUS_FAULT, // Сброс из-за Bus Fault + RESET_SOURCE_USAGE_FAULT, // Сброс из-за Usage Fault + RESET_SOURCE_MEM_FAULT, // Сброс из-за Memory Management Fault + RESET_SOURCE_CLOCK_ERROR, // Сброс из-за ошибки тактирования + RESET_SOURCE_WAKEUP, // Сброс при пробуждении + RESET_SOURCE_HSM_WATCHDOG, // Сброс от HSM watchdog +} ResetSource_t; + + +static inline bool IsDebuggerConnected(void) +{ + return CHECK_JTAG_DEBUG_ACTIVE; +} + +static inline bool IsHardFaultOccurred(void) +{ + // Проверяем наличие Hard Fault в регистре HFSR + return (SCB->HFSR & (SCB_HFSR_DEBUGEVT_Msk | + SCB_HFSR_FORCED_Msk | + SCB_HFSR_VECTTBL_Msk)) != 0; +} + + +static inline bool IsLockupOccurred(void) +{ + // Проверяем бит S_LOCKUP в DHCSR + return (CoreDebug->DHCSR & CoreDebug_DHCSR_S_LOCKUP_Msk) != 0; +} + + +static bool CheckFaultStatus(const char **fault_type) +{ + // Проверяем CFSR (Configurable Fault Status Register) + uint32_t cfsr = SCB->CFSR; + + if (cfsr & SCB_CFSR_MEMFAULTSR_Msk) { + *fault_type = "Memory Management Fault"; + return true; + } + + if (cfsr & SCB_CFSR_BUSFAULTSR_Msk) { + *fault_type = "Bus Fault"; + return true; + } + + if (cfsr & SCB_CFSR_USGFAULTSR_Msk) { + *fault_type = "Usage Fault"; + return true; + } + + return false; +} + + +ResetSource_t GetResetSource(void) +{ + // ======================================== + // 1. Проверяем CoreDebug->DHCSR + // ======================================== + uint32_t dhcsr = CoreDebug->DHCSR; + + // Сброс отладчиком (бит S_RESET_ST) + if (dhcsr & CoreDebug_DHCSR_S_RESET_ST_Msk) { + return RESET_SOURCE_DEBUG; + } + + // Lockup (зависание ядра) - бит S_LOCKUP + if (dhcsr & CoreDebug_DHCSR_S_LOCKUP_Msk) { + return RESET_SOURCE_LOCKUP; + } + + // Состояние HALT (остановка ядра отладчиком) + if (dhcsr & CoreDebug_DHCSR_S_HALT_Msk) { + return RESET_SOURCE_DEBUG; + } + + // ======================================== + // 2. Проверяем SCB (System Control Block) + // ======================================== + + // Hard Fault (SCB->HFSR) + if (SCB->HFSR & SCB_HFSR_FORCED_Msk) { + // Определяем конкретный тип fault'а через SCB->CFSR + if (SCB->CFSR & SCB_CFSR_MEMFAULTSR_Msk) { + return RESET_SOURCE_MEM_FAULT; + } + if (SCB->CFSR & SCB_CFSR_BUSFAULTSR_Msk) { + return RESET_SOURCE_BUS_FAULT; + } + if (SCB->CFSR & SCB_CFSR_USGFAULTSR_Msk) { + return RESET_SOURCE_USAGE_FAULT; + } + return RESET_SOURCE_LOCKUP; + } + + // Ошибка вектора таблицы (VECTTBL) + if (SCB->HFSR & SCB_HFSR_VECTTBL_Msk) { + return RESET_SOURCE_LOCKUP; + } + + // Debug Fault (SCB->DFSR) + if (SCB->DFSR & (SCB_DFSR_EXTERNAL_Msk | + SCB_DFSR_VCATCH_Msk | + SCB_DFSR_DWTTRAP_Msk | + SCB_DFSR_BKPT_Msk | + SCB_DFSR_HALTED_Msk)) { + return RESET_SOURCE_DEBUG; + } + + // ======================================== + // 3. Проверяем CoreDebug->DEMCR + // ======================================== + + // Векторный catch для различных ошибок + if (CoreDebug->DEMCR & (CoreDebug_DEMCR_VC_HARDERR_Msk | + CoreDebug_DEMCR_VC_INTERR_Msk | + CoreDebug_DEMCR_VC_BUSERR_Msk | + CoreDebug_DEMCR_VC_STATERR_Msk | + CoreDebug_DEMCR_VC_CHKERR_Msk | + CoreDebug_DEMCR_VC_NOCPERR_Msk | + CoreDebug_DEMCR_VC_MMERR_Msk | + CoreDebug_DEMCR_VC_CORERESET_Msk)) { + return RESET_SOURCE_DEBUG; + } + + // ======================================== + // 4. Проверяем RGM->SRS (System Reset Status) + // ======================================== + uint32_t srs = RGM->SRS; + + // Power-on reset + if (srs & RGM_SRS_POR_MASK) { + return RESET_SOURCE_POWER_ON; + } + + // External pin reset (NRST) + if (srs & RGM_SRS_PIN_MASK) { + return RESET_SOURCE_EXTERNAL; + } + + // Watchdog 1 reset + if (srs & RGM_SRS_WDOG1_MASK) { + return RESET_SOURCE_WATCHDOG; + } + + // HSM Watchdog reset + if (srs & RGM_SRS_HSM_WDOG_MASK) { + return RESET_SOURCE_HSM_WATCHDOG; + } + + // JTAG reset + if (srs & RGM_SRS_JTAG_MASK) { + return RESET_SOURCE_DEBUG; + } + + // Low Voltage Reset (Brown-out) + if (srs & RGM_SRS_LVR_MASK) { + return RESET_SOURCE_BROWNOUT; + } + + // Clock error reset + if (srs & (RGM_SRS_CLKERR0_MASK | RGM_SRS_CLKERR1_MASK)) { + return RESET_SOURCE_CLOCK_ERROR; + } + + // Wakeup reset + if (srs & RGM_SRS_WAKEUP_MASK) { + return RESET_SOURCE_WAKEUP; + } + + // System AP reset + if (srs & RGM_SRS_SYSAP_MASK) { + return RESET_SOURCE_SOFTWARE; + } + + // System ACK error + if (srs & RGM_SRS_SACKERR_MASK) { + return RESET_SOURCE_LOCKUP; + } + + // CMU reset + if (srs & RGM_SRS_CMU_MASK) { + return RESET_SOURCE_CLOCK_ERROR; + } + + // LBIST reset + if (srs & RGM_SRS_LBIST_MASK) { + return RESET_SOURCE_POWER_ON; + } + + // ======================================== + // 5. Проверяем RGM->C0_SRS (CPU0 Reset Status) + // ======================================== + uint32_t c0_srs = RGM->C0_SRS; + + // CPU software reset + if (c0_srs & RGM_C0_SRS_C0_SWRST_MASK) { + return RESET_SOURCE_SOFTWARE; + } + + // CPU watchdog reset + if (c0_srs & RGM_C0_SRS_C0_WDOG_MASK) { + return RESET_SOURCE_WATCHDOG; + } + + // CPU Lockup + if (c0_srs & RGM_C0_SRS_C0_LOCKUP_MASK) { + return RESET_SOURCE_LOCKUP; + } + + // CPU System Reset + if (c0_srs & RGM_C0_SRS_C0_SYSRST_MASK) { + return RESET_SOURCE_SOFTWARE; + } + + // CPU Interrupt reset + if (c0_srs & RGM_C0_SRS_C0_INTM_MASK) { + return RESET_SOURCE_LOCKUP; + } + + // ======================================== + // 6. Проверяем наличие отладчика + // ======================================== + if (dhcsr & CoreDebug_DHCSR_C_DEBUGEN_Msk) { + // Отладчик подключен, но другие признаки не обнаружены + if (dhcsr & (CoreDebug_DHCSR_C_HALT_Msk | + CoreDebug_DHCSR_C_STEP_Msk)) { + return RESET_SOURCE_DEBUG; + } + } + + return RESET_SOURCE_UNKNOWN; +} + +static const char* GetResetSourceString(ResetSource_t source) +{ + switch (source) { + case RESET_SOURCE_UNKNOWN: return "Unknown reset source"; + case RESET_SOURCE_POWER_ON: return "Power-on reset (POR)"; + case RESET_SOURCE_EXTERNAL: return "External reset (NRST pin)"; + case RESET_SOURCE_WATCHDOG: return "Watchdog reset (IWDG/WWDG)"; + case RESET_SOURCE_SOFTWARE: return "Software reset (NVIC_SystemReset)"; + case RESET_SOURCE_LOCKUP: return "Core Lockup reset"; + case RESET_SOURCE_DEBUG: return "Debugger reset"; + case RESET_SOURCE_BROWNOUT: return "Low Voltage reset (LVR)"; + case RESET_SOURCE_OPTION_BYTE: return "Option byte reset"; + case RESET_SOURCE_FIREWALL: return "Firewall reset"; + case RESET_SOURCE_MPU: return "MPU violation reset"; + case RESET_SOURCE_BUS_FAULT: return "Bus Fault reset"; + case RESET_SOURCE_USAGE_FAULT: return "Usage Fault reset"; + case RESET_SOURCE_MEM_FAULT: return "Memory Management Fault reset"; + case RESET_SOURCE_CLOCK_ERROR: return "Clock error reset"; + case RESET_SOURCE_WAKEUP: return "Wakeup reset"; + case RESET_SOURCE_HSM_WATCHDOG: return "HSM Watchdog reset"; + default: return "Unknown reset source"; + } +} + + +void PrintResetSource(tMma *env) +{ + // Проверяем режим отладки + if (CHECK_JTAG_DEBUG_ACTIVE) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Debug mode") + } else { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Run mode") + } + + // Получаем источник сброса + ResetSource_t source = GetResetSource(); + + // Выводим сообщение в зависимости от типа сброса + switch (source) { + case RESET_SOURCE_POWER_ON: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Power-on reset (POR)") + break; + + case RESET_SOURCE_EXTERNAL: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: External reset (NRST pin)") + break; + + case RESET_SOURCE_WATCHDOG: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Watchdog reset (IWDG/WWDG)") + break; + + case RESET_SOURCE_SOFTWARE: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Software reset (NVIC_SystemReset)") + break; + + case RESET_SOURCE_LOCKUP: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Core Lockup reset") + break; + + case RESET_SOURCE_DEBUG: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Debugger reset") + break; + + case RESET_SOURCE_BROWNOUT: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Low Voltage reset (LVR)") + break; + + case RESET_SOURCE_OPTION_BYTE: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Option byte reset") + break; + + case RESET_SOURCE_FIREWALL: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Firewall reset") + break; + + case RESET_SOURCE_MPU: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: MPU violation reset") + break; + + case RESET_SOURCE_BUS_FAULT: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Bus Fault reset") + break; + + case RESET_SOURCE_USAGE_FAULT: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Usage Fault reset") + break; + + case RESET_SOURCE_MEM_FAULT: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Memory Management Fault reset") + break; + + case RESET_SOURCE_CLOCK_ERROR: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Clock error reset") + break; + + case RESET_SOURCE_WAKEUP: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Wakeup reset") + break; + + case RESET_SOURCE_HSM_WATCHDOG: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: HSM Watchdog reset") + break; + + default: + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Reset source: Unknown") + break; + } +} + + +void PrintResetDiagnostics(tMma *env) +{ + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "=== Reset Diagnostics ==="); + + // ======================================== + // 1. CoreDebug->DHCSR (Debug Halting Control and Status Register) + // ======================================== + uint32_t dhcsr = CoreDebug->DHCSR; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "DHCSR: 0x%08X", dhcsr); + + if (dhcsr & CoreDebug_DHCSR_S_RESET_ST_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " S_RESET_ST: System reset occurred"); + } + if (dhcsr & CoreDebug_DHCSR_S_RETIRE_ST_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " S_RETIRE_ST: Retired instruction flag"); + } + if (dhcsr & CoreDebug_DHCSR_S_LOCKUP_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " S_LOCKUP: Core Lockup detected"); + } + if (dhcsr & CoreDebug_DHCSR_S_SLEEP_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " S_SLEEP: Core in sleep mode"); + } + if (dhcsr & CoreDebug_DHCSR_S_HALT_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " S_HALT: Core halted (debugger)"); + } + if (dhcsr & CoreDebug_DHCSR_S_REGRDY_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " S_REGRDY: Register read/write ready"); + } + if (dhcsr & CoreDebug_DHCSR_C_SNAPSTALL_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C_SNAPSTALL: Snap stall enabled"); + } + if (dhcsr & CoreDebug_DHCSR_C_MASKINTS_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C_MASKINTS: Interrupts masked"); + } + if (dhcsr & CoreDebug_DHCSR_C_STEP_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C_STEP: Single step mode"); + } + if (dhcsr & CoreDebug_DHCSR_C_HALT_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C_HALT: Halt request"); + } + if (dhcsr & CoreDebug_DHCSR_C_DEBUGEN_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C_DEBUGEN: Debug enabled"); + } + + // ======================================== + // 2. CoreDebug->DEMCR (Debug Exception and Monitor Control Register) + // ======================================== + uint32_t demcr = CoreDebug->DEMCR; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "DEMCR: 0x%08X", demcr); + + if (demcr & CoreDebug_DEMCR_TRCENA_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " TRCENA: Trace enabled"); + } + if (demcr & CoreDebug_DEMCR_MON_REQ_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MON_REQ: Monitor request"); + } + if (demcr & CoreDebug_DEMCR_MON_STEP_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MON_STEP: Monitor step"); + } + if (demcr & CoreDebug_DEMCR_MON_PEND_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MON_PEND: Monitor pending"); + } + if (demcr & CoreDebug_DEMCR_MON_EN_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MON_EN: Monitor enabled"); + } + if (demcr & CoreDebug_DEMCR_VC_HARDERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_HARDERR: Vector catch Hard Fault"); + } + if (demcr & CoreDebug_DEMCR_VC_INTERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_INTERR: Vector catch Interrupt error"); + } + if (demcr & CoreDebug_DEMCR_VC_BUSERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_BUSERR: Vector catch Bus error"); + } + if (demcr & CoreDebug_DEMCR_VC_STATERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_STATERR: Vector catch State error"); + } + if (demcr & CoreDebug_DEMCR_VC_CHKERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_CHKERR: Vector catch Check error"); + } + if (demcr & CoreDebug_DEMCR_VC_NOCPERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_NOCPERR: Vector catch No Coprocessor"); + } + if (demcr & CoreDebug_DEMCR_VC_MMERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_MMERR: Vector catch Memory Management"); + } + if (demcr & CoreDebug_DEMCR_VC_CORERESET_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VC_CORERESET: Vector catch Core reset"); + } + + // ======================================== + // 3. SCB->HFSR (Hard Fault Status Register) + // ======================================== + uint32_t hfsr = SCB->HFSR; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "HFSR: 0x%08X", hfsr); + + if (hfsr & SCB_HFSR_DEBUGEVT_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " DEBUGEVT: Debug event"); + } + if (hfsr & SCB_HFSR_FORCED_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " FORCED: Hard Fault forced"); + } + if (hfsr & SCB_HFSR_VECTTBL_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VECTTBL: Vector table read error"); + } + + // ======================================== + // 4. SCB->CFSR (Configurable Fault Status Register) + // ======================================== + uint32_t cfsr = SCB->CFSR; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "CFSR: 0x%08X", cfsr); + + // Memory Management Fault + if (cfsr & SCB_CFSR_MEMFAULTSR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MEMFAULT: Memory Management Fault"); + if (cfsr & SCB_CFSR_IACCVIOL_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " IACCVIOL: Instruction access violation"); + } + if (cfsr & SCB_CFSR_DACCVIOL_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " DACCVIOL: Data access violation"); + } + if (cfsr & SCB_CFSR_MUNSTKERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MUNSTKERR: Unstacking error"); + } + if (cfsr & SCB_CFSR_MSTKERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MSTKERR: Stacking error"); + } + if (cfsr & SCB_CFSR_MLSPERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MLSPERR: Lazy state error"); + } + if (cfsr & SCB_CFSR_MMARVALID_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " MMARVALID: MMFAR valid"); + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, " MMFAR: 0x%08X", SCB->MMFAR); + } + } + + // Bus Fault + if (cfsr & SCB_CFSR_BUSFAULTSR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " BUSFAULT: Bus Fault"); + if (cfsr & SCB_CFSR_IBUSERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " IBUSERR: Instruction bus error"); + } + if (cfsr & SCB_CFSR_PRECISERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PRECISERR: Precise data bus error"); + } + if (cfsr & SCB_CFSR_IMPRECISERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " IMPRECISERR: Imprecise data bus error"); + } + if (cfsr & SCB_CFSR_UNSTKERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " UNSTKERR: Unstacking error"); + } + if (cfsr & SCB_CFSR_STKERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " STKERR: Stacking error"); + } + if (cfsr & SCB_CFSR_LSPERR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " LSPERR: Lazy state error"); + } + if (cfsr & SCB_CFSR_BFARVALID_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " BFARVALID: BFAR valid"); + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, " BFAR: 0x%08X", SCB->BFAR); + } + } + + // Usage Fault + if (cfsr & SCB_CFSR_USGFAULTSR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " USGFAULT: Usage Fault"); + if (cfsr & SCB_CFSR_UNDEFINSTR_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " UNDEFINSTR: Undefined instruction"); + } + if (cfsr & SCB_CFSR_INVSTATE_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " INVSTATE: Invalid state"); + } + if (cfsr & SCB_CFSR_INVPC_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " INVPC: Invalid PC"); + } + if (cfsr & SCB_CFSR_NOCP_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " NOCP: No coprocessor"); + } + if (cfsr & SCB_CFSR_UNALIGNED_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " UNALIGNED: Unaligned access"); + } + if (cfsr & SCB_CFSR_DIVBYZERO_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " DIVBYZERO: Division by zero"); + } + } + + // ======================================== + // 5. SCB->DFSR (Debug Fault Status Register) + // ======================================== + uint32_t dfsr = SCB->DFSR; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "DFSR: 0x%08X", dfsr); + + if (dfsr & SCB_DFSR_EXTERNAL_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " EXTERNAL: External debug request"); + } + if (dfsr & SCB_DFSR_VCATCH_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " VCATCH: Vector catch"); + } + if (dfsr & SCB_DFSR_DWTTRAP_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " DWTTRAP: DWT trap"); + } + if (dfsr & SCB_DFSR_BKPT_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " BKPT: Breakpoint"); + } + if (dfsr & SCB_DFSR_HALTED_Msk) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " HALTED: Core halted"); + } + + // ======================================== + // 6. RGM->SRS (System Reset Status Register) + // ======================================== + uint32_t srs = RGM->SRS; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->SRS: 0x%08X", srs); + + if (srs & RGM_SRS_SYSRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SYSRST_TOUT: System reset timeout"); + } + if (srs & RGM_SRS_PINRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PINRST_TOUT: Pin reset timeout"); + } + if (srs & RGM_SRS_FSM_ERR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " FSM_ERR: FSM error"); + } + if (srs & RGM_SRS_LBIST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " LBIST: LBIST reset"); + } + if (srs & RGM_SRS_CMU_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CMU: CMU reset"); + } + if (srs & RGM_SRS_SACKERR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SACKERR: System ACK error"); + } + if (srs & RGM_SRS_WDOG1_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " WDOG1: Watchdog 1 reset"); + } + if (srs & RGM_SRS_SYSAP_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SYSAP: System AP reset"); + } + if (srs & RGM_SRS_JTAG_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " JTAG: JTAG reset"); + } + if (srs & RGM_SRS_POR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " POR: Power-on reset"); + } + if (srs & RGM_SRS_PIN_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PIN: External pin reset"); + } + if (srs & RGM_SRS_HSM_WDOG_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " HSM_WDOG: HSM watchdog reset"); + } + if (srs & RGM_SRS_FCSMU_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " FCSMU: FCSMU reset"); + } + if (srs & RGM_SRS_CLKERR0_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CLKERR0: Clock error 0 reset"); + } + if (srs & RGM_SRS_CLKERR1_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CLKERR1: Clock error 1 reset"); + } + if (srs & RGM_SRS_LVR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " LVR: Low Voltage reset"); + } + if (srs & RGM_SRS_WAKEUP_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " WAKEUP: Wakeup reset"); + } + + // ======================================== + // 7. RGM->SSRS (Sticky System Reset Status Register) + // ======================================== + uint32_t ssrs = RGM->SSRS; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->SSRS: 0x%08X", ssrs); + + if (ssrs & RGM_SSRS_SYSRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SYSRST_TOUT: System reset timeout (sticky)"); + } + if (ssrs & RGM_SSRS_PINRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PINRST_TOUT: Pin reset timeout (sticky)"); + } + if (ssrs & RGM_SSRS_FSM_ERR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " FSM_ERR: FSM error (sticky)"); + } + if (ssrs & RGM_SSRS_LBIST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " LBIST: LBIST reset (sticky)"); + } + if (ssrs & RGM_SSRS_CMU_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CMU: CMU reset (sticky)"); + } + if (ssrs & RGM_SSRS_SACKERR_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SACKERR_ST: System ACK error (sticky)"); + } + if (ssrs & RGM_SSRS_WDOG1_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " WDOG1: Watchdog 1 reset (sticky)"); + } + if (ssrs & RGM_SSRS_SYSAP_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SYSAP_ST: System AP reset (sticky)"); + } + if (ssrs & RGM_SSRS_JTAG_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " JTAG_ST: JTAG reset (sticky)"); + } + if (ssrs & RGM_SSRS_POR_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " POR_ST: Power-on reset (sticky)"); + } + if (ssrs & RGM_SSRS_PIN_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PIN_ST: External pin reset (sticky)"); + } + if (ssrs & RGM_SSRS_HSMWDOG_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " HSMWDOG_ST: HSM watchdog reset (sticky)"); + } + if (ssrs & RGM_SSRS_FCSMU_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " FCSMU_ST: FCSMU reset (sticky)"); + } + if (ssrs & RGM_SSRS_CLKERR0_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CLKERR0_ST: Clock error 0 reset (sticky)"); + } + if (ssrs & RGM_SSRS_CLKERR1_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CLKERR1_ST: Clock error 1 reset (sticky)"); + } + if (ssrs & RGM_SSRS_LVR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " LVR: Low Voltage reset (sticky)"); + } + if (ssrs & RGM_SSRS_WAKEUP_ST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " WAKEUP_ST: Wakeup reset (sticky)"); + } + + // ======================================== + // 8. RGM->C0_SRS (CPU0 System Reset Status Register) + // ======================================== + uint32_t c0_srs = RGM->C0_SRS; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->C0_SRS: 0x%08X", c0_srs); + + if (c0_srs & RGM_C0_SRS_SYSRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SYSRST_TOUT: System reset timeout (CPU0)"); + } + if (c0_srs & RGM_C0_SRS_PINRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PINRST_TOUT: Pin reset timeout (CPU0)"); + } + if (c0_srs & RGM_C0_SRS_FSM_ERR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " FSM_ERR: FSM error (CPU0)"); + } + if (c0_srs & RGM_C0_SRS_C0_SWRST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SWRST: CPU0 software reset"); + } + if (c0_srs & RGM_C0_SRS_C0_INTM_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_INTM: CPU0 interrupt reset"); + } + if (c0_srs & RGM_C0_SRS_C0_WDOG_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_WDOG: CPU0 watchdog reset"); + } + if (c0_srs & RGM_C0_SRS_C0_SYSRST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SYSRST: CPU0 system reset"); + } + if (c0_srs & RGM_C0_SRS_C0_LOCKUP_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_LOCKUP: CPU0 lockup reset"); + } + if (c0_srs & RGM_C0_SRS_C0_SRS_MASK) { + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, " C0_SRS: 0x%04X", (c0_srs & RGM_C0_SRS_C0_SRS_MASK) >> RGM_C0_SRS_C0_SRS_SHIFT); + } + + // ======================================== + // 9. RGM->C0_SSRS (CPU0 Sticky System Reset Status Register) + // ======================================== + uint32_t c0_ssrs = RGM->C0_SSRS; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->C0_SSRS: 0x%08X", c0_ssrs); + + if (c0_ssrs & RGM_C0_SSRS_SYSRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SYSRST_TOUT: System reset timeout (CPU0 sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_PINRST_TOUT_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PINRST_TOUT: Pin reset timeout (CPU0 sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_FSM_ERR_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " FSM_ERR: FSM error (CPU0 sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_C0_SWRST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SWRST: CPU0 software reset (sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_C0_INTM_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_INTM: CPU0 interrupt reset (sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_C0_WDOG_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_WDOG: CPU0 watchdog reset (sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_C0_SYSRST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SYSRST: CPU0 system reset (sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_C0_LOCKUP_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_LOCKUP: CPU0 lockup reset (sticky)"); + } + if (c0_ssrs & RGM_C0_SSRS_SSRS_MASK) { + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, " SSRS: 0x%04X", (c0_ssrs & RGM_C0_SSRS_SSRS_MASK) >> RGM_C0_SSRS_SSRS_SHIFT); + } + + // ======================================== + // 10. RGM->C0_CFG (CPU0 Reset Configuration Register) + // ======================================== + uint32_t c0_cfg = RGM->C0_CFG; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->C0_CFG: 0x%08X", c0_cfg); + + if (c0_cfg & RGM_C0_CFG_C0_SWRST_EN_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SWRST_EN: Software reset enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_INTM_EN_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_INTM_EN: Interrupt reset enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_WDOG_EN_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_WDOG_EN: Watchdog reset enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_SYSRST_EN_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SYSRST_EN: System reset enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_LOCKUP_EN_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_LOCKUP_EN: Lockup reset enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_SWRST_IE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SWRST_IE: Software reset interrupt enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_INTM_IE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_INTM_IE: Interrupt reset interrupt enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_WDOG_IE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_WDOG_IE: Watchdog interrupt enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_SYSRST_IE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SYSRST_IE: System reset interrupt enabled"); + } + if (c0_cfg & RGM_C0_CFG_C0_LOCKUP_IE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_LOCKUP_IE: Lockup interrupt enabled"); + } + + // ======================================== + // 11. RGM->C0_RST (CPU0 Reset Register) + // ======================================== + uint32_t c0_rst = RGM->C0_RST; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->C0_RST: 0x%08X", c0_rst); + + if (c0_rst & RGM_C0_RST_C0_OUT_OF_RST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_OUT_OF_RST: CPU0 out of reset"); + } + if (c0_rst & RGM_C0_RST_C0_SWRST_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " C0_SWRST: CPU0 software reset request"); + } + + // ======================================== + // 12. RGM->RSTFLT (Reset Filter Control Register) + // ======================================== + uint32_t rstflt = RGM->RSTFLT; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->RSTFLT: 0x%08X", rstflt); + + if (rstflt & RGM_RSTFLT_RSTFLT_BUSW_MASK) { + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, " RSTFLT_BUSW: 0x%02X", (rstflt & RGM_RSTFLT_RSTFLT_BUSW_MASK) >> RGM_RSTFLT_RSTFLT_BUSW_SHIFT); + } + if (rstflt & RGM_RSTFLT_RSTFLT_AON_LP_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " RSTFLT_AON_LP: AON low-power filter enabled"); + } + if (rstflt & RGM_RSTFLT_RSTFLT_AON_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " RSTFLT_AON: AON filter enabled"); + } + if (rstflt & RGM_RSTFLT_RSTFLT_BUS_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " RSTFLT_BUS: Bus filter enabled"); + } + + // ======================================== + // 13. RGM->SRIE (System Reset Interrupt Enable Register) + // ======================================== + uint32_t srie = RGM->SRIE; + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "RGM->SRIE: 0x%08X", srie); + + if (srie & RGM_SRIE_SACKERR_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SACKERR_RIE: ACK error interrupt enabled"); + } + if (srie & RGM_SRIE_WDOG1_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " WDOG1_RIE: Watchdog 1 interrupt enabled"); + } + if (srie & RGM_SRIE_SYSAP_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SYSAP_RIE: System AP interrupt enabled"); + } + if (srie & RGM_SRIE_SW_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " SW_RIE: Software interrupt enabled"); + } + if (srie & RGM_SRIE_CPULOC_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CPULOC_RIE: CPU lockup interrupt enabled"); + } + if (srie & RGM_SRIE_JTAG_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " JTAG_RIE: JTAG interrupt enabled"); + } + if (srie & RGM_SRIE_GLOBAL_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " GLOBAL_RIE: Global interrupt enabled"); + } + if (srie & RGM_SRIE_PIN_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " PIN_RIE: Pin reset interrupt enabled"); + } + if (srie & RGM_SRIE_WDG_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " WDG_RIE: Watchdog interrupt enabled"); + } + if (srie & RGM_SRIE_CLKERR0_RIE_MASK) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, " CLKERR0_RIE: Clock error 0 interrupt enabled"); + } + if (srie & RGM_SRIE_DELAY_MASK) { + LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, " DELAY: 0x%02X", (srie & RGM_SRIE_DELAY_MASK) >> RGM_SRIE_DELAY_SHIFT); + } + + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "========================="); +} + + +void ClearResetFlags(void) +{ + // Очищаем "липкие" флаги записью 1 в соответствующие биты + // Для очистки нужно записать 1 в биты, которые хотим сбросить + + // Очищаем SSRS (Sticky SRS) + RGM->SSRS = RGM_SSRS_MASK; + + // Очищаем C0_SSRS (Sticky CPU0 SRS) + RGM->C0_SSRS = RGM_C0_SSRS_MASK; + + // Для SRS и C0_SRS - они читаются только для статуса, + // их очистка происходит через SSRS +} + + +void AnalyzeAndPrintResetReason(tMma *env) +{ + // Небольшая задержка для стабилизации + for (volatile int i = 0; i < 1000; i++); + + // Выводим режим работы + if (CHECK_JTAG_DEBUG_ACTIVE) { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Debug mode") + } else { + LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Run mode") + } + + // Анализируем и выводим причину сброса + //PrintResetSource(env); + + // Если нужна детальная диагностика - раскомментировать + PrintResetDiagnostics(env); + + // Очищаем флаги сброса + ClearResetFlags(); +} + +// Пример использования в main() + +int main(void) +{ + tMma *env = GetMmaEnvironment(); // или как у вас создается env + + // Инициализация системы + SystemInit(); + + // Инициализация логгера (должна быть до вызова функции) + LoggerInit(); + + // Анализ причины перезагрузки + AnalyzeAndPrintResetReason(env); + + // Дальнейшая инициализация... + + while(1) { + // Основной цикл + } +} +*/ \ No newline at end of file diff --git a/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c b/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c index 4c7d1ff..653111d 100644 --- a/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c +++ b/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c @@ -8,12 +8,17 @@ #include "HardFault.h" #include "FirmwareMetadataSection.h" #include "HVAC_model.h" +#include "VIN_DATA.h" + + #define LOGGER &env->slog.logger -const char LOG_TASK_MAIN[] = "Init"; +const char LOG_INFO_TASK_MAIN[] = "Init"; +void AnalyzeAndPrintResetReason(tMma *env); + void Mma_InitComIntLog(tMma *env) { LoggerToSerialPort_Init( @@ -26,7 +31,9 @@ void Mma_InitComIntLog(tMma *env) { 10 ); - LoggerInfoStatic(&env->slog.logger, LOG_TASK_MAIN, "Start logging") + LoggerInfoStatic(&env->slog.logger, LOG_INFO_TASK_MAIN, "Start logging") + +// AnalyzeAndPrintResetReason(env); } @@ -63,7 +70,7 @@ static void Mma_InitSubSystems(tMma *env) { memset(dataTmp, 0, sizeof(dataTmp)); memcpy(dataTmp, firmwareMetaMap_Boot->fingerprint.testerCode, 9); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "Fingerprint Boot: ModuleID: %d, testerCode: %s, year: 0x%02X, month: 0x%02X day: 0x%02X", + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "Fingerprint Boot: ModuleID: %d, testerCode: %s, year: 0x%02X, month: 0x%02X day: 0x%02X", firmwareMetaMap_Boot->fingerprint.ModuleID, dataTmp, firmwareMetaMap_Boot->fingerprint.year, @@ -72,26 +79,26 @@ static void Mma_InitSubSystems(tMma *env) { memcpy(dataTmp, firmwareMetaMap_Main->fingerprint.testerCode, 9); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "Fingerprint Main: ModuleID: %d, testerCode: %s, year: 0x%02X, month: 0x%02X day: 0x%02X", + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "Fingerprint Main: ModuleID: %d, testerCode: %s, year: 0x%02X, month: 0x%02X day: 0x%02X", firmwareMetaMap_Main->fingerprint.ModuleID, dataTmp, firmwareMetaMap_Main->fingerprint.year, firmwareMetaMap_Main->fingerprint.month, firmwareMetaMap_Main->fingerprint.day); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "Internal Version HW: year: %02d, month: %02d day: %02d, revision: %02d", + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "Internal Version HW: year: %02d, month: %02d day: %02d, revision: %02d", firmwareMetaMap_Main->HW.year, firmwareMetaMap_Main->HW.month, firmwareMetaMap_Main->HW.day, firmwareMetaMap_Main->HW.revision); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "Internal Version SW: year: %02d, month: %02d day: %02d, revision: %02d", + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "Internal Version SW: year: %02d, month: %02d day: %02d, revision: %02d", firmwareMetaMap_Main->internal_SW_Version.SW.year, firmwareMetaMap_Main->internal_SW_Version.SW.month, firmwareMetaMap_Main->internal_SW_Version.SW.day, firmwareMetaMap_Main->internal_SW_Version.SW.revision); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "Internal Version MDB: year: %02d, month: %02d day: %02d, revision: %02d", + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "Internal Version MDB: year: %02d, month: %02d day: %02d, revision: %02d", firmwareMetaMap_Main->internal_SW_Version.MDB.year, firmwareMetaMap_Main->internal_SW_Version.MDB.month, firmwareMetaMap_Main->internal_SW_Version.MDB.day, @@ -101,29 +108,29 @@ static void Mma_InitSubSystems(tMma *env) { if (hardFault_magic == 0xDEADBEEF) { hardFault_magic = 0; - LoggerFormatError(LOGGER, LOG_TASK_MAIN, "HardFault addresses (%d):", hardFault_count); + LoggerFormatError(LOGGER, LOG_INFO_TASK_MAIN, "HardFault addresses (%d):", hardFault_count); for (uint32 i = 0; i < hardFault_count; ++i) { - LoggerFormatError(LOGGER, LOG_TASK_MAIN, " [%d] 0x%08X", i, hardFault_addresses[i]); + LoggerFormatError(LOGGER, LOG_INFO_TASK_MAIN, " [%d] 0x%08X", i, hardFault_addresses[i]); } } if (CHECK_JTAG_DEBUG_ACTIVE) { - LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Debug mode") + LoggerInfoStatic(LOGGER, LOG_INFO_TASK_MAIN, "Debug mode") } else { - LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Run mode") + LoggerInfoStatic(LOGGER, LOG_INFO_TASK_MAIN, "Run mode") } if (CHECK_PARALLEL_ENABLE) { - LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Parallel memory access enabled (OTA update unavailable)") + LoggerInfoStatic(LOGGER, LOG_INFO_TASK_MAIN, "Parallel memory access enabled (OTA update unavailable)") } else { - LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Parallel memory access disabled (OTA update available)") + LoggerInfoStatic(LOGGER, LOG_INFO_TASK_MAIN, "Parallel memory access disabled (OTA update available)") } /* if (RGM_SRS_WAKEUP_MASK == (RGM->SRS & RGM_SRS_WAKEUP_MASK)) { - LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Wake up from standby (INIT)") + LoggerInfoStatic(LOGGER, LOG_INFO_TASK_MAIN, "Wake up from standby (INIT)") // tGpioPin Ign_Wakeup = vInitGpioPinPull(GPIO_E, PORT_PIN_16, GPIO_IN, GPIO_PIN_NOREVERSE, GPIO_HIGH, // GPIO_PUSH_PULL, @@ -133,7 +140,7 @@ static void Mma_InitSubSystems(tMma *env) { } */ - LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "Initialization of subsystems") + LoggerInfoStatic(LOGGER, LOG_INFO_TASK_MAIN, "Initialization of subsystems") // Инициализация периферийных интерфейсов InitPeripheralInterfaces(&env->slog.logger); @@ -144,19 +151,22 @@ static void Mma_InitSubSystems(tMma *env) { memcpy(dataTmp, env->storage.dataParam->device.identification.Tester_Fingerprint.tester_serial, 9); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "Fingerprint Tester: testerCode: %s, year: 0x%02X, month: 0x%02X day: 0x%02X", + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "Fingerprint Tester: testerCode: %s, year: 0x%02X, month: 0x%02X day: 0x%02X", dataTmp, env->storage.dataParam->device.identification.Tester_Fingerprint.year, env->storage.dataParam->device.identification.Tester_Fingerprint.month, env->storage.dataParam->device.identification.Tester_Fingerprint.day); memcpy(dataTmp, env->storage.dataParam->device.identification.Vehicle_Identification, sizeof(env->storage.dataParam->device.identification.Vehicle_Identification) - 1); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "VIN: %s", dataTmp); + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "VIN: %s", dataTmp); memcpy(dataTmp, env->storage.dataParam->device.identification.Serial_Number, sizeof(env->storage.dataParam->device.identification.Serial_Number) - 1); - LoggerFormatInfo(LOGGER, LOG_TASK_MAIN, "Serial Number: %s", dataTmp); + LoggerFormatInfo(LOGGER, LOG_INFO_TASK_MAIN, "Serial Number: %s", dataTmp); - Rs_Cal_0_SedanL(); + + setVehicleTypeFromVinToCalib(env->storage.dataParam->device.identification.Vehicle_Identification); + +// Rs_Cal_0_SedanL(); VarsTabDumpObserver_StartThread(&env->storage.dumpObserver); @@ -346,7 +356,7 @@ static void Mma_InitSubSystems(tMma *env) { Lin3_StartThread(&env->linTaskActuator3); - LoggerInfoStatic(LOGGER, LOG_TASK_MAIN, "End of subsystem initialization") + LoggerInfoStatic(LOGGER, LOG_INFO_TASK_MAIN, "End of subsystem initialization") }