🎨 Rename HAL timer elements

Marlin/src/HAL/AVR/timers.h

 
 #define HAL_TIMER_RATE          ((F_CPU) / 8)    // i.e., 2MHz or 2.5MHz
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        1
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         1
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        0
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         0
 #endif
 
 #define TEMP_TIMER_FREQUENCY    ((F_CPU) / 64.0 / 256.0)
 
 FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
   switch (timer_num) {
-    case STEP_TIMER_NUM:
+    case MF_TIMER_STEP:
       // waveform generation = 0100 = CTC
       SET_WGM(1, CTC_OCRnA);
 
       TCNT1 = 0;
       break;
 
-    case TEMP_TIMER_NUM:
+    case MF_TIMER_TEMP:
       // Use timer0 for temperature measurement
       // Interleave temperature interrupt with millies interrupt
       OCR0B = 128;

Marlin/src/HAL/DUE/Tone.cpp

 void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) {
   tone_pin = _pin;
   toggles = 2 * frequency * duration / 1000;
-  HAL_timer_start(TONE_TIMER_NUM, 2 * frequency);
+  HAL_timer_start(MF_TIMER_TONE, 2 * frequency);
 }
 
 void noTone(const pin_t _pin) {
-  HAL_timer_disable_interrupt(TONE_TIMER_NUM);
+  HAL_timer_disable_interrupt(MF_TIMER_TONE);
   extDigitalWrite(_pin, LOW);
 }
 
 HAL_TONE_TIMER_ISR() {
   static uint8_t pin_state = 0;
-  HAL_timer_isr_prologue(TONE_TIMER_NUM);
+  HAL_timer_isr_prologue(MF_TIMER_TONE);
 
   if (toggles) {
     toggles--;

Marlin/src/HAL/DUE/timers.cpp

 // Private Variables
 // ------------------------
 
-const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
+const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
   { TC0, 0, TC0_IRQn,  3}, // 0 - [servo timer5]
   { TC0, 1, TC1_IRQn,  0}, // 1
   { TC0, 2, TC2_IRQn,  2}, // 2 - stepper
 */
 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
-  Tc *tc = TimerConfig[timer_num].pTimerRegs;
-  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
-  uint32_t channel = TimerConfig[timer_num].channel;
+  Tc *tc = timer_config[timer_num].pTimerRegs;
+  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
+  uint32_t channel = timer_config[timer_num].channel;
 
   // Disable interrupt, just in case it was already enabled
   NVIC_DisableIRQ(irq);
 
   pmc_set_writeprotect(false);
   pmc_enable_periph_clk((uint32_t)irq);
-  NVIC_SetPriority(irq, TimerConfig [timer_num].priority);
+  NVIC_SetPriority(irq, timer_config[timer_num].priority);
 
   // wave mode, reset counter on match with RC,
   TC_Configure(tc, channel, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1);
 }
 
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
-  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
   NVIC_EnableIRQ(irq);
 }
 
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
-  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
   NVIC_DisableIRQ(irq);
 
   // We NEED memory barriers to ensure Interrupts are actually disabled!
 }
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
-  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
   return NVIC_GetEnabledIRQ(irq);
 }
 

Marlin/src/HAL/DUE/timers.h

 
 #define HAL_TIMER_RATE         ((F_CPU) / 2)    // frequency of timers peripherals
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        2  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         2  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        4  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         4  // Timer Index for Temperature
 #endif
-#ifndef TONE_TIMER_NUM
-  #define TONE_TIMER_NUM        6  // index of timer to use for beeper tones
+#ifndef MF_TIMER_TONE
+  #define MF_TIMER_TONE         6  // index of timer to use for beeper tones
 #endif
 
 #define TEMP_TIMER_FREQUENCY   1000 // temperature interrupt frequency
 
-#define STEPPER_TIMER_RATE     HAL_TIMER_RATE   // frequency of stepper timer (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)
-#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
-#define STEPPER_TIMER_PRESCALE (CYCLES_PER_MICROSECOND / STEPPER_TIMER_TICKS_PER_US)
+#define STEPPER_TIMER_RATE          HAL_TIMER_RATE                                        // frequency of stepper timer (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)
+#define STEPPER_TIMER_TICKS_PER_US  ((STEPPER_TIMER_RATE) / 1000000)                      // stepper timer ticks per µs
+#define STEPPER_TIMER_PRESCALE      (CYCLES_PER_MICROSECOND / STEPPER_TIMER_TICKS_PER_US)
 
-#define PULSE_TIMER_RATE       STEPPER_TIMER_RATE   // frequency of pulse timer
-#define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
-#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
+#define PULSE_TIMER_RATE            STEPPER_TIMER_RATE                                    // frequency of pulse timer
+#define PULSE_TIMER_PRESCALE        STEPPER_TIMER_PRESCALE
+#define PULSE_TIMER_TICKS_PER_US    STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_STEP_TIMER_ISR
   #define HAL_STEP_TIMER_ISR() void TC2_Handler()
 // Public Variables
 // ------------------------
 
-extern const tTimerConfig TimerConfig[];
+extern const tTimerConfig timer_config[];
 
 // ------------------------
 // Public functions
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
 
 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
-  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
+  const tTimerConfig * const pConfig = &timer_config[timer_num];
   pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC = compare;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
-  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
+  const tTimerConfig * const pConfig = &timer_config[timer_num];
   return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
-  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
+  const tTimerConfig * const pConfig = &timer_config[timer_num];
   return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_CV;
 }
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num);
 
 FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
-  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
+  const tTimerConfig * const pConfig = &timer_config[timer_num];
   // Reading the status register clears the interrupt flag
   pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_SR;
 }

Marlin/src/HAL/ESP32/HAL.cpp

     idx = numPWMUsed;
     pwmPins[idx] = pin;
     // Start timer on first use
-    if (idx == 0) HAL_timer_start(PWM_TIMER_NUM, PWM_TIMER_FREQUENCY);
+    if (idx == 0) HAL_timer_start(MF_TIMER_PWM, PWM_TIMER_FREQUENCY);
 
     ++numPWMUsed;
   }
 
 // Handle PWM timer interrupt
 HAL_PWM_TIMER_ISR() {
-  HAL_timer_isr_prologue(PWM_TIMER_NUM);
+  HAL_timer_isr_prologue(MF_TIMER_PWM);
 
   static uint8_t count = 0;
 
   // 128 for 7 Bit resolution
   count = (count + 1) & 0x7F;
 
-  HAL_timer_isr_epilogue(PWM_TIMER_NUM);
+  HAL_timer_isr_epilogue(MF_TIMER_PWM);
 }
 
 #endif // ARDUINO_ARCH_ESP32

Marlin/src/HAL/ESP32/Tone.cpp

 void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) {
   tone_pin = _pin;
   toggles = 2 * frequency * duration / 1000;
-  HAL_timer_start(TONE_TIMER_NUM, 2 * frequency);
+  HAL_timer_start(MF_TIMER_TONE, 2 * frequency);
 }
 
 void noTone(const pin_t _pin) {
-  HAL_timer_disable_interrupt(TONE_TIMER_NUM);
+  HAL_timer_disable_interrupt(MF_TIMER_TONE);
   WRITE(_pin, LOW);
 }
 
 HAL_TONE_TIMER_ISR() {
-  HAL_timer_isr_prologue(TONE_TIMER_NUM);
+  HAL_timer_isr_prologue(MF_TIMER_TONE);
 
   if (toggles) {
     toggles--;

Marlin/src/HAL/ESP32/timers.cpp

 
 static timg_dev_t *TG[2] = {&TIMERG0, &TIMERG1};
 
-const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
+const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
   { TIMER_GROUP_0, TIMER_0, STEPPER_TIMER_PRESCALE, stepTC_Handler }, // 0 - Stepper
   { TIMER_GROUP_0, TIMER_1,    TEMP_TIMER_PRESCALE, tempTC_Handler }, // 1 - Temperature
   { TIMER_GROUP_1, TIMER_0,     PWM_TIMER_PRESCALE, pwmTC_Handler  }, // 2 - PWM
 // ------------------------
 
 void IRAM_ATTR timer_isr(void *para) {
-  const tTimerConfig& timer = TimerConfig[(int)para];
+  const tTimerConfig& timer = timer_config[(int)para];
 
   // Retrieve the interrupt status and the counter value
   // from the timer that reported the interrupt
  * @param frequency frequency of the timer
  */
 void HAL_timer_start(const uint8_t timer_num, uint32_t frequency) {
-  const tTimerConfig timer = TimerConfig[timer_num];
+  const tTimerConfig timer = timer_config[timer_num];
 
   timer_config_t config;
   config.divider     = timer.divider;
  * @param count     threshold at which the interrupt is triggered
  */
 void HAL_timer_set_compare(const uint8_t timer_num, hal_timer_t count) {
-  const tTimerConfig timer = TimerConfig[timer_num];
+  const tTimerConfig timer = timer_config[timer_num];
   timer_set_alarm_value(timer.group, timer.idx, count);
 }
 
  * @return           the timer current threshold for the alarm to be triggered
  */
 hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
-  const tTimerConfig timer = TimerConfig[timer_num];
+  const tTimerConfig timer = timer_config[timer_num];
 
   uint64_t alarm_value;
   timer_get_alarm_value(timer.group, timer.idx, &alarm_value);
  * @return           the current counter of the alarm
  */
 hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
-  const tTimerConfig timer = TimerConfig[timer_num];
+  const tTimerConfig timer = timer_config[timer_num];
   uint64_t counter_value;
   timer_get_counter_value(timer.group, timer.idx, &counter_value);
   return counter_value;
  * @param timer_num timer number to enable interrupts on
  */
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
-  //const tTimerConfig timer = TimerConfig[timer_num];
+  //const tTimerConfig timer = timer_config[timer_num];
   //timer_enable_intr(timer.group, timer.idx);
 }
 
  * @param timer_num timer number to disable interrupts on
  */
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
-  //const tTimerConfig timer = TimerConfig[timer_num];
+  //const tTimerConfig timer = timer_config[timer_num];
   //timer_disable_intr(timer.group, timer.idx);
 }
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
-  const tTimerConfig timer = TimerConfig[timer_num];
+  const tTimerConfig timer = timer_config[timer_num];
   return TG[timer.group]->int_ena.val | BIT(timer_num);
 }
 

Marlin/src/HAL/ESP32/timers.h

 typedef uint64_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFFFFFFFFFFFFFFULL
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
-#ifndef PWM_TIMER_NUM
-  #define PWM_TIMER_NUM         2  // index of timer to use for PWM outputs
+#ifndef MF_TIMER_PWM
+  #define MF_TIMER_PWM          2  // index of timer to use for PWM outputs
 #endif
-#ifndef TONE_TIMER_NUM
-  #define TONE_TIMER_NUM        3  // index of timer for beeper tones
+#ifndef MF_TIMER_TONE
+  #define MF_TIMER_TONE         3  // index of timer for beeper tones
 #endif
 
 #define HAL_TIMER_RATE APB_CLK_FREQ // frequency of timer peripherals
 #define PULSE_TIMER_PRESCALE     STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_TEMP_TIMER_ISR
   #define HAL_TEMP_TIMER_ISR() extern "C" void tempTC_Handler()
 // Public Variables
 // ------------------------
 
-extern const tTimerConfig TimerConfig[];
+extern const tTimerConfig timer_config[];
 
 // ------------------------
 // Public functions

Marlin/src/HAL/LINUX/timers.h

 
 #define HAL_TIMER_RATE         ((SystemCoreClock) / 4)  // frequency of timers peripherals
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
 
 #define TEMP_TIMER_RATE        1000000
 #define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_STEP_TIMER_ISR
   #define HAL_STEP_TIMER_ISR()  extern "C" void TIMER0_IRQHandler()
 #define HAL_PWM_TIMER_ISR()   extern "C" void TIMER3_IRQHandler()
 #define HAL_PWM_TIMER_IRQn
 
-
 void HAL_timer_init();
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
 

Marlin/src/HAL/LPC1768/timers.cpp

 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   switch (timer_num) {
-    case 0:
+    case MF_TIMER_STEP:
       LPC_TIM0->MCR = _BV(SBIT_MR0I) | _BV(SBIT_MR0R); // Match on MR0, reset on MR0, interrupts when NVIC enables them
       LPC_TIM0->MR0 = uint32_t(STEPPER_TIMER_RATE) / frequency; // Match value (period) to set frequency
       LPC_TIM0->TCR = _BV(SBIT_CNTEN); // Counter Enable
       NVIC_EnableIRQ(TIMER0_IRQn);
       break;
 
-    case 1:
+    case MF_TIMER_TEMP:
       LPC_TIM1->MCR = _BV(SBIT_MR0I) | _BV(SBIT_MR0R); // Match on MR0, reset on MR0, interrupts when NVIC enables them
       LPC_TIM1->MR0 = uint32_t(TEMP_TIMER_RATE) / frequency;
       LPC_TIM1->TCR = _BV(SBIT_CNTEN); // Counter Enable

Marlin/src/HAL/LPC1768/timers.h

 
 #define HAL_TIMER_RATE         ((F_CPU) / 4)  // frequency of timers peripherals
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
-#ifndef PWM_TIMER_NUM
-  #define PWM_TIMER_NUM         3  // Timer Index for PWM
+#ifndef MF_TIMER_PWM
+  #define MF_TIMER_PWM          3  // Timer Index for PWM
 #endif
 
 #define TEMP_TIMER_RATE        1000000
 #define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_STEP_TIMER_ISR
-  #define HAL_STEP_TIMER_ISR() _HAL_TIMER_ISR(STEP_TIMER_NUM)
+  #define HAL_STEP_TIMER_ISR() _HAL_TIMER_ISR(MF_TIMER_STEP)
 #endif
 #ifndef HAL_TEMP_TIMER_ISR
-  #define HAL_TEMP_TIMER_ISR() _HAL_TIMER_ISR(TEMP_TIMER_NUM)
+  #define HAL_TEMP_TIMER_ISR() _HAL_TIMER_ISR(MF_TIMER_TEMP)
 #endif
 
 // Timer references by index
-#define STEP_TIMER_PTR _HAL_TIMER(STEP_TIMER_NUM)
-#define TEMP_TIMER_PTR _HAL_TIMER(TEMP_TIMER_NUM)
+#define STEP_TIMER_PTR _HAL_TIMER(MF_TIMER_STEP)
+#define TEMP_TIMER_PTR _HAL_TIMER(MF_TIMER_TEMP)
 
 // ------------------------
 // Public functions
 
 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
   switch (timer_num) {
-    case 0: STEP_TIMER_PTR->MR0 = compare; break; // Stepper Timer Match Register 0
-    case 1: TEMP_TIMER_PTR->MR0 = compare; break; //    Temp Timer Match Register 0
+    case MF_TIMER_STEP: STEP_TIMER_PTR->MR0 = compare; break; // Stepper Timer Match Register 0
+    case MF_TIMER_TEMP: TEMP_TIMER_PTR->MR0 = compare; break; //    Temp Timer Match Register 0
   }
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return STEP_TIMER_PTR->MR0; // Stepper Timer Match Register 0
-    case 1: return TEMP_TIMER_PTR->MR0; //    Temp Timer Match Register 0
+    case MF_TIMER_STEP: return STEP_TIMER_PTR->MR0; // Stepper Timer Match Register 0
+    case MF_TIMER_TEMP: return TEMP_TIMER_PTR->MR0; //    Temp Timer Match Register 0
   }
   return 0;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return STEP_TIMER_PTR->TC; // Stepper Timer Count
-    case 1: return TEMP_TIMER_PTR->TC; //    Temp Timer Count
+    case MF_TIMER_STEP: return STEP_TIMER_PTR->TC; // Stepper Timer Count
+    case MF_TIMER_TEMP: return TEMP_TIMER_PTR->TC; //    Temp Timer Count
   }
   return 0;
 }
 
 FORCE_INLINE static void HAL_timer_enable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: NVIC_EnableIRQ(TIMER0_IRQn); break; // Enable interrupt handler
-    case 1: NVIC_EnableIRQ(TIMER1_IRQn); break; // Enable interrupt handler
+    case MF_TIMER_STEP: NVIC_EnableIRQ(TIMER0_IRQn); break; // Enable interrupt handler
+    case MF_TIMER_TEMP: NVIC_EnableIRQ(TIMER1_IRQn); break; // Enable interrupt handler
   }
 }
 
 FORCE_INLINE static void HAL_timer_disable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: NVIC_DisableIRQ(TIMER0_IRQn); break; // Disable interrupt handler
-    case 1: NVIC_DisableIRQ(TIMER1_IRQn); break; // Disable interrupt handler
+    case MF_TIMER_STEP: NVIC_DisableIRQ(TIMER0_IRQn); break; // Disable interrupt handler
+    case MF_TIMER_TEMP: NVIC_DisableIRQ(TIMER1_IRQn); break; // Disable interrupt handler
   }
 
   // We NEED memory barriers to ensure Interrupts are actually disabled!
 
 FORCE_INLINE static bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return NVIC_GetEnableIRQ(TIMER0_IRQn); // Check if interrupt is enabled or not
-    case 1: return NVIC_GetEnableIRQ(TIMER1_IRQn); // Check if interrupt is enabled or not
+    case MF_TIMER_STEP: return NVIC_GetEnableIRQ(TIMER0_IRQn); // Check if interrupt is enabled or not
+    case MF_TIMER_TEMP: return NVIC_GetEnableIRQ(TIMER1_IRQn); // Check if interrupt is enabled or not
   }
   return false;
 }
 
 FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: SBI(STEP_TIMER_PTR->IR, SBIT_CNTEN); break;
-    case 1: SBI(TEMP_TIMER_PTR->IR, SBIT_CNTEN); break;
+    case MF_TIMER_STEP: SBI(STEP_TIMER_PTR->IR, SBIT_CNTEN); break;
+    case MF_TIMER_TEMP: SBI(TEMP_TIMER_PTR->IR, SBIT_CNTEN); break;
   }
 }
 

Marlin/src/HAL/NATIVE_SIM/timers.h

 
 #define HAL_TIMER_RATE         ((SystemCoreClock) / 4)  // frequency of timers peripherals
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
-#ifndef SYSTICK_TIMER_NUM
-  #define SYSTICK_TIMER_NUM     2 // Timer Index for Systick
+#ifndef MF_TIMER_SYSTICK
+  #define MF_TIMER_SYSTICK      2  // Timer Index for Systick
 #endif
 #define SYSTICK_TIMER_FREQUENCY 1000
 
 #define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_STEP_TIMER_ISR
   #define HAL_STEP_TIMER_ISR()  extern "C" void TIMER0_IRQHandler()

Marlin/src/HAL/SAMD51/Servo.cpp

 static volatile int8_t currentServoIndex[_Nbr_16timers];    // index for the servo being pulsed for each timer (or -1 if refresh interval)
 
 FORCE_INLINE static uint16_t getTimerCount() {
-  Tc * const tc = TimerConfig[SERVO_TC].pTc;
+  Tc * const tc = timer_config[SERVO_TC].pTc;
 
   tc->COUNT16.CTRLBSET.reg = TC_CTRLBCLR_CMD_READSYNC;
   SYNC(tc->COUNT16.SYNCBUSY.bit.CTRLB || tc->COUNT16.SYNCBUSY.bit.COUNT);
 // Interrupt handler for the TC
 // ----------------------------
 HAL_SERVO_TIMER_ISR() {
-  Tc * const tc = TimerConfig[SERVO_TC].pTc;
+  Tc * const tc = timer_config[SERVO_TC].pTc;
   const timer16_Sequence_t timer =
     #ifndef _useTimer1
       _timer2
 }
 
 void initISR(timer16_Sequence_t timer) {
-  Tc * const tc = TimerConfig[SERVO_TC].pTc;
+  Tc * const tc = timer_config[SERVO_TC].pTc;
   const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
 
   static bool initialized = false;  // Servo TC has been initialized
 }
 
 void finISR(timer16_Sequence_t timer) {
-  Tc * const tc = TimerConfig[SERVO_TC].pTc;
+  Tc * const tc = timer_config[SERVO_TC].pTc;
   const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
 
   // Disable the match channel interrupt request

Marlin/src/HAL/SAMD51/inc/SanityCheck.h

   #error "OnBoard SPI BUS can't be shared with other devices."
 #endif
 
-#if SERVO_TC == RTC_TIMER_NUM
+#if SERVO_TC == MF_TIMER_RTC
   #error "Servos can't use RTC timer"
 #endif
 

Marlin/src/HAL/SAMD51/timers.cpp

 // Local defines
 // --------------------------------------------------------------------------
 
-#define NUM_HARDWARE_TIMERS 8
+#define NUM_HARDWARE_TIMERS 9
 
 // --------------------------------------------------------------------------
 // Private Variables
 // --------------------------------------------------------------------------
 
-const tTimerConfig TimerConfig[NUM_HARDWARE_TIMERS+1] = {
+const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
   { {.pTc=TC0},  TC0_IRQn, TC_PRIORITY(0) },  // 0 - stepper (assigned priority 2)
   { {.pTc=TC1},  TC1_IRQn, TC_PRIORITY(1) },  // 1 - stepper (needed by 32 bit timers)
   { {.pTc=TC2},  TC2_IRQn, 5              },  // 2 - tone (reserved by framework and fixed assigned priority 5)
 // --------------------------------------------------------------------------
 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
-  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
 
   // Disable interrupt, just in case it was already enabled
   Disable_Irq(irq);
 
-  if (timer_num == RTC_TIMER_NUM) {
-    Rtc * const rtc = TimerConfig[timer_num].pRtc;
+  if (timer_num == MF_TIMER_RTC) {
+    Rtc * const rtc = timer_config[timer_num].pRtc;
 
     // Disable timer interrupt
     rtc->MODE0.INTENCLR.reg = RTC_MODE0_INTENCLR_CMP0;
     SYNC(rtc->MODE0.SYNCBUSY.bit.ENABLE);
   }
   else {
-    Tc * const tc = TimerConfig[timer_num].pTc;
+    Tc * const tc = timer_config[timer_num].pTc;
 
     // Disable timer interrupt
     tc->COUNT32.INTENCLR.reg = TC_INTENCLR_OVF; // disable overflow interrupt
   }
 
   // Finally, enable IRQ
-  NVIC_SetPriority(irq, TimerConfig[timer_num].priority);
+  NVIC_SetPriority(irq, timer_config[timer_num].priority);
   NVIC_EnableIRQ(irq);
 }
 
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
-  const IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
   NVIC_EnableIRQ(irq);
 }
 
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
-  const IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
   Disable_Irq(irq);
 }
 
 }
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
-  const IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
   return NVIC_GetEnabledIRQ(irq);
 }
 

Marlin/src/HAL/SAMD51/timers.h

 // --------------------------------------------------------------------------
 // Defines
 // --------------------------------------------------------------------------
-#define RTC_TIMER_NUM       8   // This is not a TC but a RTC
 
 typedef uint32_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFFFFFF
 
 #define HAL_TIMER_RATE      F_CPU   // frequency of timers peripherals
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#define MF_TIMER_RTC            8   // This is not a TC but a RTC
+
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0   // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        RTC_TIMER_NUM // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         MF_TIMER_RTC // Timer Index for Temperature
 #endif
 
 #define TEMP_TIMER_FREQUENCY   1000 // temperature interrupt frequency
 #define PULSE_TIMER_PRESCALE      STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US  STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT()   HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED()               HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT()   HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED()               HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
-#define TC_PRIORITY(t)        t == SERVO_TC ? 1                                     \
-                               : (t == STEP_TIMER_NUM || t == PULSE_TIMER_NUM) ? 2  \
-                               : (t == TEMP_TIMER_NUM) ? 6                          \
-                               : 7
+#define TC_PRIORITY(t)     (  t == SERVO_TC ? 1                              \
+                           : (t == MF_TIMER_STEP || t == MF_TIMER_PULSE) ? 2 \
+                           : (t == MF_TIMER_TEMP) ? 6 : 7 )
 
 #define _TC_HANDLER(t)          void TC##t##_Handler()
 #define TC_HANDLER(t)           _TC_HANDLER(t)
 #ifndef HAL_STEP_TIMER_ISR
-  #define HAL_STEP_TIMER_ISR()  TC_HANDLER(STEP_TIMER_NUM)
+  #define HAL_STEP_TIMER_ISR()  TC_HANDLER(MF_TIMER_STEP)
 #endif
-#if STEP_TIMER_NUM != PULSE_TIMER_NUM
-  #define HAL_PULSE_TIMER_ISR() TC_HANDLER(PULSE_TIMER_NUM)
+#if MF_TIMER_STEP != MF_TIMER_PULSE
+  #define HAL_PULSE_TIMER_ISR() TC_HANDLER(MF_TIMER_PULSE)
 #endif
-#if TEMP_TIMER_NUM == RTC_TIMER_NUM
+#if MF_TIMER_TEMP == MF_TIMER_RTC
   #define HAL_TEMP_TIMER_ISR()  void RTC_Handler()
 #else
-  #define HAL_TEMP_TIMER_ISR()  TC_HANDLER(TEMP_TIMER_NUM)
+  #define HAL_TEMP_TIMER_ISR()  TC_HANDLER(MF_TIMER_TEMP)
 #endif
 
 // --------------------------------------------------------------------------
 // Public Variables
 // --------------------------------------------------------------------------
 
-extern const tTimerConfig TimerConfig[];
+extern const tTimerConfig timer_config[];
 
 // --------------------------------------------------------------------------
 // Public functions
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
 
 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
-  // Should never be called with timer RTC_TIMER_NUM
-  Tc * const tc = TimerConfig[timer_num].pTc;
+  // Should never be called with timer MF_TIMER_RTC
+  Tc * const tc = timer_config[timer_num].pTc;
   tc->COUNT32.CC[0].reg = compare;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
-  // Should never be called with timer RTC_TIMER_NUM
-  Tc * const tc = TimerConfig[timer_num].pTc;
+  // Should never be called with timer MF_TIMER_RTC
+  Tc * const tc = timer_config[timer_num].pTc;
   return (hal_timer_t)tc->COUNT32.CC[0].reg;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
-  // Should never be called with timer RTC_TIMER_NUM
-  Tc * const tc = TimerConfig[timer_num].pTc;
+  // Should never be called with timer MF_TIMER_RTC
+  Tc * const tc = timer_config[timer_num].pTc;
   tc->COUNT32.CTRLBSET.reg = TC_CTRLBCLR_CMD_READSYNC;
   SYNC(tc->COUNT32.SYNCBUSY.bit.CTRLB || tc->COUNT32.SYNCBUSY.bit.COUNT);
   return tc->COUNT32.COUNT.reg;
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num);
 
 FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
-  if (timer_num == RTC_TIMER_NUM) {
-    Rtc * const rtc = TimerConfig[timer_num].pRtc;
+  if (timer_num == MF_TIMER_RTC) {
+    Rtc * const rtc = timer_config[timer_num].pRtc;
     // Clear interrupt flag
     rtc->MODE0.INTFLAG.reg = RTC_MODE0_INTFLAG_CMP0;
   }
   else {
-    Tc * const tc = TimerConfig[timer_num].pTc;
+    Tc * const tc = timer_config[timer_num].pTc;
     // Clear interrupt flag
     tc->COUNT32.INTFLAG.reg = TC_INTFLAG_OVF;
   }

Marlin/src/HAL/STM32/fast_pwm.cpp

 
 void set_pwm_frequency(const pin_t pin, int f_desired) {
   if (!PWM_PIN(pin)) return; // Don't proceed if no hardware timer
-  HardwareTimer *HT;
-  PinName pin_name = digitalPinToPinName(pin);
-  TIM_TypeDef *Instance = (TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM); // Get HAL timer instance
 
   uint32_t index = get_timer_index(Instance);
 
     #endif
   ) return;
 
-  if (HardwareTimer_Handle[index] == nullptr) // If frequency is set before duty we need to create a handle here. 
+  const PinName pin_name = digitalPinToPinName(pin);
+  TIM_TypeDef * const Instance = (TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM); // Get HAL timer instance
+  if (HardwareTimer_Handle[index] == nullptr) // If frequency is set before duty we need to create a handle here.
     HardwareTimer_Handle[index]->__this = new HardwareTimer((TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM));
-  HT = (HardwareTimer *)(HardwareTimer_Handle[index]->__this);
+  HardwareTimer * const HT = (HardwareTimer *)(HardwareTimer_Handle[index]->__this);
   timer_freq[index] = f_desired; // Save the last frequency so duty will not set the default for this timer number.
-  HT->setOverflow(f_desired, HERTZ_FORMAT);   
+  HT->setOverflow(f_desired, HERTZ_FORMAT);
 }
 
 #endif // HAL_STM32

Marlin/src/HAL/STM32/timers.cpp

 uint32_t GetStepperTimerClkFreq() {
   // Timer input clocks vary between devices, and in some cases between timers on the same device.
   // Retrieve at runtime to ensure device compatibility. Cache result to avoid repeated overhead.
-  static uint32_t clkfreq = timer_instance[STEP_TIMER_NUM]->getTimerClkFreq();
+  static uint32_t clkfreq = timer_instance[MF_TIMER_STEP]->getTimerClkFreq();
   return clkfreq;
 }
 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   if (!HAL_timer_initialized(timer_num)) {
     switch (timer_num) {
-      case STEP_TIMER_NUM: // STEPPER TIMER - use a 32bit timer if possible
+      case MF_TIMER_STEP: // STEPPER TIMER - use a 32bit timer if possible
         timer_instance[timer_num] = new HardwareTimer(STEP_TIMER_DEV);
         /* Set the prescaler to the final desired value.
          * This will change the effective ISR callback frequency but when
         timer_instance[timer_num]->setPrescaleFactor(STEPPER_TIMER_PRESCALE); //the -1 is done internally
         timer_instance[timer_num]->setOverflow(_MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (HAL_TIMER_RATE) / (STEPPER_TIMER_PRESCALE) /* /frequency */), TICK_FORMAT);
         break;
-      case TEMP_TIMER_NUM: // TEMP TIMER - any available 16bit timer
+      case MF_TIMER_TEMP: // TEMP TIMER - any available 16bit timer
         timer_instance[timer_num] = new HardwareTimer(TEMP_TIMER_DEV);
         // The prescale factor is computed automatically for HERTZ_FORMAT
         timer_instance[timer_num]->setOverflow(frequency, HERTZ_FORMAT);
     // These calls can be removed and replaced with
     // timer_instance[timer_num]->setInterruptPriority
     switch (timer_num) {
-      case STEP_TIMER_NUM:
+      case MF_TIMER_STEP:
         timer_instance[timer_num]->setInterruptPriority(STEP_TIMER_IRQ_PRIO, 0);
         break;
-      case TEMP_TIMER_NUM:
+      case MF_TIMER_TEMP:
         timer_instance[timer_num]->setInterruptPriority(TEMP_TIMER_IRQ_PRIO, 0);
         break;
     }
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
   if (HAL_timer_initialized(timer_num) && !timer_instance[timer_num]->hasInterrupt()) {
     switch (timer_num) {
-      case STEP_TIMER_NUM:
+      case MF_TIMER_STEP:
         timer_instance[timer_num]->attachInterrupt(Step_Handler);
         break;
-      case TEMP_TIMER_NUM:
+      case MF_TIMER_TEMP:
         timer_instance[timer_num]->attachInterrupt(Temp_Handler);
         break;
     }

Marlin/src/HAL/STM32/timers.h

 
 #define NUM_HARDWARE_TIMERS 2
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
 
 #define TEMP_TIMER_FREQUENCY 1000   // Temperature::isr() is expected to be called at around 1kHz
 #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 extern void Step_Handler();
 extern void Temp_Handler();

Marlin/src/HAL/STM32F1/HAL.h

 
 #ifndef PWM_FREQUENCY
   #define PWM_FREQUENCY      1000 // Default PWM Frequency
-#endif  
+#endif
 #define HAL_CAN_SET_PWM_FREQ      // This HAL supports PWM Frequency adjustment
 
 /**
  *  Set the PWM duty cycle of the provided pin to the provided value
  *  Optionally allows inverting the duty cycle [default = false]
  *  Optionally allows changing the maximum size of the provided value to enable finer PWM duty control [default = 255]
- *  The timer must be pre-configured with set_pwm_frequency() if the default frequency is not desired.   
+ *  The timer must be pre-configured with set_pwm_frequency() if the default frequency is not desired.
  */
 void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);

Marlin/src/HAL/STM32F1/Servo.cpp

 #define US_TO_ANGLE(us)    int16_t(map((us), SERVO_DEFAULT_MIN_PW, SERVO_DEFAULT_MAX_PW, minAngle, maxAngle))
 
 void libServo::servoWrite(uint8_t inPin, uint16_t duty_cycle) {
-  #ifdef SERVO0_TIMER_NUM
+  #ifdef MF_TIMER_SERVO0
     if (servoIndex == 0) {
       pwmSetDuty(duty_cycle);
       return;
 
 libServo::libServo() {
   servoIndex = ServoCount < MAX_SERVOS ? ServoCount++ : INVALID_SERVO;
-  timer_set_interrupt_priority(SERVO0_TIMER_NUM, SERVO0_TIMER_IRQ_PRIO);
+  HAL_timer_set_interrupt_priority(MF_TIMER_SERVO0, SERVO0_TIMER_IRQ_PRIO);
 }
 
 bool libServo::attach(const int32_t inPin, const int32_t inMinAngle, const int32_t inMaxAngle) {
   maxAngle = inMaxAngle;
   angle = -1;
 
-  #ifdef SERVO0_TIMER_NUM
+  #ifdef MF_TIMER_SERVO0
     if (servoIndex == 0 && setupSoftPWM(inPin)) {
       pin = inPin; // set attached()
       return true;
 
 int32_t libServo::read() const {
   if (attached()) {
-    #ifdef SERVO0_TIMER_NUM
+    #ifdef MF_TIMER_SERVO0
       if (servoIndex == 0) return angle;
     #endif
     timer_dev *tdev = PIN_MAP[pin].timer_device;
   }
 }
 
-#ifdef SERVO0_TIMER_NUM
+#ifdef MF_TIMER_SERVO0
   extern "C" void Servo_IRQHandler() {
-    static timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM);
+    static timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
     uint16_t SR = timer_get_status(tdev);
     if (SR & TIMER_SR_CC1IF) { // channel 1 off
       #ifdef SERVO0_PWM_OD
   }
 
   bool libServo::setupSoftPWM(const int32_t inPin) {
-    timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM);
+    timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
     if (!tdev) return false;
     #ifdef SERVO0_PWM_OD
       OUT_WRITE_OD(inPin, 1);
   }
 
   void libServo::pwmSetDuty(const uint16_t duty_cycle) {
-    timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM);
+    timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
     timer_set_compare(tdev, 1, duty_cycle);
     timer_generate_update(tdev);
     if (duty_cycle) {
   }
 
   void libServo::pauseSoftPWM() { // detach
-    timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM);
+    timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
     timer_pause(tdev);
     pwmSetDuty(0);
   }

Marlin/src/HAL/STM32F1/fast_pwm.cpp

   uint16_t max_val = timer->regs.bas->ARR * v / v_size;
   if (invert) max_val = v_size - max_val;
   pwmWrite(pin, max_val);
-
 }
 
 void set_pwm_frequency(const pin_t pin, int f_desired) {
   uint8_t channel = PIN_MAP[pin].timer_channel;
 
   // Protect used timers
-  if (timer == get_timer_dev(TEMP_TIMER_NUM)) return;
-  if (timer == get_timer_dev(STEP_TIMER_NUM)) return;
-  #if PULSE_TIMER_NUM != STEP_TIMER_NUM
-    if (timer == get_timer_dev(PULSE_TIMER_NUM)) return;
+  if (timer == HAL_get_timer_dev(MF_TIMER_TEMP)) return;
+  if (timer == HAL_get_timer_dev(MF_TIMER_STEP)) return;
+  #if MF_TIMER_PULSE != MF_TIMER_STEP
+    if (timer == HAL_get_timer_dev(MF_TIMER_PULSE)) return;
   #endif
 
   if (!(timer->regs.bas->SR & TIMER_CR1_CEN))   // Ensure the timer is enabled

Marlin/src/HAL/STM32F1/timers.cpp

  * TODO: Calculate Timer prescale value, so we get the 32bit to adjust
  */
 
-
-
-
-void timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority) {
+void HAL_timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority) {
   nvic_irq_num irq_num;
   switch (timer_num) {
     case 1: irq_num = NVIC_TIMER1_CC; break;
   nvic_irq_set_priority(irq_num, priority);
 }
 
-
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   /**
    * Give the Stepper ISR a higher priority (lower number)
    */
 
   switch (timer_num) {
-    case STEP_TIMER_NUM:
+    case MF_TIMER_STEP:
       timer_pause(STEP_TIMER_DEV);
       timer_set_mode(STEP_TIMER_DEV, STEP_TIMER_CHAN, TIMER_OUTPUT_COMPARE); // counter
       timer_set_count(STEP_TIMER_DEV, 0);
       timer_set_compare(STEP_TIMER_DEV, STEP_TIMER_CHAN, _MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (STEPPER_TIMER_RATE) / frequency));
       timer_no_ARR_preload_ARPE(STEP_TIMER_DEV); // Need to be sure no preload on ARR register
       timer_attach_interrupt(STEP_TIMER_DEV, STEP_TIMER_CHAN, stepTC_Handler);
-      timer_set_interrupt_priority(STEP_TIMER_NUM, STEP_TIMER_IRQ_PRIO);
+      HAL_timer_set_interrupt_priority(MF_TIMER_STEP, STEP_TIMER_IRQ_PRIO);
       timer_generate_update(STEP_TIMER_DEV);
       timer_resume(STEP_TIMER_DEV);
       break;
-    case TEMP_TIMER_NUM:
+    case MF_TIMER_TEMP:
       timer_pause(TEMP_TIMER_DEV);
       timer_set_mode(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, TIMER_OUTPUT_COMPARE);
       timer_set_count(TEMP_TIMER_DEV, 0);
       timer_set_reload(TEMP_TIMER_DEV, 0xFFFF);
       timer_set_compare(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, _MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (F_CPU) / (TEMP_TIMER_PRESCALE) / frequency));
       timer_attach_interrupt(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, tempTC_Handler);
-      timer_set_interrupt_priority(TEMP_TIMER_NUM, TEMP_TIMER_IRQ_PRIO);
+      HAL_timer_set_interrupt_priority(MF_TIMER_TEMP, TEMP_TIMER_IRQ_PRIO);
       timer_generate_update(TEMP_TIMER_DEV);
       timer_resume(TEMP_TIMER_DEV);
       break;
 
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case STEP_TIMER_NUM: ENABLE_STEPPER_DRIVER_INTERRUPT(); break;
-    case TEMP_TIMER_NUM: ENABLE_TEMPERATURE_INTERRUPT(); break;
+    case MF_TIMER_STEP: ENABLE_STEPPER_DRIVER_INTERRUPT(); break;
+    case MF_TIMER_TEMP: ENABLE_TEMPERATURE_INTERRUPT(); break;
   }
 }
 
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case STEP_TIMER_NUM: DISABLE_STEPPER_DRIVER_INTERRUPT(); break;
-    case TEMP_TIMER_NUM: DISABLE_TEMPERATURE_INTERRUPT(); break;
+    case MF_TIMER_STEP: DISABLE_STEPPER_DRIVER_INTERRUPT(); break;
+    case MF_TIMER_TEMP: DISABLE_TEMPERATURE_INTERRUPT(); break;
   }
 }
 
-static inline bool timer_irq_enabled(const timer_dev * const dev, const uint8_t interrupt) {
+static inline bool HAL_timer_irq_enabled(const timer_dev * const dev, const uint8_t interrupt) {
   return bool(*bb_perip(&(dev->regs).gen->DIER, interrupt));
 }
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
   switch (timer_num) {
-    case STEP_TIMER_NUM: return timer_irq_enabled(STEP_TIMER_DEV, STEP_TIMER_CHAN);
-    case TEMP_TIMER_NUM: return timer_irq_enabled(TEMP_TIMER_DEV, TEMP_TIMER_CHAN);
+    case MF_TIMER_STEP: return HAL_timer_irq_enabled(STEP_TIMER_DEV, STEP_TIMER_CHAN);
+    case MF_TIMER_TEMP: return HAL_timer_irq_enabled(TEMP_TIMER_DEV, TEMP_TIMER_CHAN);
   }
   return false;
 }
 
-timer_dev* get_timer_dev(int number) {
+timer_dev* HAL_get_timer_dev(int number) {
   switch (number) {
     #if STM32_HAVE_TIMER(1)
       case 1: return &timer1;

Marlin/src/HAL/STM32F1/timers.h

  *   - Otherwise it uses Timer 8 on boards with STM32_HIGH_DENSITY
  *     or Timer 4 on other boards.
  */
-#ifndef STEP_TIMER_NUM
+#ifndef MF_TIMER_STEP
   #if defined(MCU_STM32F103CB) || defined(MCU_STM32F103C8)
-    #define STEP_TIMER_NUM      4  // For C8/CB boards, use timer 4
+    #define MF_TIMER_STEP       4  // For C8/CB boards, use timer 4
   #else
-    #define STEP_TIMER_NUM      5  // for other boards, five is fine.
+    #define MF_TIMER_STEP       5  // for other boards, five is fine.
   #endif
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        2  // Timer Index for Temperature
-  //#define TEMP_TIMER_NUM      4  // 2->4, Timer 2 for Stepper Current PWM
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         2  // Timer Index for Temperature
+  //#define MF_TIMER_TEMP       4  // 2->4, Timer 2 for Stepper Current PWM
 #endif
 
 #if MB(BTT_SKR_MINI_E3_V1_0, BTT_SKR_E3_DIP, BTT_SKR_MINI_E3_V1_2, MKS_ROBIN_LITE, MKS_ROBIN_E3D, MKS_ROBIN_E3)
   // SKR Mini E3 boards use PA8 as FAN_PIN, so TIMER 1 is used for Fan PWM.
   #ifdef STM32_HIGH_DENSITY
-    #define SERVO0_TIMER_NUM 8  // tone.cpp uses Timer 4
+    #define MF_TIMER_SERVO0  8  // tone.cpp uses Timer 4
   #else
-    #define SERVO0_TIMER_NUM 3  // tone.cpp uses Timer 8
+    #define MF_TIMER_SERVO0  3  // tone.cpp uses Timer 8
   #endif
 #else
-  #define SERVO0_TIMER_NUM 1  // SERVO0 or BLTOUCH
+  #define MF_TIMER_SERVO0  1  // SERVO0 or BLTOUCH
 #endif
 
 #define STEP_TIMER_IRQ_PRIO 2
 #define TEMP_TIMER_PRESCALE     1000 // prescaler for setting Temp timer, 72Khz
 #define TEMP_TIMER_FREQUENCY    1000 // temperature interrupt frequency
 
-#define STEPPER_TIMER_PRESCALE 18             // prescaler for setting stepper timer, 4Mhz
-#define STEPPER_TIMER_RATE     (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)   // frequency of stepper timer
-#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
+#define STEPPER_TIMER_PRESCALE      18                                          // prescaler for setting stepper timer, 4Mhz
+#define STEPPER_TIMER_RATE          (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)   // frequency of stepper timer
+#define STEPPER_TIMER_TICKS_PER_US  ((STEPPER_TIMER_RATE) / 1000000)            // stepper timer ticks per µs
 
-#define PULSE_TIMER_RATE       STEPPER_TIMER_RATE   // frequency of pulse timer
-#define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
-#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
+#define PULSE_TIMER_RATE            STEPPER_TIMER_RATE   // frequency of pulse timer
+#define PULSE_TIMER_PRESCALE        STEPPER_TIMER_PRESCALE
+#define PULSE_TIMER_TICKS_PER_US    STEPPER_TIMER_TICKS_PER_US
 
-timer_dev* get_timer_dev(int number);
-#define TIMER_DEV(num) get_timer_dev(num)
-#define STEP_TIMER_DEV TIMER_DEV(STEP_TIMER_NUM)
-#define TEMP_TIMER_DEV TIMER_DEV(TEMP_TIMER_NUM)
+timer_dev* HAL_get_timer_dev(int number);
+#define TIMER_DEV(num) HAL_get_timer_dev(num)
+#define STEP_TIMER_DEV TIMER_DEV(MF_TIMER_STEP)
+#define TEMP_TIMER_DEV TIMER_DEV(MF_TIMER_TEMP)
 
 #define ENABLE_STEPPER_DRIVER_INTERRUPT() timer_enable_irq(STEP_TIMER_DEV, STEP_TIMER_CHAN)
 #define DISABLE_STEPPER_DRIVER_INTERRUPT() timer_disable_irq(STEP_TIMER_DEV, STEP_TIMER_CHAN)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
 #define ENABLE_TEMPERATURE_INTERRUPT() timer_enable_irq(TEMP_TIMER_DEV, TEMP_TIMER_CHAN)
 #define DISABLE_TEMPERATURE_INTERRUPT() timer_disable_irq(TEMP_TIMER_DEV, TEMP_TIMER_CHAN)
 // Public Variables
 // ------------------------
 
-//static HardwareTimer StepperTimer(STEP_TIMER_NUM);
-//static HardwareTimer TempTimer(TEMP_TIMER_NUM);
+//static HardwareTimer StepperTimer(MF_TIMER_STEP);
+//static HardwareTimer TempTimer(MF_TIMER_TEMP);
 
 // ------------------------
 // Public functions
 
 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
   switch (timer_num) {
-  case STEP_TIMER_NUM:
+  case MF_TIMER_STEP:
     // NOTE: WE have set ARPE = 0, which means the Auto reload register is not preloaded
     // and there is no need to use any compare, as in the timer mode used, setting ARR to the compare value
     // will result in exactly the same effect, ie triggering an interrupt, and on top, set counter to 0
     timer_set_reload(STEP_TIMER_DEV, compare); // We reload direct ARR as needed during counting up
     break;
-  case TEMP_TIMER_NUM:
+  case MF_TIMER_TEMP:
     timer_set_compare(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, compare);
     break;
   }
 
 FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
   switch (timer_num) {
-  case STEP_TIMER_NUM:
-    // No counter to clear
-    timer_generate_update(STEP_TIMER_DEV);
-    return;
-  case TEMP_TIMER_NUM:
-    timer_set_count(TEMP_TIMER_DEV, 0);
-    timer_generate_update(TEMP_TIMER_DEV);
-    return;
+    case MF_TIMER_STEP:
+      // No counter to clear
+      timer_generate_update(STEP_TIMER_DEV);
+      return;
+    case MF_TIMER_TEMP:
+      timer_set_count(TEMP_TIMER_DEV, 0);
+      timer_generate_update(TEMP_TIMER_DEV);
+      return;
   }
 }
 
   bb_peri_set_bit(&(dev->regs).gen->CR1, TIMER_CR1_ARPE_BIT, 0);
 }
 
-void timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority);
+void HAL_timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority);
 
 #define TIMER_OC_NO_PRELOAD 0 // Need to disable preload also on compare registers.

Marlin/src/HAL/TEENSY31_32/timers.cpp

 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   switch (timer_num) {
-    case 0:
+    case MF_TIMER_STEP:
       FTM0_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN;
       FTM0_SC = 0x00; // Set this to zero before changing the modulus
       FTM0_CNT = 0x0000; // Reset the count to zero
       FTM0_SC = (FTM_SC_CLKS(0b1) & FTM_SC_CLKS_MASK) | (FTM_SC_PS(FTM0_TIMER_PRESCALE_BITS) & FTM_SC_PS_MASK); // Bus clock 60MHz divided by prescaler 8
       FTM0_C0SC = FTM_CSC_CHIE | FTM_CSC_MSA | FTM_CSC_ELSA;
       break;
-    case 1:
+    case MF_TIMER_TEMP:
       FTM1_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; // Disable write protection, Enable FTM1
       FTM1_SC = 0x00; // Set this to zero before changing the modulus
       FTM1_CNT = 0x0000; // Reset the count to zero
 
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: NVIC_ENABLE_IRQ(IRQ_FTM0); break;
-    case 1: NVIC_ENABLE_IRQ(IRQ_FTM1); break;
+    case MF_TIMER_STEP: NVIC_ENABLE_IRQ(IRQ_FTM0); break;
+    case MF_TIMER_TEMP: NVIC_ENABLE_IRQ(IRQ_FTM1); break;
   }
 }
 
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: NVIC_DISABLE_IRQ(IRQ_FTM0); break;
-    case 1: NVIC_DISABLE_IRQ(IRQ_FTM1); break;
+    case MF_TIMER_STEP: NVIC_DISABLE_IRQ(IRQ_FTM0); break;
+    case MF_TIMER_TEMP: NVIC_DISABLE_IRQ(IRQ_FTM1); break;
   }
 
   // We NEED memory barriers to ensure Interrupts are actually disabled!
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return NVIC_IS_ENABLED(IRQ_FTM0);
-    case 1: return NVIC_IS_ENABLED(IRQ_FTM1);
+    case MF_TIMER_STEP: return NVIC_IS_ENABLED(IRQ_FTM0);
+    case MF_TIMER_TEMP: return NVIC_IS_ENABLED(IRQ_FTM1);
   }
   return false;
 }
 
 void HAL_timer_isr_prologue(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0:
+    case MF_TIMER_STEP:
       FTM0_CNT = 0x0000;
       FTM0_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
       FTM0_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag
       break;
-    case 1:
+    case MF_TIMER_TEMP:
       FTM1_CNT = 0x0000;
       FTM1_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
       FTM1_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag

Marlin/src/HAL/TEENSY31_32/timers.h

 
 #define HAL_TIMER_RATE         (FTM0_TIMER_RATE)
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
 
 #define TEMP_TIMER_FREQUENCY    1000
 #define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_STEP_TIMER_ISR
   #define HAL_STEP_TIMER_ISR() extern "C" void ftm0_isr() //void TC3_Handler()
 
 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
   switch (timer_num) {
-    case 0: FTM0_C0V = compare; break;
-    case 1: FTM1_C0V = compare; break;
+    case MF_TIMER_STEP: FTM0_C0V = compare; break;
+    case MF_TIMER_TEMP: FTM1_C0V = compare; break;
   }
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return FTM0_C0V;
-    case 1: return FTM1_C0V;
+    case MF_TIMER_STEP: return FTM0_C0V;
+    case MF_TIMER_TEMP: return FTM1_C0V;
   }
   return 0;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return FTM0_CNT;
-    case 1: return FTM1_CNT;
+    case MF_TIMER_STEP: return FTM0_CNT;
+    case MF_TIMER_TEMP: return FTM1_CNT;
   }
   return 0;
 }

Marlin/src/HAL/TEENSY35_36/timers.cpp

 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   switch (timer_num) {
-    case 0:
+    case MF_TIMER_STEP:
       FTM0_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN;
       FTM0_SC = 0x00; // Set this to zero before changing the modulus
       FTM0_CNT = 0x0000; // Reset the count to zero
       FTM0_SC = (FTM_SC_CLKS(0b1) & FTM_SC_CLKS_MASK) | (FTM_SC_PS(FTM0_TIMER_PRESCALE_BITS) & FTM_SC_PS_MASK); // Bus clock 60MHz divided by prescaler 8
       FTM0_C0SC = FTM_CSC_CHIE | FTM_CSC_MSA | FTM_CSC_ELSA;
       break;
-    case 1:
+    case MF_TIMER_TEMP:
       FTM1_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; // Disable write protection, Enable FTM1
       FTM1_SC = 0x00; // Set this to zero before changing the modulus
       FTM1_CNT = 0x0000; // Reset the count to zero
 
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: NVIC_ENABLE_IRQ(IRQ_FTM0); break;
-    case 1: NVIC_ENABLE_IRQ(IRQ_FTM1); break;
+    case MF_TIMER_STEP: NVIC_ENABLE_IRQ(IRQ_FTM0); break;
+    case MF_TIMER_TEMP: NVIC_ENABLE_IRQ(IRQ_FTM1); break;
   }
 }
 
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: NVIC_DISABLE_IRQ(IRQ_FTM0); break;
-    case 1: NVIC_DISABLE_IRQ(IRQ_FTM1); break;
+    case MF_TIMER_STEP: NVIC_DISABLE_IRQ(IRQ_FTM0); break;
+    case MF_TIMER_TEMP: NVIC_DISABLE_IRQ(IRQ_FTM1); break;
   }
 
   // We NEED memory barriers to ensure Interrupts are actually disabled!
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return NVIC_IS_ENABLED(IRQ_FTM0);
-    case 1: return NVIC_IS_ENABLED(IRQ_FTM1);
+    case MF_TIMER_STEP: return NVIC_IS_ENABLED(IRQ_FTM0);
+    case MF_TIMER_TEMP: return NVIC_IS_ENABLED(IRQ_FTM1);
   }
   return false;
 }
 
 void HAL_timer_isr_prologue(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0:
+    case MF_TIMER_STEP:
       FTM0_CNT = 0x0000;
       FTM0_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
       FTM0_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag
       break;
-    case 1:
+    case MF_TIMER_TEMP:
       FTM1_CNT = 0x0000;
       FTM1_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
       FTM1_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag

Marlin/src/HAL/TEENSY35_36/timers.h

 
 #define HAL_TIMER_RATE         (FTM0_TIMER_RATE)
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
 
 #define TEMP_TIMER_FREQUENCY    1000
 #define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_STEP_TIMER_ISR
   #define HAL_STEP_TIMER_ISR() extern "C" void ftm0_isr() //void TC3_Handler()
 
 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
   switch (timer_num) {
-    case 0: FTM0_C0V = compare; break;
-    case 1: FTM1_C0V = compare; break;
+    case MF_TIMER_STEP: FTM0_C0V = compare; break;
+    case MF_TIMER_TEMP: FTM1_C0V = compare; break;
   }
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return FTM0_C0V;
-    case 1: return FTM1_C0V;
+    case MF_TIMER_STEP: return FTM0_C0V;
+    case MF_TIMER_TEMP: return FTM1_C0V;
   }
   return 0;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return FTM0_CNT;
-    case 1: return FTM1_CNT;
+    case MF_TIMER_STEP: return FTM0_CNT;
+    case MF_TIMER_TEMP: return FTM1_CNT;
   }
   return 0;
 }

Marlin/src/HAL/TEENSY40_41/timers.cpp

 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   switch (timer_num) {
-    case 0:
+    case MF_TIMER_STEP:
       CCM_CSCMR1 &= ~CCM_CSCMR1_PERCLK_CLK_SEL; // turn off 24mhz mode
       CCM_CCGR1 |= CCM_CCGR1_GPT1_BUS(CCM_CCGR_ON);
 
       attachInterruptVector(IRQ_GPT1, &stepTC_Handler);
       NVIC_SET_PRIORITY(IRQ_GPT1, 16);
       break;
-    case 1:
+    case MF_TIMER_TEMP:
       CCM_CSCMR1 &= ~CCM_CSCMR1_PERCLK_CLK_SEL; // turn off 24mhz mode
       CCM_CCGR0 |= CCM_CCGR0_GPT2_BUS(CCM_CCGR_ON);
 
 
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0:
-      NVIC_ENABLE_IRQ(IRQ_GPT1);
-      break;
-    case 1:
-      NVIC_ENABLE_IRQ(IRQ_GPT2);
-      break;
+    case MF_TIMER_STEP: NVIC_ENABLE_IRQ(IRQ_GPT1); break;
+    case MF_TIMER_TEMP: NVIC_ENABLE_IRQ(IRQ_GPT2); break;
   }
 }
 
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: NVIC_DISABLE_IRQ(IRQ_GPT1); break;
-    case 1: NVIC_DISABLE_IRQ(IRQ_GPT2); break;
+    case MF_TIMER_STEP: NVIC_DISABLE_IRQ(IRQ_GPT1); break;
+    case MF_TIMER_TEMP: NVIC_DISABLE_IRQ(IRQ_GPT2); break;
   }
 
   // We NEED memory barriers to ensure Interrupts are actually disabled!
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return (NVIC_IS_ENABLED(IRQ_GPT1));
-    case 1: return (NVIC_IS_ENABLED(IRQ_GPT2));
+    case MF_TIMER_STEP: return (NVIC_IS_ENABLED(IRQ_GPT1));
+    case MF_TIMER_TEMP: return (NVIC_IS_ENABLED(IRQ_GPT2));
   }
   return false;
 }
 
 void HAL_timer_isr_prologue(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0:
-      GPT1_SR = GPT_IR_OF1IE;  // clear OF3 bit
-      break;
-    case 1:
-      GPT2_SR = GPT_IR_OF1IE;  // clear OF3 bit
-      break;
+    case MF_TIMER_STEP: GPT1_SR = GPT_IR_OF1IE; break; // clear OF3 bit
+    case MF_TIMER_TEMP: GPT2_SR = GPT_IR_OF1IE; break; // clear OF3 bit
   }
   asm volatile("dsb");
 }

Marlin/src/HAL/TEENSY40_41/timers.h

 #define GPT1_TIMER_RATE (GPT_TIMER_RATE / GPT1_TIMER_PRESCALE) // 75MHz
 #define GPT2_TIMER_RATE (GPT_TIMER_RATE / GPT2_TIMER_PRESCALE) // 15MHz
 
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
+#ifndef MF_TIMER_STEP
+  #define MF_TIMER_STEP         0  // Timer Index for Stepper
 #endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
+#ifndef MF_TIMER_PULSE
+  #define MF_TIMER_PULSE        MF_TIMER_STEP
 #endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
+#ifndef MF_TIMER_TEMP
+  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
 #endif
 
 #define TEMP_TIMER_RATE        1000000
 #define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
 #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
 
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
+#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
+#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
 
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
+#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
 
 #ifndef HAL_STEP_TIMER_ISR
   #define HAL_STEP_TIMER_ISR() extern "C" void stepTC_Handler() // GPT1_Handler()
 
 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
   switch (timer_num) {
-    case 0:
-      GPT1_OCR1 = compare - 1;
-      break;
-    case 1:
-      GPT2_OCR1 = compare - 1;
-      break;
+    case MF_TIMER_STEP: GPT1_OCR1 = compare - 1; break;
+    case MF_TIMER_TEMP: GPT2_OCR1 = compare - 1; break;
   }
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return GPT1_OCR1;
-    case 1: return GPT2_OCR1;
+    case MF_TIMER_STEP: return GPT1_OCR1;
+    case MF_TIMER_TEMP: return GPT2_OCR1;
   }
   return 0;
 }
 
 FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
   switch (timer_num) {
-    case 0: return GPT1_CNT;
-    case 1: return GPT2_CNT;
+    case MF_TIMER_STEP: return GPT1_CNT;
+    case MF_TIMER_TEMP: return GPT2_CNT;
   }
   return 0;
 }

Marlin/src/feature/easythreed_ui.cpp

 
 //
 // Filament Load/Unload Button
-// Load/Unload buttons are a 3 position switch with a common center ground. 
+// Load/Unload buttons are a 3 position switch with a common center ground.
 //
 void EasythreedUI::loadButton() {
   if (printingIsActive()) return;
             print_key_flag = PF_RESUME;                             // The "Print" button now resumes the print
             break;
             }
-          case PF_RESUME: {                                         // Resume printing 
+          case PF_RESUME: {                                         // Resume printing
             if (printingIsActive()) break;
             blink_interval_ms = LED_BLINK_2;                        // Blink the indicator LED at 1 second intervals
             queue.inject(F("M24"));                                 // Queue resume

Marlin/src/module/planner.h

           || TERN0(EXTERNAL_CLOSED_LOOP_CONTROLLER, CLOSED_LOOP_WAITING())
       );
     }
-    
+
     // Block until all buffered steps are executed / cleaned
     static void synchronize();
 

Marlin/src/module/stepper.cpp

 #define PULSE_LOW_TICK_COUNT hal_timer_t(NS_TO_PULSE_TIMER_TICKS(_MIN_PULSE_LOW_NS - _MIN(_MIN_PULSE_LOW_NS, TIMER_SETUP_NS)))
 
 #define USING_TIMED_PULSE() hal_timer_t start_pulse_count = 0
-#define START_TIMED_PULSE(DIR) (start_pulse_count = HAL_timer_get_count(PULSE_TIMER_NUM))
-#define AWAIT_TIMED_PULSE(DIR) while (PULSE_##DIR##_TICK_COUNT > HAL_timer_get_count(PULSE_TIMER_NUM) - start_pulse_count) { }
+#define START_TIMED_PULSE(DIR) (start_pulse_count = HAL_timer_get_count(MF_TIMER_PULSE))
+#define AWAIT_TIMED_PULSE(DIR) while (PULSE_##DIR##_TICK_COUNT > HAL_timer_get_count(MF_TIMER_PULSE) - start_pulse_count) { }
 #define START_HIGH_PULSE()  START_TIMED_PULSE(HIGH)
 #define AWAIT_HIGH_PULSE()  AWAIT_TIMED_PULSE(HIGH)
 #define START_LOW_PULSE()   START_TIMED_PULSE(LOW)
  */
 
 HAL_STEP_TIMER_ISR() {
-  HAL_timer_isr_prologue(STEP_TIMER_NUM);
+  HAL_timer_isr_prologue(MF_TIMER_STEP);
 
   Stepper::isr();
 
-  HAL_timer_isr_epilogue(STEP_TIMER_NUM);
+  HAL_timer_isr_epilogue(MF_TIMER_STEP);
 }
 
 #ifdef CPU_32_BIT
   // Program timer compare for the maximum period, so it does NOT
   // flag an interrupt while this ISR is running - So changes from small
   // periods to big periods are respected and the timer does not reset to 0
-  HAL_timer_set_compare(STEP_TIMER_NUM, hal_timer_t(HAL_TIMER_TYPE_MAX));
+  HAL_timer_set_compare(MF_TIMER_STEP, hal_timer_t(HAL_TIMER_TYPE_MAX));
 
   // Count of ticks for the next ISR
   hal_timer_t next_isr_ticks = 0;
      * On AVR the ISR epilogue+prologue is estimated at 100 instructions - Give 8µs as margin
      * On ARM the ISR epilogue+prologue is estimated at 20 instructions - Give 1µs as margin
      */
-    min_ticks = HAL_timer_get_count(STEP_TIMER_NUM) + hal_timer_t(
+    min_ticks = HAL_timer_get_count(MF_TIMER_STEP) + hal_timer_t(
       #ifdef __AVR__
         8
       #else
   // sure that the time has not arrived yet - Warrantied by the scheduler
 
   // Set the next ISR to fire at the proper time
-  HAL_timer_set_compare(STEP_TIMER_NUM, hal_timer_t(next_isr_ticks));
+  HAL_timer_set_compare(MF_TIMER_STEP, hal_timer_t(next_isr_ticks));
 
   // Don't forget to finally reenable interrupts
   ENABLE_ISRS();
   #endif
 
   #if DISABLED(I2S_STEPPER_STREAM)
-    HAL_timer_start(STEP_TIMER_NUM, 122); // Init Stepper ISR to 122 Hz for quick starting
+    HAL_timer_start(MF_TIMER_STEP, 122); // Init Stepper ISR to 122 Hz for quick starting
     wake_up();
     sei();
   #endif
   #define EXTRA_CYCLES_BABYSTEP (STEP_PULSE_CYCLES - (CYCLES_EATEN_BABYSTEP))
 
   #if EXTRA_CYCLES_BABYSTEP > 20
-    #define _SAVE_START() const hal_timer_t pulse_start = HAL_timer_get_count(PULSE_TIMER_NUM)
-    #define _PULSE_WAIT() while (EXTRA_CYCLES_BABYSTEP > (uint32_t)(HAL_timer_get_count(PULSE_TIMER_NUM) - pulse_start) * (PULSE_TIMER_PRESCALE)) { /* nada */ }
+    #define _SAVE_START() const hal_timer_t pulse_start = HAL_timer_get_count(MF_TIMER_PULSE)
+    #define _PULSE_WAIT() while (EXTRA_CYCLES_BABYSTEP > (uint32_t)(HAL_timer_get_count(MF_TIMER_PULSE) - pulse_start) * (PULSE_TIMER_PRESCALE)) { /* nada */ }
   #else
     #define _SAVE_START() NOOP
     #if EXTRA_CYCLES_BABYSTEP > 0

Marlin/src/module/temperature.cpp

     HAL_ANALOG_SELECT(POWER_MONITOR_VOLTAGE_PIN);
   #endif
 
-  HAL_timer_start(TEMP_TIMER_NUM, TEMP_TIMER_FREQUENCY);
+  HAL_timer_start(MF_TIMER_TEMP, TEMP_TIMER_FREQUENCY);
   ENABLE_TEMPERATURE_INTERRUPT();
 
   #if HAS_AUTO_FAN_0
  *  - Call planner.isr to count down its "ignore" time
  */
 HAL_TEMP_TIMER_ISR() {
-  HAL_timer_isr_prologue(TEMP_TIMER_NUM);
+  HAL_timer_isr_prologue(MF_TIMER_TEMP);
 
   Temperature::isr();
 
-  HAL_timer_isr_epilogue(TEMP_TIMER_NUM);
+  HAL_timer_isr_epilogue(MF_TIMER_TEMP);
 }
 
 #if ENABLED(SLOW_PWM_HEATERS) && !defined(MIN_STATE_TIME)

Marlin/src/pins/sam/pins_ARCHIM1.h

 //
 // Timers
 //
-// These are already defined in DUE, so must be undefined first
-#define STEP_TIMER_NUM                         3
+#define MF_TIMER_STEP  3
 #define HAL_STEP_TIMER_ISR()  void TC3_Handler()
 
 //

Marlin/src/pins/stm32f0/pins_MALYAN_M300.h

 //
 // Timers
 //
-#define STEP_TIMER                             6
-#define TEMP_TIMER                             7
+#define STEP_TIMER  6
+#define TEMP_TIMER  7
 
 //
 // Limit Switches

Marlin/src/pins/stm32f1/pins_FLSUN_HISPEED.h

 #define BOARD_NO_NATIVE_USB
 
 // Avoid conflict with TIMER_SERVO when using the STM32 HAL
-#define TEMP_TIMER                             5
+#define TEMP_TIMER  5
 
 //
 // Release PB4 (Y_ENABLE_PIN) from JTAG NRST role

Marlin/src/pins/stm32f1/pins_MALYAN_M200.h

 // On STM32F103:
 // PB3, PB6, PB7, and PB8 can be used with pwm, which rules out TIM2 and TIM4.
 // On STM32F070, 16 and 17 are in use, but 1 and 3 are available.
-#define STEP_TIMER                             1
-#define TEMP_TIMER                             3
+#define STEP_TIMER  1
+#define TEMP_TIMER  3
 
 //
 // Limit Switches

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_E3P.h

 #define MKS_HARDWARE_TEST_ONLY_E0
 
 // Avoid conflict with TIMER_SERVO when using the STM32 HAL
-#define TEMP_TIMER                             5
+#define TEMP_TIMER  5
 
 //
 // Release PB4 (Y_ENABLE_PIN) from JTAG NRST role

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_NANO_V2.h

 #define USES_DIAG_PINS
 
 // Avoid conflict with TIMER_SERVO when using the STM32 HAL
-#define TEMP_TIMER                             5
+#define TEMP_TIMER  5
 
 //
 // Release PB4 (Y_ENABLE_PIN) from JTAG NRST role

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_NANO_common.h

 #define BOARD_NO_NATIVE_USB
 
 // Avoid conflict with TIMER_SERVO when using the STM32 HAL
-#define TEMP_TIMER                             5
+#define TEMP_TIMER  5
 
 //
 // EEPROM

Marlin/src/pins/stm32f4/pins_BTT_OCTOPUS_V1_common.h

 #define I2C_SDA_PIN                         PB9
 
 // Avoid conflict with TIMER_TONE
-#define STEP_TIMER                            10
+#define STEP_TIMER 10
 
 //
 // Servos

Marlin/src/pins/stm32f4/pins_BTT_SKR_V2_0_common.h

 #define HAS_OTG_USB_HOST_SUPPORT                  // USB Flash Drive support
 
 // Avoid conflict with TIMER_TONE
-#define STEP_TIMER                            10
+#define STEP_TIMER 10
 
 //
 // Servos

Marlin/src/pins/stm32f4/pins_FLYF407ZG.h

 #define DEFAULT_MACHINE_NAME BOARD_INFO_NAME
 
 // Avoid conflict with fans and TIMER_TONE
-#define TEMP_TIMER                             3
-#define STEP_TIMER                             5
+#define TEMP_TIMER  3
+#define STEP_TIMER  5
 
 //
 // EEPROM Emulation

Marlin/src/pins/stm32f4/pins_LERDGE_S.h

 #define BOARD_INFO_NAME      "Lerdge S"
 #define DEFAULT_MACHINE_NAME "LERDGE"
 
-#define STEP_TIMER                             4
-#define TEMP_TIMER                             2
+#define STEP_TIMER  4
+#define TEMP_TIMER  2
 
 #define HAS_OTG_USB_HOST_SUPPORT                  // USB Flash Drive support
 

Marlin/src/pins/stm32f4/pins_LERDGE_X.h

 #define BOARD_INFO_NAME      "Lerdge X"
 #define DEFAULT_MACHINE_NAME "LERDGE"
 
-#define STEP_TIMER                             4
-#define TEMP_TIMER                             2
+#define STEP_TIMER  4
+#define TEMP_TIMER  2
 
 #define I2C_EEPROM
 #define I2C_SCL_PIN                         PB8

Marlin/src/pins/stm32f4/pins_MKS_MONSTER8.h

 //#define DISABLE_DEBUG
 
 // Avoid conflict with TIMER_TONE
-#define STEP_TIMER                            10
+#define STEP_TIMER 10
 
 // Use one of these or SDCard-based Emulation will be used
 //#define SRAM_EEPROM_EMULATION                   // Use BackSRAM-based EEPROM emulation

Marlin/src/pins/stm32f4/pins_MKS_ROBIN_NANO_V3_common.h

 #define HAS_OTG_USB_HOST_SUPPORT                  // USB Flash Drive support
 
 // Avoid conflict with TIMER_TONE
-#define STEP_TIMER                            10
+#define STEP_TIMER 10
 
 // Use one of these or SDCard-based Emulation will be used
 //#define SRAM_EEPROM_EMULATION                   // Use BackSRAM-based EEPROM emulation

Marlin/src/pins/stm32f4/pins_RUMBA32_common.h

 //              This will be difficult to solve from the Arduino IDE, without modifying the RUMBA32 variant
 //              included with the STM32 framework.
 
-#define STEP_TIMER                            10
-#define TEMP_TIMER                            14
+#define STEP_TIMER 10
+#define TEMP_TIMER 14
 
 //
 // Limit Switches

Marlin/src/pins/stm32f7/pins_NUCLEO_F767ZI.h

  * TIM14 - TEMP_TIMER (Marlin)
  *
  */
-#define STEP_TIMER                             4
-#define TEMP_TIMER                            14
+#define STEP_TIMER  4
+#define TEMP_TIMER 14
 
 /**
  * These pin assignments are arbitrary and intending for testing purposes.

Marlin/src/pins/stm32f7/pins_REMRAM_V1.h

 // Timers
 //
 
-#define STEP_TIMER                             2
+#define STEP_TIMER  2