♻️ Move watchdog to MarlinHAL

Marlin/src/HAL/AVR/HAL.cpp

 
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
+#include <avr/wdt.h>
 
 #ifdef USBCON
   DefaultSerial1 MSerial0(false, Serial);
 }
 
 // ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #include <avr/wdt.h>
+  #include "../../MarlinCore.h"
+
+  // Initialize watchdog with 8s timeout, if possible. Otherwise, make it 4s.
+  void MarlinHAL::watchdog_init() {
+    #if ENABLED(WATCHDOG_DURATION_8S) && defined(WDTO_8S)
+      #define WDTO_NS WDTO_8S
+    #else
+      #define WDTO_NS WDTO_4S
+    #endif
+    #if ENABLED(WATCHDOG_RESET_MANUAL)
+      // Enable the watchdog timer, but only for the interrupt.
+      // Take care, as this requires the correct order of operation, with interrupts disabled.
+      // See the datasheet of any AVR chip for details.
+      wdt_reset();
+      cli();
+      _WD_CONTROL_REG = _BV(_WD_CHANGE_BIT) | _BV(WDE);
+      _WD_CONTROL_REG = _BV(WDIE) | (WDTO_NS & 0x07) | ((WDTO_NS & 0x08) << 2); // WDTO_NS directly does not work. bit 0-2 are consecutive in the register but the highest value bit is at bit 5
+                                                                                // So worked for up to WDTO_2S
+      sei();
+      wdt_reset();
+    #else
+      wdt_enable(WDTO_NS); // The function handles the upper bit correct.
+    #endif
+    //delay(10000); // test it!
+  }
+
+  //===========================================================================
+  //=================================== ISR ===================================
+  //===========================================================================
+
+  // Watchdog timer interrupt, called if main program blocks >4sec and manual reset is enabled.
+  #if ENABLED(WATCHDOG_RESET_MANUAL)
+    ISR(WDT_vect) {
+      sei();  // With the interrupt driven serial we need to allow interrupts.
+      SERIAL_ERROR_MSG(STR_WATCHDOG_FIRED);
+      minkill();  // interrupt-safe final kill and infinite loop
+    }
+  #endif
+
+  // Reset watchdog. MUST be called at least every 4 seconds after the
+  // first watchdog_init or AVR will go into emergency procedures.
+  void MarlinHAL::watchdog_refresh() { wdt_reset(); }
+
+#endif // USE_WATCHDOG
+
+// ------------------------
 // Free Memory Accessor
 // ------------------------
 

Marlin/src/HAL/AVR/HAL.h

 #include "../shared/Marduino.h"
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
-#include "watchdog.h"
 #include "math.h"
 
 #ifdef USBCON
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
   static void init();          // Called early in setup()
   static void init_board() {}  // Called less early in setup()
   static void reboot();        // Restart the firmware from 0x0

Marlin/src/HAL/AVR/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef __AVR__
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include "watchdog.h"
-
-#include "../../MarlinCore.h"
-
-// Initialize watchdog with 8s timeout, if possible. Otherwise, make it 4s.
-void watchdog_init() {
-  #if ENABLED(WATCHDOG_DURATION_8S) && defined(WDTO_8S)
-    #define WDTO_NS WDTO_8S
-  #else
-    #define WDTO_NS WDTO_4S
-  #endif
-  #if ENABLED(WATCHDOG_RESET_MANUAL)
-    // Enable the watchdog timer, but only for the interrupt.
-    // Take care, as this requires the correct order of operation, with interrupts disabled.
-    // See the datasheet of any AVR chip for details.
-    wdt_reset();
-    cli();
-    _WD_CONTROL_REG = _BV(_WD_CHANGE_BIT) | _BV(WDE);
-    _WD_CONTROL_REG = _BV(WDIE) | (WDTO_NS & 0x07) | ((WDTO_NS & 0x08) << 2); // WDTO_NS directly does not work. bit 0-2 are consecutive in the register but the highest value bit is at bit 5
-                                                                              // So worked for up to WDTO_2S
-    sei();
-    wdt_reset();
-  #else
-    wdt_enable(WDTO_NS); // The function handles the upper bit correct.
-  #endif
-  //delay(10000); // test it!
-}
-
-//===========================================================================
-//=================================== ISR ===================================
-//===========================================================================
-
-// Watchdog timer interrupt, called if main program blocks >4sec and manual reset is enabled.
-#if ENABLED(WATCHDOG_RESET_MANUAL)
-  ISR(WDT_vect) {
-    sei();  // With the interrupt driven serial we need to allow interrupts.
-    SERIAL_ERROR_MSG(STR_WATCHDOG_FIRED);
-    minkill();  // interrupt-safe final kill and infinite loop
-  }
-#endif
-
-#endif // USE_WATCHDOG
-#endif // __AVR__

Marlin/src/HAL/AVR/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include <avr/wdt.h>
-
-// Initialize watchdog with a 4 second interrupt time
-void watchdog_init();
-
-// Reset watchdog. MUST be called at least every 4 seconds after the
-// first watchdog_init or AVR will go into emergency procedures.
-inline void HAL_watchdog_refresh() { wdt_reset(); }

Marlin/src/HAL/DUE/HAL.cpp

 #ifdef ARDUINO_ARCH_SAM
 
 #include "../../inc/MarlinConfig.h"
-#include "HAL.h"
+#include "../../MarlinCore.h"
 
 #include <Wire.h>
 #include "usb/usb_task.h"
 void MarlinHAL::reboot() { rstc_start_software_reset(RSTC); }
 
 // ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  // Initialize watchdog - On SAM3X, Watchdog was already configured
+  //  and enabled or disabled at startup, so no need to reconfigure it
+  //  here.
+  void MarlinHAL::watchdog_init() { WDT_Restart(WDT); } // Reset watchdog to start clean
+
+  // Reset watchdog. MUST be called at least every 4 seconds after the
+  // first watchdog_init or AVR will go into emergency procedures.
+  void MarlinHAL::watchdog_refresh() { watchdogReset(); }
+
+#endif
+
+// Override Arduino runtime to either config or disable the watchdog
+//
+// We need to configure the watchdog as soon as possible in the boot
+// process, because watchdog initialization at hardware reset on SAM3X8E
+// is unreliable, and there is risk of unintended resets if we delay
+// that initialization to a later time.
+void watchdogSetup() {
+
+  #if ENABLED(USE_WATCHDOG)
+
+    // 4 seconds timeout
+    uint32_t timeout = TERN(WATCHDOG_DURATION_8S, 8000, 4000);
+
+    // Calculate timeout value in WDT counter ticks: This assumes
+    // the slow clock is running at 32.768 kHz watchdog
+    // frequency is therefore 32768 / 128 = 256 Hz
+    timeout = (timeout << 8) / 1000;
+    if (timeout == 0)
+      timeout = 1;
+    else if (timeout > 0xFFF)
+      timeout = 0xFFF;
+
+    // We want to enable the watchdog with the specified timeout
+    uint32_t value =
+      WDT_MR_WDV(timeout) |               // With the specified timeout
+      WDT_MR_WDD(timeout) |               // and no invalid write window
+    #if !(SAMV70 || SAMV71 || SAME70 || SAMS70)
+      WDT_MR_WDRPROC   |                  // WDT fault resets processor only - We want
+                                          // to keep PIO controller state
+    #endif
+      WDT_MR_WDDBGHLT  |                  // WDT stops in debug state.
+      WDT_MR_WDIDLEHLT;                   // WDT stops in idle state.
+
+    #if ENABLED(WATCHDOG_RESET_MANUAL)
+      // We enable the watchdog timer, but only for the interrupt.
+
+      // Configure WDT to only trigger an interrupt
+      value |= WDT_MR_WDFIEN;             // Enable WDT fault interrupt.
+
+      // Disable WDT interrupt (just in case, to avoid triggering it!)
+      NVIC_DisableIRQ(WDT_IRQn);
+
+      // We NEED memory barriers to ensure Interrupts are actually disabled!
+      // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
+      __DSB();
+      __ISB();
+
+      // Initialize WDT with the given parameters
+      WDT_Enable(WDT, value);
+
+      // Configure and enable WDT interrupt.
+      NVIC_ClearPendingIRQ(WDT_IRQn);
+      NVIC_SetPriority(WDT_IRQn, 0); // Use highest priority, so we detect all kinds of lockups
+      NVIC_EnableIRQ(WDT_IRQn);
+
+    #else
+
+      // a WDT fault triggers a reset
+      value |= WDT_MR_WDRSTEN;
+
+      // Initialize WDT with the given parameters
+      WDT_Enable(WDT, value);
+
+    #endif
+
+    // Reset the watchdog
+    WDT_Restart(WDT);
+
+  #else
+
+    // Make sure to completely disable the Watchdog
+    WDT_Disable(WDT);
+
+  #endif
+}
+
+// ------------------------
 // Free Memory Accessor
 // ------------------------
 

Marlin/src/HAL/DUE/HAL.h

 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
-#include "watchdog.h"
 
 #include <stdint.h>
 
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
-  static void init();       // Called early in setup()
-  static void init_board(); // Called less early in setup()
-  static void reboot();     // Software reset
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
+  static void init();          // Called early in setup()
+  static void init_board();    // Called less early in setup()
+  static void reboot();        // Restart the firmware
 
   // Interrupts
   static bool isr_state() { return !__get_PRIMASK(); }

Marlin/src/HAL/DUE/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../inc/MarlinConfig.h"
-#include "../../MarlinCore.h"
-#include "watchdog.h"
-
-// Override Arduino runtime to either config or disable the watchdog
-//
-// We need to configure the watchdog as soon as possible in the boot
-// process, because watchdog initialization at hardware reset on SAM3X8E
-// is unreliable, and there is risk of unintended resets if we delay
-// that initialization to a later time.
-void watchdogSetup() {
-
-  #if ENABLED(USE_WATCHDOG)
-
-    // 4 seconds timeout
-    uint32_t timeout = TERN(WATCHDOG_DURATION_8S, 8000, 4000);
-
-    // Calculate timeout value in WDT counter ticks: This assumes
-    // the slow clock is running at 32.768 kHz watchdog
-    // frequency is therefore 32768 / 128 = 256 Hz
-    timeout = (timeout << 8) / 1000;
-    if (timeout == 0)
-      timeout = 1;
-    else if (timeout > 0xFFF)
-      timeout = 0xFFF;
-
-    // We want to enable the watchdog with the specified timeout
-    uint32_t value =
-      WDT_MR_WDV(timeout) |               // With the specified timeout
-      WDT_MR_WDD(timeout) |               // and no invalid write window
-    #if !(SAMV70 || SAMV71 || SAME70 || SAMS70)
-      WDT_MR_WDRPROC   |                  // WDT fault resets processor only - We want
-                                          // to keep PIO controller state
-    #endif
-      WDT_MR_WDDBGHLT  |                  // WDT stops in debug state.
-      WDT_MR_WDIDLEHLT;                   // WDT stops in idle state.
-
-    #if ENABLED(WATCHDOG_RESET_MANUAL)
-      // We enable the watchdog timer, but only for the interrupt.
-
-      // Configure WDT to only trigger an interrupt
-      value |= WDT_MR_WDFIEN;             // Enable WDT fault interrupt.
-
-      // Disable WDT interrupt (just in case, to avoid triggering it!)
-      NVIC_DisableIRQ(WDT_IRQn);
-
-      // We NEED memory barriers to ensure Interrupts are actually disabled!
-      // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-      __DSB();
-      __ISB();
-
-      // Initialize WDT with the given parameters
-      WDT_Enable(WDT, value);
-
-      // Configure and enable WDT interrupt.
-      NVIC_ClearPendingIRQ(WDT_IRQn);
-      NVIC_SetPriority(WDT_IRQn, 0); // Use highest priority, so we detect all kinds of lockups
-      NVIC_EnableIRQ(WDT_IRQn);
-
-    #else
-
-      // a WDT fault triggers a reset
-      value |= WDT_MR_WDRSTEN;
-
-      // Initialize WDT with the given parameters
-      WDT_Enable(WDT, value);
-
-    #endif
-
-    // Reset the watchdog
-    WDT_Restart(WDT);
-
-  #else
-
-    // Make sure to completely disable the Watchdog
-    WDT_Disable(WDT);
-
-  #endif
-}
-
-#if ENABLED(USE_WATCHDOG)
-  // Initialize watchdog - On SAM3X, Watchdog was already configured
-  //  and enabled or disabled at startup, so no need to reconfigure it
-  //  here.
-  void watchdog_init() {
-    // Reset watchdog to start clean
-    WDT_Restart(WDT);
-  }
-#endif // USE_WATCHDOG
-
-#endif

Marlin/src/HAL/DUE/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-// Arduino Due core now has watchdog support
-
-#include "HAL.h"
-
-// Initialize watchdog with a 4 second interrupt time
-void watchdog_init();
-
-// Reset watchdog. MUST be called at least every 4 seconds after the
-// first watchdog_init or AVR will go into emergency procedures.
-inline void HAL_watchdog_refresh() { watchdogReset(); }

Marlin/src/HAL/ESP32/HAL.cpp

 int MarlinHAL::freeMemory() { return ESP.getFreeHeap(); }
 
 // ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
+
+  extern "C" {
+    esp_err_t esp_task_wdt_reset();
+  }
+
+  void watchdogSetup() {
+    // do whatever. don't remove this function.
+  }
+
+  void MarlinHAL::watchdog_init() {
+    // TODO
+  }
+
+  // Reset watchdog.
+  void MarlinHAL::watchdog_refresh() { esp_task_wdt_reset(); }
+
+#endif
+
+// ------------------------
 // ADC
 // ------------------------
 

Marlin/src/HAL/ESP32/HAL.h

 #include "../shared/HAL_SPI.h"
 
 #include "fastio.h"
-#include "watchdog.h"
 #include "i2s.h"
 
 #if ENABLED(WIFISUPPORT)
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
-  static void init() {}  // Called early in setup()
-  static void init_board();     // Called less early in setup()
-  static void reboot();         // Restart the firmware
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
+  static void init() {}        // Called early in setup()
+  static void init_board();    // Called less early in setup()
+  static void reboot();        // Restart the firmware
 
   // Interrupts
   static portMUX_TYPE spinlock;

Marlin/src/HAL/ESP32/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
-
-#include "watchdog.h"
-
-void watchdogSetup() {
-  // do whatever. don't remove this function.
-}
-
-void watchdog_init() {
-  // TODO
-}
-
-#endif // USE_WATCHDOG
-
-#endif // ARDUINO_ARCH_ESP32

Marlin/src/HAL/ESP32/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-  esp_err_t esp_task_wdt_reset();
-
-#ifdef __cplusplus
-  }
-#endif
-
-// Initialize watchdog with a 4 second interrupt time
-void watchdog_init();
-
-// Reset watchdog.
-inline void HAL_watchdog_refresh() { esp_task_wdt_reset(); }

Marlin/src/HAL/HAL.h

 #ifndef PGMSTR
   #define PGMSTR(NAM,STR) const char NAM[] = STR
 #endif
-
-inline void watchdog_refresh() {
-  TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
-}

Marlin/src/HAL/LINUX/HAL.h

  */
 #pragma once
 
+#include "../../inc/MarlinConfigPre.h"
+
 #include <iostream>
 #include <stdint.h>
 #include <stdarg.h>
 #include <algorithm>
 
 #include "hardware/Clock.h"
-
 #include "../shared/Marduino.h"
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
-#include "watchdog.h"
 #include "serial.h"
 
 // ------------------------
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init() {}
+  static void watchdog_refresh() {}
+
   static void init() {}        // Called early in setup()
   static void init_board() {}  // Called less early in setup()
-  static void reboot();               // Reset the application state and GPIO
+  static void reboot();        // Reset the application state and GPIO
 
   // Interrupts
   static bool isr_state() { return true; }

Marlin/src/HAL/LINUX/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef __PLAT_LINUX__
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include "watchdog.h"
-
-#define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
-
-void watchdog_init() {}
-void HAL_watchdog_refresh() {}
-
-#endif
-
-#endif // __PLAT_LINUX__

Marlin/src/HAL/LINUX/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-void watchdog_init();
-void HAL_watchdog_refresh();

Marlin/src/HAL/LPC1768/HAL.cpp

 #include "../shared/Delay.h"
 #include "../../../gcode/parser.h"
 
-#if ENABLED(USE_WATCHDOG)
-  #include "watchdog.h"
-#endif
-
 DefaultSerial1 USBSerial(false, UsbSerial);
 
 uint32_t MarlinHAL::adc_result = 0;
   return RST_POWER_ON;
 }
 
-void MarlinHAL::clear_reset_source() {
-  TERN_(USE_WATCHDOG, watchdog_clear_timeout_flag());
-}
+void MarlinHAL::clear_reset_source() { watchdog_clear_timeout_flag(); }
 
 void flashFirmware(const int16_t) {
   delay(500);          // Give OS time to disconnect
   hal.reboot();
 }
 
+#if ENABLED(USE_WATCHDOG)
+
+  #include <lpc17xx_wdt.h>
+
+  #define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
+
+  void MarlinHAL::watchdog_init() {
+    #if ENABLED(WATCHDOG_RESET_MANUAL)
+      // We enable the watchdog timer, but only for the interrupt.
+
+      // Configure WDT to only trigger an interrupt
+      // Disable WDT interrupt (just in case, to avoid triggering it!)
+      NVIC_DisableIRQ(WDT_IRQn);
+
+      // We NEED memory barriers to ensure Interrupts are actually disabled!
+      // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
+      __DSB();
+      __ISB();
+
+      // Configure WDT to only trigger an interrupt
+      // Initialize WDT with the given parameters
+      WDT_Init(WDT_CLKSRC_IRC, WDT_MODE_INT_ONLY);
+
+      // Configure and enable WDT interrupt.
+      NVIC_ClearPendingIRQ(WDT_IRQn);
+      NVIC_SetPriority(WDT_IRQn, 0); // Use highest priority, so we detect all kinds of lockups
+      NVIC_EnableIRQ(WDT_IRQn);
+    #else
+      WDT_Init(WDT_CLKSRC_IRC, WDT_MODE_RESET);
+    #endif
+    WDT_Start(WDT_TIMEOUT_US);
+  }
+
+  void MarlinHAL::watchdog_refresh() {
+    WDT_Feed();
+    #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
+      TOGGLE(LED_PIN);  // heartbeat indicator
+    #endif
+  }
+
+  // Timeout state
+  bool MarlinHAL::watchdog_timed_out() { return TEST(WDT_ReadTimeOutFlag(), 0); }
+  void MarlinHAL::watchdog_clear_timeout_flag() { WDT_ClrTimeOutFlag(); }
+
+#endif // USE_WATCHDOG
+
 // For M42/M43, scan command line for pin code
 //   return index into pin map array if found and the pin is valid.
 //   return dval if not found or not a valid pin.

Marlin/src/HAL/LPC1768/HAL.h

 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
-#include "watchdog.h"
 #include "MarlinSerial.h"
 
 #include <adc.h>
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
-  static void init();                 // Called early in setup()
+  static void init();          // Called early in setup()
   static void init_board() {}  // Called less early in setup()
-  static void reboot();               // Restart the firmware from 0x0
+  static void reboot();        // Restart the firmware from 0x0
 
   // Interrupts
   static bool isr_state() { return !__get_PRIMASK(); }
 
   static void delay_ms(const int ms) { _delay_ms(ms); }
 
+  // Watchdog
+  static void watchdog_init() IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+  static bool watchdog_timed_out() IF_DISABLED(USE_WATCHDOG, { return false; });
+  static void watchdog_clear_timeout_flag() IF_DISABLED(USE_WATCHDOG, {});
+
   // Tasks, called from idle()
   static void idletask();
 

Marlin/src/HAL/LPC1768/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef TARGET_LPC1768
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include <lpc17xx_wdt.h>
-#include "watchdog.h"
-
-#define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
-
-void watchdog_init() {
-  #if ENABLED(WATCHDOG_RESET_MANUAL)
-    // We enable the watchdog timer, but only for the interrupt.
-
-    // Configure WDT to only trigger an interrupt
-    // Disable WDT interrupt (just in case, to avoid triggering it!)
-    NVIC_DisableIRQ(WDT_IRQn);
-
-    // We NEED memory barriers to ensure Interrupts are actually disabled!
-    // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-    __DSB();
-    __ISB();
-
-    // Configure WDT to only trigger an interrupt
-    // Initialize WDT with the given parameters
-    WDT_Init(WDT_CLKSRC_IRC, WDT_MODE_INT_ONLY);
-
-    // Configure and enable WDT interrupt.
-    NVIC_ClearPendingIRQ(WDT_IRQn);
-    NVIC_SetPriority(WDT_IRQn, 0); // Use highest priority, so we detect all kinds of lockups
-    NVIC_EnableIRQ(WDT_IRQn);
-  #else
-    WDT_Init(WDT_CLKSRC_IRC, WDT_MODE_RESET);
-  #endif
-  WDT_Start(WDT_TIMEOUT_US);
-}
-
-void HAL_watchdog_refresh() {
-  WDT_Feed();
-  #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
-    TOGGLE(LED_PIN);  // heartbeat indicator
-  #endif
-}
-
-// Timeout state
-bool watchdog_timed_out() { return TEST(WDT_ReadTimeOutFlag(), 0); }
-void watchdog_clear_timeout_flag() { WDT_ClrTimeOutFlag(); }
-
-#endif // USE_WATCHDOG
-#endif // TARGET_LPC1768

Marlin/src/HAL/LPC1768/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-void watchdog_init();
-void HAL_watchdog_refresh();
-
-bool watchdog_timed_out();
-void watchdog_clear_timeout_flag();

Marlin/src/HAL/NATIVE_SIM/HAL.h

 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
-#include "watchdog.h"
 #include "serial.h"
 
 // ------------------------
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
   static void init() {}        // Called early in setup()
   static void init_board() {}  // Called less early in setup()
   static void reboot();        // Restart the firmware from 0x0

Marlin/src/HAL/NATIVE_SIM/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#define WDT_TIMEOUT   4000000 // 4 second timeout
-
-void watchdog_init();
-void HAL_watchdog_refresh();

Marlin/src/HAL/SAMD51/HAL.cpp

   ADC_COUNT
 };
 
+#if ENABLED(USE_WATCHDOG)
+
+  #define WDT_TIMEOUT_REG TERN(WATCHDOG_DURATION_8S, WDT_CONFIG_PER_CYC8192, WDT_CONFIG_PER_CYC4096) // 4 or 8 second timeout
+
+  void MarlinHAL::watchdog_init() {
+    // The low-power oscillator used by the WDT runs at 32,768 Hz with
+    // a 1:32 prescale, thus 1024 Hz, though probably not super precise.
+
+    // Setup WDT clocks
+    MCLK->APBAMASK.bit.OSC32KCTRL_ = true;
+    MCLK->APBAMASK.bit.WDT_ = true;
+    OSC32KCTRL->OSCULP32K.bit.EN1K = true;  // Enable out 1K (this is what WDT uses)
+
+    WDT->CTRLA.bit.ENABLE = false;          // Disable watchdog for config
+    SYNC(WDT->SYNCBUSY.bit.ENABLE);
+
+    WDT->INTENCLR.reg = WDT_INTENCLR_EW;    // Disable early warning interrupt
+    WDT->CONFIG.reg = WDT_TIMEOUT_REG;      // Set a 4s or 8s period for chip reset
+
+    hal.watchdog_refresh();
+
+    WDT->CTRLA.reg = WDT_CTRLA_ENABLE;      // Start watchdog now in normal mode
+    SYNC(WDT->SYNCBUSY.bit.ENABLE);
+  }
+
+  // Reset watchdog. MUST be called at least every 4 seconds after the
+  // first watchdog_init or SAMD will go into emergency procedures.
+  void MarlinHAL::watchdog_refresh() {
+    SYNC(WDT->SYNCBUSY.bit.CLEAR);        // Test first if previous is 'ongoing' to save time waiting for command execution
+    WDT->CLEAR.reg = WDT_CLEAR_CLEAR_KEY;
+  }
+
+#endif
+
 // ------------------------
 // Types
 // ------------------------

Marlin/src/HAL/SAMD51/HAL.h

 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
-#include "watchdog.h"
 
 #ifdef ADAFRUIT_GRAND_CENTRAL_M4
   #include "MarlinSerial_AGCM4.h"
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
   static void init();          // Called early in setup()
   static void init_board() {}  // Called less early in setup()
   static void reboot();        // Restart the firmware from 0x0

Marlin/src/HAL/SAMD51/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef __SAMD51__
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include "watchdog.h"
-
-#define WDT_TIMEOUT_REG TERN(WATCHDOG_DURATION_8S, WDT_CONFIG_PER_CYC8192, WDT_CONFIG_PER_CYC4096) // 4 or 8 second timeout
-
-void watchdog_init() {
-  // The low-power oscillator used by the WDT runs at 32,768 Hz with
-  // a 1:32 prescale, thus 1024 Hz, though probably not super precise.
-
-  // Setup WDT clocks
-  MCLK->APBAMASK.bit.OSC32KCTRL_ = true;
-  MCLK->APBAMASK.bit.WDT_ = true;
-  OSC32KCTRL->OSCULP32K.bit.EN1K = true;      // Enable out 1K (this is what WDT uses)
-
-  WDT->CTRLA.bit.ENABLE = false;              // Disable watchdog for config
-  SYNC(WDT->SYNCBUSY.bit.ENABLE);
-
-  WDT->INTENCLR.reg = WDT_INTENCLR_EW;        // Disable early warning interrupt
-  WDT->CONFIG.reg = WDT_TIMEOUT_REG;          // Set a 4s or 8s period for chip reset
-
-  HAL_watchdog_refresh();
-
-  WDT->CTRLA.reg = WDT_CTRLA_ENABLE;          // Start watchdog now in normal mode
-  SYNC(WDT->SYNCBUSY.bit.ENABLE);
-}
-
-#endif // USE_WATCHDOG
-
-#endif // __SAMD51__

Marlin/src/HAL/SAMD51/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-// Initialize watchdog with a 4 second interrupt time
-void watchdog_init();
-
-// Reset watchdog. MUST be called at least every 4 seconds after the
-// first watchdog_init or SAMD will go into emergency procedures.
-inline void HAL_watchdog_refresh() {
-  SYNC(WDT->SYNCBUSY.bit.CLEAR);        // Test first if previous is 'ongoing' to save time waiting for command execution
-  WDT->CLEAR.reg = WDT_CLEAR_CLEAR_KEY;
-}

Marlin/src/HAL/STM32/HAL.cpp

 
 void MarlinHAL::clear_reset_source() { __HAL_RCC_CLEAR_RESET_FLAGS(); }
 
+// ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
+
+  #include <IWatchdog.h>
+
+  void MarlinHAL::watchdog_init() {
+    IF_DISABLED(DISABLE_WATCHDOG_INIT, IWatchdog.begin(WDT_TIMEOUT_US));
+  }
+
+  void MarlinHAL::watchdog_refresh() {
+    IWatchdog.reload();
+    #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
+      TOGGLE(LED_PIN);  // heartbeat indicator
+    #endif
+  }
+
+#endif
+
 extern "C" {
   extern unsigned int _ebss; // end of bss section
 }

Marlin/src/HAL/STM32/HAL.h

 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
 #include "Servo.h"
-#include "watchdog.h"
 #include "MarlinSerial.h"
 
 #include "../../inc/MarlinConfigPre.h"
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
-  static void init();                 // Called early in setup()
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
+  static void init();          // Called early in setup()
   static void init_board() {}  // Called less early in setup()
-  static void reboot();               // Restart the firmware from 0x0
+  static void reboot();        // Restart the firmware from 0x0
 
   // Interrupts
   static bool isr_state() { return !__get_PRIMASK(); }

Marlin/src/HAL/STM32/MinSerial.cpp

 #if ENABLED(POSTMORTEM_DEBUGGING)
 
 #include "../shared/MinSerial.h"
-#include "watchdog.h"
 
 /* Instruction Synchronization Barrier */
 #define isb() __asm__ __volatile__ ("isb" : : : "memory")
   #if WITHIN(SERIAL_PORT, 1, 6)
     constexpr uint32_t usart_sr_txe = _BV(7);
     while (!(regs->SR & usart_sr_txe)) {
-      TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+      hal.watchdog_refresh();
       sw_barrier();
     }
     regs->DR = c;

Marlin/src/HAL/STM32/sdio.cpp

 
   uint8_t retry_Cnt = retryCnt;
   for (;;) {
-    TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+    hal.watchdog_refresh();
     status = (bool) HAL_SD_Init(&hsd);
     if (!status) break;
     if (!--retry_Cnt) return false;   // return failing status if retries are exhausted
   #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3) // go to 4 bit wide mode if pins are defined
     retry_Cnt = retryCnt;
     for (;;) {
-      TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+      hal.watchdog_refresh();
       if (!HAL_SD_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B)) break;  // some cards are only 1 bit wide so a pass here is not required
       if (!--retry_Cnt) break;
     }
       SD_LowLevel_Init();
       retry_Cnt = retryCnt;
       for (;;) {
-        TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+        hal.watchdog_refresh();
         status = (bool) HAL_SD_Init(&hsd);
         if (!status) break;
         if (!--retry_Cnt) return false;   // return failing status if retries are exhausted
 static bool SDIO_ReadWriteBlock_DMA(uint32_t block, const uint8_t *src, uint8_t *dst) {
   if (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER) return false;
 
-  TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+  hal.watchdog_refresh();
 
   HAL_StatusTypeDef ret;
   if (src) {

Marlin/src/HAL/STM32/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-
-#include "../platforms.h"
-
-#ifdef HAL_STM32
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
-
-#include "../../inc/MarlinConfig.h"
-
-#include "watchdog.h"
-#include <IWatchdog.h>
-
-void watchdog_init() {
-  #if DISABLED(DISABLE_WATCHDOG_INIT)
-    IWatchdog.begin(WDT_TIMEOUT_US);
-  #endif
-}
-
-void HAL_watchdog_refresh() {
-  IWatchdog.reload();
-  #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
-    TOGGLE(LED_PIN);  // heartbeat indicator
-  #endif
-}
-
-#endif // USE_WATCHDOG
-#endif // HAL_STM32

Marlin/src/HAL/STM32/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-void watchdog_init();
-void HAL_watchdog_refresh();

Marlin/src/HAL/STM32F1/HAL.cpp

 #endif
 
 // ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #include <libmaple/iwdg.h>
+
+  void watchdogSetup() {
+    // do whatever. don't remove this function.
+  }
+
+  /**
+   *  The watchdog clock is 40Khz. So for a 4s or 8s interval use a /256 preescaler and 625 or 1250 reload value (counts down to 0).
+   */
+  #define STM32F1_WD_RELOAD TERN(WATCHDOG_DURATION_8S, 1250, 625) // 4 or 8 second timeout
+
+  /**
+   * @brief  Initialize the independent hardware watchdog.
+   *
+   * @return No return
+   *
+   * @details The watchdog clock is 40Khz. So for a 4s or 8s interval use a /256 preescaler and 625 or 1250 reload value (counts down to 0).
+   */
+  void MarlinHAL::watchdog_init() {
+    #if DISABLED(DISABLE_WATCHDOG_INIT)
+      iwdg_init(IWDG_PRE_256, STM32F1_WD_RELOAD);
+    #endif
+  }
+
+  // Reset watchdog. MUST be called every 4 or 8 seconds after the
+  // first watchdog_init or the STM32F1 will reset.
+  void MarlinHAL::watchdog_refresh() {
+    #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
+      TOGGLE(LED_PIN);  // heartbeat indicator
+    #endif
+    iwdg_feed();
+  }
+
+#endif // USE_WATCHDOG
+
+// ------------------------
 // ADC
 // ------------------------
 

Marlin/src/HAL/STM32F1/HAL.h

 #include "../shared/HAL_SPI.h"
 
 #include "fastio.h"
-#include "watchdog.h"
 
 #include <stdint.h>
 #include <util/atomic.h>
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
   static void init();          // Called early in setup()
   static void init_board() {}  // Called less early in setup()
   static void reboot();        // Restart the firmware from 0x0

Marlin/src/HAL/STM32F1/MinSerial.cpp

 #if ENABLED(POSTMORTEM_DEBUGGING)
 
 #include "../shared/MinSerial.h"
-#include "watchdog.h"
 
 #include <libmaple/usart.h>
 #include <libmaple/rcc.h>
   #if WITHIN(SERIAL_PORT, 1, 6)
     struct usart_dev* dev = MYSERIAL1.c_dev();
     while (!(dev->regs->SR & USART_SR_TXE)) {
-      TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+      hal.watchdog_refresh();
       sw_barrier();
     }
     dev->regs->DR = c;

Marlin/src/HAL/STM32F1/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * HAL for stm32duino.com based on Libmaple and compatible (STM32F1)
- */
-
-#ifdef __STM32F1__
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include <libmaple/iwdg.h>
-#include "watchdog.h"
-
-/**
- *  The watchdog clock is 40Khz. So for a 4s or 8s interval use a /256 preescaler and 625 or 1250 reload value (counts down to 0).
- */
-#define STM32F1_WD_RELOAD TERN(WATCHDOG_DURATION_8S, 1250, 625) // 4 or 8 second timeout
-
-void HAL_watchdog_refresh() {
-  #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
-    TOGGLE(LED_PIN);  // heartbeat indicator
-  #endif
-  iwdg_feed();
-}
-
-void watchdogSetup() {
-  // do whatever. don't remove this function.
-}
-
-/**
- * @brief  Initialized the independent hardware watchdog.
- *
- * @return No return
- *
- * @details The watchdog clock is 40Khz. So for a 4s or 8s interval use a /256 preescaler and 625 or 1250 reload value (counts down to 0).
- */
-void watchdog_init() {
-  #if DISABLED(DISABLE_WATCHDOG_INIT)
-    iwdg_init(IWDG_PRE_256, STM32F1_WD_RELOAD);
-  #endif
-}
-
-#endif // USE_WATCHDOG
-#endif // __STM32F1__

Marlin/src/HAL/STM32F1/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * HAL for stm32duino.com based on Libmaple and compatible (STM32F1)
- */
-
-#include <libmaple/iwdg.h>
-
-// Initialize watchdog with a 4 or 8 second countdown time
-void watchdog_init();
-
-// Reset watchdog. MUST be called every 4 or 8 seconds after the
-// first watchdog_init or the STM32F1 will reset.
-void HAL_watchdog_refresh();

Marlin/src/HAL/TEENSY31_32/HAL.cpp

 }
 
 // ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #define WDT_TIMEOUT_MS TERN(WATCHDOG_DURATION_8S, 8000, 4000) // 4 or 8 second timeout
+
+  void MarlinHAL::watchdog_init() {
+    WDOG_TOVALH = 0;
+    WDOG_TOVALL = WDT_TIMEOUT_MS;
+    WDOG_STCTRLH = WDOG_STCTRLH_WDOGEN;
+  }
+
+  void MarlinHAL::watchdog_refresh() {
+    // Watchdog refresh sequence
+    WDOG_REFRESH = 0xA602;
+    WDOG_REFRESH = 0xB480;
+  }
+
+#endif
+
+// ------------------------
 // ADC
 // ------------------------
 

Marlin/src/HAL/TEENSY31_32/HAL.h

 #include "../shared/HAL_SPI.h"
 
 #include "fastio.h"
-#include "watchdog.h"
 
 #include <stdint.h>
 
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
   static void init() {}        // Called early in setup()
   static void init_board() {}  // Called less early in setup()
   static void reboot();        // Restart the firmware from 0x0

Marlin/src/HAL/TEENSY31_32/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef __MK20DX256__
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include "watchdog.h"
-
-#define WDT_TIMEOUT_MS TERN(WATCHDOG_DURATION_8S, 8000, 4000) // 4 or 8 second timeout
-
-void watchdog_init() {
-  WDOG_TOVALH = 0;
-  WDOG_TOVALL = WDT_TIMEOUT_MS;
-  WDOG_STCTRLH = WDOG_STCTRLH_WDOGEN;
-}
-
-#endif // USE_WATCHDOG
-
-#endif // __MK20DX256__

Marlin/src/HAL/TEENSY31_32/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "HAL.h"
-
-// Arduino Due core now has watchdog support
-
-void watchdog_init();
-
-inline void HAL_watchdog_refresh() {
-  // Watchdog refresh sequence
-  WDOG_REFRESH = 0xA602;
-  WDOG_REFRESH = 0xB480;
-}

Marlin/src/HAL/TEENSY35_36/HAL.cpp

 }
 
 // ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #define WDT_TIMEOUT_MS TERN(WATCHDOG_DURATION_8S, 8000, 4000) // 4 or 8 second timeout
+
+  void MarlinHAL::watchdog_init() {
+    WDOG_TOVALH = 0;
+    WDOG_TOVALL = WDT_TIMEOUT_MS;
+    WDOG_STCTRLH = WDOG_STCTRLH_WDOGEN;
+  }
+
+  void MarlinHAL::watchdog_refresh() {
+    // Watchdog refresh sequence
+    WDOG_REFRESH = 0xA602;
+    WDOG_REFRESH = 0xB480;
+  }
+
+#endif
+
+// ------------------------
 // ADC
 // ------------------------
 

Marlin/src/HAL/TEENSY35_36/HAL.h

 #include "../shared/HAL_SPI.h"
 
 #include "fastio.h"
-#include "watchdog.h"
 
 #include <stdint.h>
 #include <util/atomic.h>
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
   static void init() {}        // Called early in setup()
   static void init_board() {}  // Called less early in setup()
   static void reboot();        // Restart the firmware from 0x0

Marlin/src/HAL/TEENSY35_36/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include "watchdog.h"
-
-#define WDT_TIMEOUT_MS TERN(WATCHDOG_DURATION_8S, 8000, 4000) // 4 or 8 second timeout
-
-void watchdog_init() {
-  WDOG_TOVALH = 0;
-  WDOG_TOVALL = WDT_TIMEOUT_MS;
-  WDOG_STCTRLH = WDOG_STCTRLH_WDOGEN;
-}
-
-#endif // USE_WATCHDOG
-
-#endif // __MK64FX512__ || __MK66FX1M0__

Marlin/src/HAL/TEENSY35_36/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-void watchdog_init();
-
-inline void HAL_watchdog_refresh() {
-  // Watchdog refresh sequence
-  WDOG_REFRESH = 0xA602;
-  WDOG_REFRESH = 0xB480;
-}

Marlin/src/HAL/TEENSY40_41/HAL.cpp

 }
 
 // ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #define WDT_TIMEOUT TERN(WATCHDOG_DURATION_8S, 8, 4) // 4 or 8 second timeout
+
+  constexpr uint8_t timeoutval = (WDT_TIMEOUT - 0.5f) / 0.5f;
+
+  void MarlinHAL::watchdog_init() {
+    CCM_CCGR3 |= CCM_CCGR3_WDOG1(3);  // enable WDOG1 clocks
+    WDOG1_WMCR = 0;                   // disable power down PDE
+    WDOG1_WCR |= WDOG_WCR_SRS | WDOG_WCR_WT(timeoutval);
+    WDOG1_WCR |= WDOG_WCR_WDE | WDOG_WCR_WDT | WDOG_WCR_SRE;
+  }
+
+  void MarlinHAL::watchdog_refresh() {
+    // Watchdog refresh sequence
+    WDOG1_WSR = 0x5555;
+    WDOG1_WSR = 0xAAAA;
+  }
+
+#endif
+
+// ------------------------
 // ADC
 // ------------------------
 

Marlin/src/HAL/TEENSY40_41/HAL.h

 #include "../shared/HAL_SPI.h"
 
 #include "fastio.h"
-#include "watchdog.h"
 
 #include <stdint.h>
 #include <util/atomic.h>
   // Earliest possible init, before setup()
   MarlinHAL() {}
 
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
   static void init() {}        // Called early in setup()
   static void init_board() {}  // Called less early in setup()
   static void reboot();        // Restart the firmware from 0x0

Marlin/src/HAL/TEENSY40_41/watchdog.cpp

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef __IMXRT1062__
-
-/**
- * HAL Watchdog for Teensy 4.0 (IMXRT1062DVL6A) / 4.1 (IMXRT1062DVJ6A)
- */
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(USE_WATCHDOG)
-
-#include "watchdog.h"
-
-#define WDT_TIMEOUT TERN(WATCHDOG_DURATION_8S, 8, 4) // 4 or 8 second timeout
-
-constexpr uint8_t timeoutval = (WDT_TIMEOUT - 0.5f) / 0.5f;
-
-void watchdog_init() {
-  CCM_CCGR3 |= CCM_CCGR3_WDOG1(3);  // enable WDOG1 clocks
-  WDOG1_WMCR = 0;                   // disable power down PDE
-  WDOG1_WCR |= WDOG_WCR_SRS | WDOG_WCR_WT(timeoutval);
-  WDOG1_WCR |= WDOG_WCR_WDE | WDOG_WCR_WDT | WDOG_WCR_SRE;
-}
-
-void HAL_watchdog_refresh() {
-  // Watchdog refresh sequence
-  WDOG1_WSR = 0x5555;
-  WDOG1_WSR = 0xAAAA;
-}
-
-#endif // USE_WATCHDOG
-#endif // __IMXRT1062__

Marlin/src/HAL/TEENSY40_41/watchdog.h

-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * HAL Watchdog for Teensy 4.0 (IMXRT1062DVL6A) / 4.1 (IMXRT1062DVJ6A)
- */
-
-void watchdog_init();
-
-void HAL_watchdog_refresh();

Marlin/src/MarlinCore.cpp

 
     // Wait for both KILL and ENC to be released
     while (TERN0(HAS_KILL, kill_state()) || TERN0(SOFT_RESET_ON_KILL, ui.button_pressed()))
-      watchdog_refresh();
+      hal.watchdog_refresh();
 
     // Wait for either KILL or ENC to be pressed again
     while (TERN1(HAS_KILL, !kill_state()) && TERN1(SOFT_RESET_ON_KILL, !ui.button_pressed()))
-      watchdog_refresh();
+      hal.watchdog_refresh();
 
     // Reboot the board
     hal.reboot();
 
   #else
 
-    for (;;) watchdog_refresh();  // Wait for RESET button or power-cycle
+    for (;;) hal.watchdog_refresh();  // Wait for RESET button or power-cycle
 
   #endif
 }
   #endif
 
   #if ENABLED(USE_WATCHDOG)
-    SETUP_RUN(watchdog_init());       // Reinit watchdog after hal.get_reset_source call
+    SETUP_RUN(hal.watchdog_init());   // Reinit watchdog after hal.get_reset_source call
   #endif
 
   #if ENABLED(EXTERNAL_CLOSED_LOOP_CONTROLLER)

Marlin/src/gcode/config/M43.cpp

       SERIAL_EOL();
     }
     else {
-      watchdog_refresh();
+      hal.watchdog_refresh();
       report_pin_state_extended(pin, ignore_protection, true, F("Pulsing   "));
       #ifdef __STM32F1__
         const auto prior_mode = _GET_MODE(i);
       {
         pinMode(pin, OUTPUT);
         for (int16_t j = 0; j < repeat; j++) {
-          watchdog_refresh(); extDigitalWrite(pin, 0); safe_delay(wait);
-          watchdog_refresh(); extDigitalWrite(pin, 1); safe_delay(wait);
-          watchdog_refresh(); extDigitalWrite(pin, 0); safe_delay(wait);
-          watchdog_refresh();
+          hal.watchdog_refresh(); extDigitalWrite(pin, 0); safe_delay(wait);
+          hal.watchdog_refresh(); extDigitalWrite(pin, 1); safe_delay(wait);
+          hal.watchdog_refresh(); extDigitalWrite(pin, 0); safe_delay(wait);
+          hal.watchdog_refresh();
         }
       }
       #ifdef __STM32F1__

Marlin/src/gcode/feature/L6470/M916-M918.cpp

         }
         DEBUG_ECHOLNPGM(".");
         reset_stepper_timeout(); // keep steppers powered
-        watchdog_refresh();
         safe_delay(5000);
         status_composite_temp = 0;
         for (j = 0; j < driver_count; j++) {

Marlin/src/gcode/gcode_d.cpp

 
         c = 1024 * 4;
         while (c--) {
-          TERN_(USE_WATCHDOG, watchdog_refresh());
+          hal.watchdog_refresh();
           card.write(buf, COUNT(buf));
         }
         SERIAL_ECHOLNPGM(" done");
         __attribute__((aligned(sizeof(size_t)))) uint8_t buf[512];
         uint16_t c = 1024 * 4;
         while (c--) {
-          TERN_(USE_WATCHDOG, watchdog_refresh());
+          hal.watchdog_refresh();
           card.read(buf, COUNT(buf));
           bool error = false;
           for (uint16_t i = 0; i < COUNT(buf); i++) {

Marlin/src/lcd/e3v2/proui/meshviewer.cpp

   LOOP_S_L_N(x, 1, sizex - 1) DrawMeshVLine(x);
   LOOP_S_L_N(y, 1, sizey - 1) DrawMeshHLine(y);
   LOOP_L_N(y, sizey) {
-    watchdog_refresh();
+    hal.watchdog_refresh();
     LOOP_L_N(x, sizex) {
       uint16_t color = DWINUI::RainbowInt(zmesh[x][y], _MIN(-5, minz), _MAX(5, maxz));
       uint8_t radius = rm(zmesh[x][y]);

Marlin/src/lcd/extui/mks_ui/draw_print_file.cpp

     char temp_test[200];
     volatile uint16_t *p_index;
 
-    watchdog_refresh();
+    hal.watchdog_refresh();
     memset(public_buf, 0, 200);
 
     while (card.isFileOpen()) {

Marlin/src/lcd/extui/mks_ui/draw_z_offset_wizard.cpp

       sync_plan_position();
       // Raise Z as if it was homed
       do_z_clearance(Z_POST_CLEARANCE);
-      watchdog_refresh();
+      hal.watchdog_refresh();
       draw_return_ui();
       return;
     case ID_M_RETURN:
       #else // Otherwise do a Z clearance move like after Homing
         do_z_clearance(Z_POST_CLEARANCE);
       #endif
-      watchdog_refresh();
+      hal.watchdog_refresh();
       draw_return_ui();
       return;
   }

Marlin/src/lcd/extui/mks_ui/pic_manager.cpp

   W25QXX.init(SPI_QUARTER_SPEED);
   // erase 0x001000 -64K
   for (pic_sectorcnt = 0; pic_sectorcnt < (64 - 4) / 4; pic_sectorcnt++) {
-    watchdog_refresh();
+    hal.watchdog_refresh();
     W25QXX.SPI_FLASH_SectorErase(PICINFOADDR + pic_sectorcnt * 4 * 1024);
   }
   // erase 64K -- 6M
   for (pic_sectorcnt = 0; pic_sectorcnt < (PIC_SIZE_xM * 1024 / 64 - 1); pic_sectorcnt++) {
-    watchdog_refresh();
+    hal.watchdog_refresh();
     W25QXX.SPI_FLASH_BlockErase((pic_sectorcnt + 1) * 64 * 1024);
   }
 }
     volatile uint32_t Font_sectorcnt = 0;
     W25QXX.init(SPI_QUARTER_SPEED);
     for (Font_sectorcnt = 0; Font_sectorcnt < 32 - 1; Font_sectorcnt++) {
-      watchdog_refresh();
+      hal.watchdog_refresh();
       W25QXX.SPI_FLASH_BlockErase(FONTINFOADDR + Font_sectorcnt * 64 * 1024);
     }
   }
       return;
     }
 
-    watchdog_refresh();
+    hal.watchdog_refresh();
     disp_assets_update_progress(fn);
 
     W25QXX.init(SPI_QUARTER_SPEED);
     totalSizeLoaded += pfileSize;
     if (assetType == ASSET_TYPE_LOGO) {
       do {
-        watchdog_refresh();
+        hal.watchdog_refresh();
         pbr = file.read(public_buf, BMP_WRITE_BUF_LEN);
         Pic_Logo_Write((uint8_t*)fn, public_buf, pbr);
       } while (pbr >= BMP_WRITE_BUF_LEN);
     }
     else if (assetType == ASSET_TYPE_TITLE_LOGO) {
       do {
-        watchdog_refresh();
+        hal.watchdog_refresh();
         pbr = file.read(public_buf, BMP_WRITE_BUF_LEN);
         Pic_TitleLogo_Write((uint8_t*)fn, public_buf, pbr);
       } while (pbr >= BMP_WRITE_BUF_LEN);
     }
     else if (assetType == ASSET_TYPE_G_PREVIEW) {
       do {
-        watchdog_refresh();
+        hal.watchdog_refresh();
         pbr = file.read(public_buf, BMP_WRITE_BUF_LEN);
         default_view_Write(public_buf, pbr);
       } while (pbr >= BMP_WRITE_BUF_LEN);
       SPIFlash.beginWrite(Pic_Write_Addr);
       #if HAS_SPI_FLASH_COMPRESSION
         do {
-          watchdog_refresh();
+          hal.watchdog_refresh();
           pbr = file.read(public_buf, SPI_FLASH_PageSize);
           TERN_(MARLIN_DEV_MODE, totalSizes += pbr);
           SPIFlash.writeData(public_buf, SPI_FLASH_PageSize);
     else if (assetType == ASSET_TYPE_FONT) {
       Pic_Write_Addr = UNIGBK_FLASH_ADDR;
       do {
-        watchdog_refresh();
+        hal.watchdog_refresh();
         pbr = file.read(public_buf, BMP_WRITE_BUF_LEN);
         W25QXX.SPI_FLASH_BufferWrite(public_buf, Pic_Write_Addr, pbr);
         Pic_Write_Addr += pbr;
 
       disp_assets_update();
       disp_assets_update_progress(F("Erasing pics..."));
-      watchdog_refresh();
+      hal.watchdog_refresh();
       spiFlashErase_PIC();
       #if HAS_SPI_FLASH_FONT
         disp_assets_update_progress(F("Erasing fonts..."));
-        watchdog_refresh();
+        hal.watchdog_refresh();
         spiFlashErase_FONT();
       #endif
 

Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp

   ui_cfg_init();
   disp_language_init();
 
-  watchdog_refresh();     // LVGL init takes time
+  hal.watchdog_refresh();     // LVGL init takes time
 
   // Init TFT first!
   SPI_TFT.spi_init(SPI_FULL_SPEED);
   SPI_TFT.LCD_init();
 
-  watchdog_refresh();     // LVGL init takes time
+  hal.watchdog_refresh();     // LVGL init takes time
 
   #if ENABLED(USB_FLASH_DRIVE_SUPPORT)
     uint16_t usb_flash_loop = 1000;
     #endif
     do {
       card.media_driver_usbFlash.idle();
-      watchdog_refresh();
+      hal.watchdog_refresh();
       delay(2);
     } while (!card.media_driver_usbFlash.isInserted() && usb_flash_loop--);
     card.mount();
   #elif HAS_LOGO_IN_FLASH
     delay(1000);
-    watchdog_refresh();
+    hal.watchdog_refresh();
     delay(1000);
   #endif
 
-  watchdog_refresh();     // LVGL init takes time
+  hal.watchdog_refresh();     // LVGL init takes time
 
   #if ENABLED(SDSUPPORT)
     UpdateAssets();
-    watchdog_refresh();   // LVGL init takes time
+    hal.watchdog_refresh();   // LVGL init takes time
     TERN_(MKS_TEST, mks_test_get());
   #endif
 

Marlin/src/lcd/extui/mks_ui/wifi_module.cpp

 void wifi_delay(int n) {
   const uint32_t start = getWifiTick();
   while (getWifiTickDiff(start, getWifiTick()) < (uint32_t)n)
-    watchdog_refresh();
+    hal.watchdog_refresh();
 }
 
 void wifi_reset() {
 void wifi_looping() {
   do {
     wifi_rcv_handle();
-    watchdog_refresh();
+    hal.watchdog_refresh();
   } while (wifi_link_state == WIFI_TRANS_FILE);
 }
 
 
   esp_state = TRANSFER_IDLE;
   esp_port_begin(1);
-  watchdog_refresh();
+  hal.watchdog_refresh();
   wifi_reset();
 
   #if 0
 }
 
 void mks_wifi_firmware_update() {
-  watchdog_refresh();
+  hal.watchdog_refresh();
   card.openFileRead((char *)ESP_FIRMWARE_FILE);
 
   if (card.isFileOpen()) {
     card.closefile();
 
     wifi_delay(2000);
-    watchdog_refresh();
+    hal.watchdog_refresh();
     if (usartFifoAvailable((SZ_USART_FIFO *)&WifiRxFifo) < 20) return;
 
     clear_cur_ui();
     lv_draw_dialog(DIALOG_TYPE_UPDATE_ESP_FIRMWARE);
 
     lv_task_handler();
-    watchdog_refresh();
+    hal.watchdog_refresh();
 
     if (wifi_upload(0) >= 0) {
       card.removeFile((char *)ESP_FIRMWARE_FILE_RENAME);

Marlin/src/lcd/extui/mks_ui/wifi_upload.cpp

     EspUploadResult stat;
 
     //IWDG_ReloadCounter();
-    watchdog_refresh();
+    hal.watchdog_refresh();
 
     if (getWifiTickDiff(startTime, getWifiTick()) > msTimeout)
       return timeout;
     for (;;) {
       size_t bodyLen;
       EspUploadResult rc = readPacket(ESP_SYNC, 0, &bodyLen, defaultTimeout);
-      watchdog_refresh();
+      hal.watchdog_refresh();
       if (rc != success || bodyLen != 2) break;
     }
   }
 
   while (esp_upload.state != upload_idle) {
     upload_spin();
-    watchdog_refresh();
+    hal.watchdog_refresh();
   }
 
   ResetWiFiForUpload(1);

Marlin/src/module/temperature.cpp

   thermalManager.disable_all_heaters();
   #if HAS_BEEPER
     for (uint8_t i = 20; i--;) {
-      watchdog_refresh();
+      hal.watchdog_refresh();
       buzzer.click(25);
       delay(80);
-      watchdog_refresh();
+      hal.watchdog_refresh();
     }
     buzzer.on();
   #endif
   }
 
   disable_all_heaters(); // always disable (even for bogus temp)
-  watchdog_refresh();
+  hal.watchdog_refresh();
 
   #if BOGUS_TEMPERATURE_GRACE_PERIOD
     const millis_t ms = millis();
  *  - Update the heated bed PID output value
  */
 void Temperature::manage_heater() {
-  if (marlin_state == MF_INITIALIZING) return watchdog_refresh(); // If Marlin isn't started, at least reset the watchdog!
+  if (marlin_state == MF_INITIALIZING) return hal.watchdog_refresh(); // If Marlin isn't started, at least reset the watchdog!
 
   static bool no_reentry = false;  // Prevent recursion
   if (no_reentry) return;
  */
 void Temperature::updateTemperaturesFromRawValues() {
 
-  watchdog_refresh(); // Reset because raw_temps_ready was set by the interrupt
+  hal.watchdog_refresh(); // Reset because raw_temps_ready was set by the interrupt
 
   TERN_(TEMP_SENSOR_0_IS_MAX_TC, temp_hotend[0].setraw(READ_MAX_TC(0)));
   TERN_(TEMP_SENSOR_1_IS_MAX_TC, temp_hotend[1].setraw(READ_MAX_TC(1)));

Marlin/src/sd/Sd2Card.cpp

   const millis_t init_timeout = millis() + SD_INIT_TIMEOUT;
   uint32_t arg;
 
-  watchdog_refresh(); // In case init takes too long
+  hal.watchdog_refresh(); // In case init takes too long
 
   // Set pin modes
   #if ENABLED(ZONESTAR_12864OLED)
   // Must supply min of 74 clock cycles with CS high.
   LOOP_L_N(i, 10) spiSend(0xFF);
 
-  watchdog_refresh(); // In case init takes too long
+  hal.watchdog_refresh(); // In case init takes too long
 
   // Command to go idle in SPI mode
   while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
     crcSupported = (cardCommand(CMD59, 1) == R1_IDLE_STATE);
   #endif
 
-  watchdog_refresh(); // In case init takes too long
+  hal.watchdog_refresh(); // In case init takes too long
 
   // check SD version
   for (;;) {
     }
   }
 
-  watchdog_refresh(); // In case init takes too long
+  hal.watchdog_refresh(); // In case init takes too long
 
   // Initialize card and send host supports SDHC if SD2
   arg = type() == SD_CARD_TYPE_SD2 ? 0x40000000 : 0;