diff --git a/wled00/util.cpp b/wled00/util.cpp index 47a2aa8e..7f0c2201 100644 --- a/wled00/util.cpp +++ b/wled00/util.cpp @@ -720,116 +720,132 @@ void *realloc_malloc(void *ptr, size_t size) { // checks if the ESP reboots multiple times due to a crash or watchdog timeout // if a bootloop is detected: restore settings from backup, then reset settings, then switch boot image (and repeat) -#define BOOTLOOP_THRESHOLD 5 // number of consecutive crashes to trigger bootloop detection -#define BOOTLOOP_ACTION_RESTORE 0 // default action: restore config from /bak.cfg.json -#define BOOTLOOP_ACTION_RESET 1 // if restore does not work, reset config (rename /cfg.json to /rst.cfg.json) -#define BOOTLOOP_ACTION_OTA 2 // swap the boot partition -#define BOOTLOOP_ACTION_DUMP 3 // nothing seems to help, dump files to serial and reboot (until hardware reset) +#define BOOTLOOP_INTERVAL_MILLIS 5000 // time limit between crashes: 5 seconds +#define BOOTLOOP_THRESHOLD 5 // number of consecutive crashes to trigger bootloop detection +#define BOOTLOOP_ACTION_RESTORE 0 // default action: restore config from /bkp.cfg.json +#define BOOTLOOP_ACTION_RESET 1 // if restore does not work, reset config (rename /cfg.json to /rst.cfg.json) +#define BOOTLOOP_ACTION_OTA 2 // swap the boot partition +#define BOOTLOOP_ACTION_DUMP 3 // nothing seems to help, dump files to serial and reboot (until hardware reset) + +// Platform-agnostic abstraction +enum class ResetReason { + Power, + Software, + Crash, + Brownout +}; #ifdef ESP8266 -#define BOOTLOOP_INTERVAL_TICKS (5 * 160000) // time limit between crashes: ~5 seconds in RTC ticks // Place variables in RTC memory via references, since RTC memory is not exposed via the linker in the Non-OS SDK // Use an offset of 32 as there's some hints that the first 128 bytes of "user" memory are used by the OTA system // Ref: https://github.com/esp8266/Arduino/blob/78d0d0aceacc1553f45ad8154592b0af22d1eede/cores/esp8266/Esp.cpp#L168 static volatile uint32_t& bl_last_boottime = *(RTC_USER_MEM + 32); static volatile uint32_t& bl_crashcounter = *(RTC_USER_MEM + 33); static volatile uint32_t& bl_actiontracker = *(RTC_USER_MEM + 34); + +static inline ResetReason rebootReason() { + rst_info* resetreason = system_get_rst_info(); + if (resetreason->reason == REASON_EXCEPTION_RST || resetreason->reason == REASON_WDT_RST) return ResetReason::Crash; + if (resetreason->reason == REASON_SOFT_RESTART) return ResetReason::Software; + return ResetReason::Power; +} + +static inline uint32_t getRtcMillis() { return system_get_rtc_time() / 160; }; // rtc ticks ~160000Hz + #else -#define BOOTLOOP_INTERVAL_TICKS 5000 // time limit between crashes: ~5 seconds in milliseconds // variables in RTC_NOINIT memory persist between reboots (but not on hardware reset) RTC_NOINIT_ATTR static uint32_t bl_last_boottime; RTC_NOINIT_ATTR static uint32_t bl_crashcounter; RTC_NOINIT_ATTR static uint32_t bl_actiontracker; + +static inline ResetReason rebootReason() { + esp_reset_reason_t reason = esp_reset_reason(); + if (reason == ESP_RST_BROWNOUT) return ResetReason::Brownout; + if (reason == ESP_RST_SW) return ResetReason::Software; + if (reason == ESP_RST_PANIC || reason == ESP_RST_WDT || reason == ESP_RST_INT_WDT || reason == ESP_RST_TASK_WDT) return ResetReason::Crash; + return ResetReason::Power; +} + +#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0) +static inline uint32_t getRtcMillis() { return esp_rtc_get_time_us() / 1000; } +#elif ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(3, 3, 0) +static inline uint32_t getRtcMillis() { return rtc_time_slowclk_to_us(rtc_time_get(), rtc_clk_slow_freq_get_hz()) / 1000; } +#endif + void bootloopCheckOTA() { bl_actiontracker = BOOTLOOP_ACTION_OTA; } // swap boot image if bootloop is detected instead of restoring config + #endif // detect bootloop by checking the reset reason and the time since last boot static bool detectBootLoop() { -#if !defined(ESP8266) - #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0) - uint32_t rtctime = esp_rtc_get_time_us() / 1000; // convert to milliseconds - #elif ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(3, 3, 0) - uint64_t rtc_ticks = rtc_time_get(); - uint32_t rtctime = rtc_time_slowclk_to_us(rtc_ticks, rtc_clk_slow_freq_get_hz()) / 1000; // convert to milliseconds - #endif + uint32_t rtctime = getRtcMillis(); + bool result = false; - esp_reset_reason_t reason = esp_reset_reason(); - - if (!(reason == ESP_RST_PANIC || reason == ESP_RST_WDT || reason == ESP_RST_INT_WDT || reason == ESP_RST_TASK_WDT)) { - // no crash detected, init variables - bl_crashcounter = 0; - bl_last_boottime = rtctime; - if(reason != ESP_RST_SW) + switch(rebootReason()) { + case ResetReason::Power: bl_actiontracker = BOOTLOOP_ACTION_RESTORE; // init action tracker if not an intentional reboot (e.g. from OTA or bootloop handler) - } else if (reason == ESP_RST_BROWNOUT) { - // crash due to brownout can't be detected unless using flash memory to store bootloop variables - // this is a simpler way to preemtively revert the config in case current brownout is caused by a bad choice of settings - DEBUG_PRINTLN(F("brownout detected")); - //restoreConfig(); // TODO: blindly restoring config if brownout detected is a bad idea, need a better way (if at all) - } else { - uint32_t rebootinterval = rtctime - bl_last_boottime; - bl_last_boottime = rtctime; // store current runtime for next reboot - if (rebootinterval < BOOTLOOP_INTERVAL_TICKS) { - bl_crashcounter++; - if (bl_crashcounter >= BOOTLOOP_THRESHOLD) { - DEBUG_PRINTLN(F("!BOOTLOOP DETECTED!")); - bl_crashcounter = 0; - return true; - } - } - } -#else // ESP8266 - rst_info* resetreason = system_get_rst_info(); - uint32_t rtctime = system_get_rtc_time(); + // fall through + case ResetReason::Software: + // no crash detected, reset counter + bl_crashcounter = 0; + break; - if (!(resetreason->reason == REASON_EXCEPTION_RST || resetreason->reason == REASON_WDT_RST)) { - // no crash detected, init variables - bl_crashcounter = 0; - bl_last_boottime = rtctime; - if(resetreason->reason != REASON_SOFT_RESTART) { - bl_actiontracker = BOOTLOOP_ACTION_RESTORE; // init action tracker if not an intentional reboot (e.g. from OTA or bootloop handler) - } - } else { - // system has crashed - uint32_t rebootinterval = rtctime - bl_last_boottime; - bl_last_boottime = rtctime; - if (rebootinterval < BOOTLOOP_INTERVAL_TICKS) { - bl_crashcounter++; - if (bl_crashcounter >= BOOTLOOP_THRESHOLD) { - DEBUG_PRINTLN(F("BOOTLOOP DETECTED")); - bl_crashcounter = 0; - return true; + case ResetReason::Crash: + { + uint32_t rebootinterval = rtctime - bl_last_boottime; + if (rebootinterval < BOOTLOOP_INTERVAL_MILLIS) { + bl_crashcounter++; + if (bl_crashcounter >= BOOTLOOP_THRESHOLD) { + DEBUG_PRINTLN(F("!BOOTLOOP DETECTED!")); + bl_crashcounter = 0; + result = true; + } } + break; } + + case ResetReason::Brownout: + // crash due to brownout can't be detected unless using flash memory to store bootloop variables + DEBUG_PRINTLN(F("brownout detected")); + //restoreConfig(); // TODO: blindly restoring config if brownout detected is a bad idea, need a better way (if at all) + break; } -#endif - return false; // no bootloop detected + + bl_last_boottime = rtctime; // store current runtime for next reboot + + return result; } void handleBootLoop() { DEBUG_PRINTF_P(PSTR("checking for bootloop: time %d, counter %d, action %d\n"), bl_last_boottime, bl_crashcounter, bl_actiontracker); if (!detectBootLoop()) return; // no bootloop detected - if (bl_actiontracker == BOOTLOOP_ACTION_RESTORE) { - restoreConfig(); // note: if this fails, could reset immediately. instead just let things play out and save a few lines of code - bl_actiontracker = BOOTLOOP_ACTION_RESET; // reset config if it keeps bootlooping - } else if (bl_actiontracker == BOOTLOOP_ACTION_RESET) { - resetConfig(); - bl_actiontracker = BOOTLOOP_ACTION_OTA; // swap boot partition if it keeps bootlooping. On ESP8266 this is the same as BOOTLOOP_ACTION_NONE - } + switch(bl_actiontracker) { + case BOOTLOOP_ACTION_RESTORE: + restoreConfig(); + ++bl_actiontracker; + break; + case BOOTLOOP_ACTION_RESET: + resetConfig(); + ++bl_actiontracker; + break; + case BOOTLOOP_ACTION_OTA: #ifndef ESP8266 - else if (bl_actiontracker == BOOTLOOP_ACTION_OTA) { - if(Update.canRollBack()) { - DEBUG_PRINTLN(F("Swapping boot partition...")); - Update.rollBack(); // swap boot partition - } - bl_actiontracker = BOOTLOOP_ACTION_DUMP; // out of options + if(Update.canRollBack()) { + DEBUG_PRINTLN(F("Swapping boot partition...")); + Update.rollBack(); // swap boot partition + } + ++bl_actiontracker; + break; +#else + // fall through +#endif + case BOOTLOOP_ACTION_DUMP: + dumpFilesToSerial(); + break; } - #endif - else - dumpFilesToSerial(); - ESP.restart(); // restart cleanly and don't wait for another crash + ESP.restart(); // restart cleanly and don't wait for another crash } /*