Move FAST_PWM_FAN code to HALs (#13491)

Marlin/src/HAL/HAL_AVR/HAL.h

@@ -372,3 +372,22 @@ inline void HAL_adc_init(void) {
 
 // AVR compatibility
 #define strtof strtod
+
+/**
+ *  set_pwm_frequency
+ *  Sets the frequency of the timer corresponding to the provided pin
+ *  as close as possible to the provided desired frequency. Internally
+ *  calculates the required waveform generation mode, prescaler and
+ *  resolution values required and sets the timer registers accordingly.
+ *  NOTE that the frequency is applied to all pins on the timer (Ex OC3A, OC3B and OC3B)
+ *  NOTE that there are limitations, particularly if using TIMER2. (see Configuration_adv.h -> FAST FAN PWM Settings)
+ */
+void set_pwm_frequency(const pin_t pin, int f_desired);
+
+/**
+ * set_pwm_duty
+ *  Sets 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]
+ */
+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/HAL_AVR/fast_pwm.cpp

@@ -0,0 +1,250 @@
+#ifdef __AVR__
+
+#include "../../inc/MarlinConfigPre.h"
+/**
+ * get_pwm_timer
+ *  Grabs timer information and registers of the provided pin
+ *  returns Timer struct containing this information
+ *  Used by set_pwm_frequency, set_pwm_duty
+ *
+ */
+
+#if ENABLED(FAST_PWM_FAN)
+#include "HAL.h"
+
+  struct Timer {
+    volatile uint8_t* TCCRnQ[3];  // max 3 TCCR registers per timer
+    volatile uint16_t* OCRnQ[3];  // max 3 OCR registers per timer
+    volatile uint16_t* ICRn;      // max 1 ICR register per timer
+    uint8_t n;                    // the timer number [0->5]
+    uint8_t q;                    // the timer output [0->2] (A->C)
+  };
+
+  Timer get_pwm_timer(pin_t pin) {
+    uint8_t q = 0;
+    switch (digitalPinToTimer(pin)) {
+      // Protect reserved timers (TIMER0 & TIMER1)
+      #ifdef TCCR0A
+        #if !AVR_AT90USB1286_FAMILY
+          case TIMER0A:
+        #endif
+        case TIMER0B:
+      #endif
+      #ifdef TCCR1A
+        case TIMER1A: case TIMER1B:
+      #endif
+                                          break;
+      #if defined(TCCR2) || defined(TCCR2A)
+        #ifdef TCCR2
+          case TIMER2: {
+            Timer timer = {
+              /*TCCRnQ*/  { &TCCR2, NULL, NULL},
+              /*OCRnQ*/   { (uint16_t*)&OCR2, NULL, NULL},
+              /*ICRn*/      NULL,
+              /*n, q*/      2, 0
+            };
+          }
+        #elif defined TCCR2A
+          #if ENABLED(USE_OCR2A_AS_TOP)
+            case TIMER2A:   break; // protect TIMER2A
+            case TIMER2B: {
+              Timer timer = {
+                /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  NULL},
+                /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, NULL},
+                /*ICRn*/      NULL,
+                /*n, q*/      2, 1
+              };
+              return timer;
+            }
+          #else
+            case TIMER2B:   ++q;
+            case TIMER2A: {
+              Timer timer = {
+                /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  NULL},
+                /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, NULL},
+                /*ICRn*/      NULL,
+                              2, q
+              };
+              return timer;
+            }
+          #endif
+        #endif
+      #endif
+      #ifdef TCCR3A
+        case TIMER3C:   ++q;
+        case TIMER3B:   ++q;
+        case TIMER3A: {
+          Timer timer = {
+            /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  &TCCR3C},
+            /*OCRnQ*/   { &OCR3A,   &OCR3B,   &OCR3C},
+            /*ICRn*/      &ICR3,
+            /*n, q*/      3, q
+          };
+          return timer;
+        }
+      #endif
+      #ifdef TCCR4A
+        case TIMER4C:   ++q;
+        case TIMER4B:   ++q;
+        case TIMER4A: {
+          Timer timer = {
+            /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C},
+            /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C},
+            /*ICRn*/      &ICR4,
+            /*n, q*/      4, q
+          };
+          return timer;
+        }
+      #endif
+      #ifdef TCCR5A
+        case TIMER5C:   ++q;
+        case TIMER5B:   ++q;
+        case TIMER5A: {
+          Timer timer = {
+            /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C},
+            /*OCRnQ*/   { &OCR5A,   &OCR5B,   &OCR5C },
+            /*ICRn*/      &ICR5,
+            /*n, q*/      5, q
+          };
+          return timer;
+        }
+      #endif
+    }
+    Timer timer = {
+        /*TCCRnQ*/  { NULL, NULL, NULL},
+        /*OCRnQ*/   { NULL, NULL, NULL},
+        /*ICRn*/      NULL,
+                      0, 0
+    };
+    return timer;
+  }
+
+  void set_pwm_frequency(const pin_t pin, int f_desired) {
+    Timer timer = get_pwm_timer(pin);
+    if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
+    uint16_t size;
+    if (timer.n == 2) size = 255; else size = 65535;
+
+    uint16_t res = 255;   // resolution (TOP value)
+    uint8_t j = 0;        // prescaler index
+    uint8_t wgm = 1;      // waveform generation mode
+
+    // Calculating the prescaler and resolution to use to achieve closest frequency
+    if (f_desired != 0) {
+      int f = (F_CPU) / (2 * 1024 * size) + 1; // Initialize frequency as lowest (non-zero) achievable
+      uint16_t prescaler[] = { 0, 1, 8, /*TIMER2 ONLY*/32, 64, /*TIMER2 ONLY*/128, 256, 1024 };
+
+      // loop over prescaler values
+      for (uint8_t i = 1; i < 8; i++) {
+        uint16_t res_temp_fast = 255, res_temp_phase_correct = 255;
+        if (timer.n == 2) {
+          // No resolution calculation for TIMER2 unless enabled USE_OCR2A_AS_TOP
+          #if ENABLED(USE_OCR2A_AS_TOP)
+            const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
+            res_temp_fast = rtf - 1;
+            res_temp_phase_correct = rtf / 2;
+          #endif
+        }
+        else {
+          // Skip TIMER2 specific prescalers when not TIMER2
+          if (i == 3 || i == 5) continue;
+          const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
+          res_temp_fast = rtf - 1;
+          res_temp_phase_correct = rtf / 2;
+        }
+
+        LIMIT(res_temp_fast, 1u, size);
+        LIMIT(res_temp_phase_correct, 1u, size);
+        // Calculate frequencies of test prescaler and resolution values
+        const int f_temp_fast = (F_CPU) / (prescaler[i] * (1 + res_temp_fast)),
+                  f_temp_phase_correct = (F_CPU) / (2 * prescaler[i] * res_temp_phase_correct),
+                  f_diff = ABS(f - f_desired),
+                  f_fast_diff = ABS(f_temp_fast - f_desired),
+                  f_phase_diff = ABS(f_temp_phase_correct - f_desired);
+
+        // If FAST values are closest to desired f
+        if (f_fast_diff < f_diff && f_fast_diff <= f_phase_diff) {
+          // Remember this combination
+          f = f_temp_fast;
+          res = res_temp_fast;
+          j = i;
+          // Set the Wave Generation Mode to FAST PWM
+          if (timer.n == 2) {
+            wgm = (
+              #if ENABLED(USE_OCR2A_AS_TOP)
+                WGM2_FAST_PWM_OCR2A
+              #else
+                WGM2_FAST_PWM
+              #endif
+            );
+          }
+          else wgm = WGM_FAST_PWM_ICRn;
+        }
+        // If PHASE CORRECT values are closes to desired f
+        else if (f_phase_diff < f_diff) {
+          f = f_temp_phase_correct;
+          res = res_temp_phase_correct;
+          j = i;
+          // Set the Wave Generation Mode to PWM PHASE CORRECT
+          if (timer.n == 2) {
+            wgm = (
+              #if ENABLED(USE_OCR2A_AS_TOP)
+                WGM2_PWM_PC_OCR2A
+              #else
+                WGM2_PWM_PC
+              #endif
+            );
+          }
+          else wgm = WGM_PWM_PC_ICRn;
+        }
+      }
+    }
+    _SET_WGMnQ(timer.TCCRnQ, wgm);
+    _SET_CSn(timer.TCCRnQ, j);
+
+    if (timer.n == 2) {
+      #if ENABLED(USE_OCR2A_AS_TOP)
+        _SET_OCRnQ(timer.OCRnQ, 0, res);  // Set OCR2A value (TOP) = res
+      #endif
+    }
+    else
+      _SET_ICRn(timer.ICRn, res);         // Set ICRn value (TOP) = res
+  }
+
+  void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
+    // If v is 0 or v_size (max), digitalWrite to LOW or HIGH.
+    // Note that digitalWrite also disables pwm output for us (sets COM bit to 0)
+    if (v == 0)
+      digitalWrite(pin, invert);
+    else if (v == v_size)
+      digitalWrite(pin, !invert);
+    else {
+      Timer timer = get_pwm_timer(pin);
+      if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
+      // Set compare output mode to CLEAR -> SET or SET -> CLEAR (if inverted)
+      _SET_COMnQ(timer.TCCRnQ, (timer.q
+          #ifdef TCCR2
+            + (timer.q == 2) // COM20 is on bit 4 of TCCR2, thus requires q + 1 in the macro
+          #endif
+        ), COM_CLEAR_SET + invert
+      );
+
+      uint16_t top;
+      if (timer.n == 2) { // if TIMER2
+        top = (
+          #if ENABLED(USE_OCR2A_AS_TOP)
+            *timer.OCRnQ[0] // top = OCR2A
+          #else
+            255 // top = 0xFF (max)
+          #endif
+        );
+      }
+      else
+        top = *timer.ICRn; // top = ICRn
+
+      _SET_OCRnQ(timer.OCRnQ, timer.q, v * float(top / v_size)); // Scale 8/16-bit v to top value
+    }
+  }
+
+#endif // FAST_PWM_FAN
+#endif // __AVR__

Marlin/src/HAL/HAL_AVR/fastio_AVR.h

@@ -200,7 +200,7 @@ enum ClockSource2 : char {
     TCCR##T##B = (TCCR##T##B & ~(0x3 << WGM##T##2)) | (((int(V) >> 2) & 0x3) << WGM##T##2); \
   }while(0)
 #define SET_WGM(T,V) _SET_WGM(T,WGM_##V)
-// Runtime (see Temperature::set_pwm_frequency):
+// Runtime (see set_pwm_frequency):
 #define _SET_WGMnQ(TCCRnQ, V) do{ \
     *(TCCRnQ)[0] = (*(TCCRnQ)[0] & ~(0x3 << 0)) | (( int(V)       & 0x3) << 0); \
     *(TCCRnQ)[1] = (*(TCCRnQ)[1] & ~(0x3 << 3)) | (((int(V) >> 2) & 0x3) << 3); \
@@ -230,7 +230,7 @@ enum ClockSource2 : char {
 #define SET_CS4(V) _SET_CS4(CS_##V)
 #define SET_CS5(V) _SET_CS5(CS_##V)
 #define SET_CS(T,V) SET_CS##T(V)
-// Runtime (see Temperature::set_pwm_frequency)
+// Runtime (see set_pwm_frequency)
 #define _SET_CSn(TCCRnQ, V) do{ \
     (*(TCCRnQ)[1] = (*(TCCRnQ[1]) & ~(0x7 << 0)) | ((int(V) & 0x7) << 0)); \
   }while(0)
@@ -243,19 +243,19 @@ enum ClockSource2 : char {
 #define SET_COMB(T,V) SET_COM(T,B,V)
 #define SET_COMC(T,V) SET_COM(T,C,V)
 #define SET_COMS(T,V1,V2,V3) do{ SET_COMA(T,V1); SET_COMB(T,V2); SET_COMC(T,V3); }while(0)
-// Runtime (see Temperature::set_pwm_duty)
+// Runtime (see set_pwm_duty)
 #define _SET_COMnQ(TCCRnQ, Q, V) do{ \
     (*(TCCRnQ)[0] = (*(TCCRnQ)[0] & ~(0x3 << (6-2*(Q)))) | (int(V) << (6-2*(Q)))); \
   }while(0)
 
 // Set OCRnQ register
-// Runtime (see Temperature::set_pwm_duty):
+// Runtime (see set_pwm_duty):
 #define _SET_OCRnQ(OCRnQ, Q, V) do{ \
     (*(OCRnQ)[(Q)] = (0x0000) | (int(V) & 0xFFFF)); \
   }while(0)
 
 // Set ICRn register (one per timer)
-// Runtime (see Temperature::set_pwm_frequency)
+// Runtime (see set_pwm_frequency)
 #define _SET_ICRn(ICRn, V) do{ \
     (*(ICRn) = (0x0000) | (int(V) & 0xFFFF)); \
   }while(0)

Marlin/src/HAL/HAL_DUE/SanityCheck.h

@@ -50,3 +50,7 @@
     #error "DUE software SPI is required but is incompatible with TMC2130 hardware SPI. Enable TMC_USE_SW_SPI to fix."
   #endif
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_ESP32/SanityCheck.h

@@ -23,3 +23,7 @@
 #if ENABLED(EMERGENCY_PARSER)
   #error "EMERGENCY_PARSER is not yet implemented for ESP32. Disable EMERGENCY_PARSER to continue."
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_LINUX/SanityCheck.h

@@ -65,3 +65,7 @@
     #endif
   #endif
 #endif // SPINDLE_LASER_ENABLE
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_LPC1768/HAL.h

@@ -157,3 +157,19 @@ void HAL_idletask(void);
 
 #define PLATFORM_M997_SUPPORT
 void flashFirmware(int16_t value);
+
+/**
+ * set_pwm_frequency
+ *  Set the frequency of the timer corresponding to the provided pin
+ *  All Hardware PWM pins run at the same frequency and all
+ *  Software PWM pins run at the same frequency
+ */
+void set_pwm_frequency(const pin_t pin, int f_desired);
+
+/**
+ * set_pwm_duty
+ *  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]
+ */
+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/HAL_LPC1768/fast_pwm.cpp

@@ -0,0 +1,40 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2019 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef TARGET_LPC1768
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if ENABLED(FAST_PWM_FAN)
+
+#include <pwm.h>
+
+void set_pwm_frequency(const pin_t pin, int f_desired) {
+  pwm_set_frequency(pin, f_desired);
+}
+
+void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
+  pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size);
+}
+
+#endif // FAST_PWM_FAN
+#endif // TARGET_LPC1768

Marlin/src/HAL/HAL_STM32/SanityCheck.h

@@ -69,3 +69,7 @@
 #if ENABLED(EMERGENCY_PARSER)
   #error "EMERGENCY_PARSER is not yet implemented for STM32. Disable EMERGENCY_PARSER to continue."
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_STM32F1/SanityCheck.h

@@ -74,3 +74,7 @@
 #if ENABLED(SDIO_SUPPORT) && DISABLED(SDSUPPORT)
   #error "SDIO_SUPPORT requires SDSUPPORT. Enable SDSUPPORT to continue."
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_STM32F4/SanityCheck.h

@@ -68,3 +68,7 @@
 #if ENABLED(EMERGENCY_PARSER)
   #error "EMERGENCY_PARSER is not yet implemented for STM32F4. Disable EMERGENCY_PARSER to continue."
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_STM32F7/SanityCheck.h

@@ -70,3 +70,7 @@
 #if ENABLED(EMERGENCY_PARSER)
   #error "EMERGENCY_PARSER is not yet implemented for STM32F7. Disable EMERGENCY_PARSER to continue."
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_TEENSY31_32/SanityCheck.h

@@ -27,3 +27,7 @@
 #if ENABLED(EMERGENCY_PARSER)
   #error "EMERGENCY_PARSER is not yet implemented for Teensy 3.1/3.2. Disable EMERGENCY_PARSER to continue."
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/HAL/HAL_TEENSY35_36/SanityCheck.h

@@ -27,3 +27,7 @@
 #if ENABLED(EMERGENCY_PARSER)
   #error "EMERGENCY_PARSER is not yet implemented for Teensy 3.5/3.6. Disable EMERGENCY_PARSER to continue."
 #endif
+
+#if ENABLED(FAST_PWM_FAN)
+  #error "FAST_PWM_FAN is not yet implemented for this platform."
+#endif

Marlin/src/inc/SanityCheck.h

@@ -2015,10 +2015,6 @@ static_assert(   _ARR_TEST(3,0) && _ARR_TEST(3,1) && _ARR_TEST(3,2)
   #error "POWER_LOSS_RECOVERY currently requires an LCD Controller."
 #endif
 
-#if ENABLED(FAST_PWM_FAN) && !(defined(ARDUINO) && !defined(ARDUINO_ARCH_SAM))
-  #error "FAST_PWM_FAN is only supported for ARDUINO and ARDUINO_ARCH_SAM."
-#endif
-
 #if ENABLED(Z_STEPPER_AUTO_ALIGN)
   #if !Z_MULTI_STEPPER_DRIVERS
     #error "Z_STEPPER_AUTO_ALIGN requires Z_DUAL_STEPPER_DRIVERS or Z_TRIPLE_STEPPER_DRIVERS."

Marlin/src/module/planner.cpp

@@ -1278,13 +1278,13 @@ void Planner::check_axes_activity() {
     #elif ENABLED(FAST_PWM_FAN)
 
       #if HAS_FAN0
-        thermalManager.set_pwm_duty(FAN_PIN, CALC_FAN_SPEED(0));
+        set_pwm_duty(FAN_PIN, CALC_FAN_SPEED(0));
       #endif
       #if HAS_FAN1
-        thermalManager.set_pwm_duty(FAN1_PIN, CALC_FAN_SPEED(1));
+        set_pwm_duty(FAN1_PIN, CALC_FAN_SPEED(1));
       #endif
       #if HAS_FAN2
-        thermalManager.set_pwm_duty(FAN2_PIN, CALC_FAN_SPEED(2));
+        set_pwm_duty(FAN2_PIN, CALC_FAN_SPEED(2));
       #endif
 
     #else

Marlin/src/module/temperature.cpp

@@ -1544,237 +1544,6 @@ void Temperature::init() {
   #endif
 }
 
-
-#if ENABLED(FAST_PWM_FAN)
-  Temperature::Timer Temperature::get_pwm_timer(pin_t pin) {
-    #if defined(ARDUINO) && !defined(ARDUINO_ARCH_SAM)
-      uint8_t q = 0;
-      switch (digitalPinToTimer(pin)) {
-        // Protect reserved timers (TIMER0 & TIMER1)
-        #ifdef TCCR0A
-          #if !AVR_AT90USB1286_FAMILY
-            case TIMER0A:
-          #endif
-          case TIMER0B:
-        #endif
-        #ifdef TCCR1A
-          case TIMER1A: case TIMER1B:
-        #endif
-                                            break;
-        #if defined(TCCR2) || defined(TCCR2A)
-          #ifdef TCCR2
-            case TIMER2: {
-              Temperature::Timer timer = {
-                /*TCCRnQ*/  { &TCCR2, NULL, NULL},
-                /*OCRnQ*/   { (uint16_t*)&OCR2, NULL, NULL},
-                /*ICRn*/      NULL,
-                /*n, q*/      2, 0
-              };
-            }
-          #elif defined TCCR2A
-            #if ENABLED(USE_OCR2A_AS_TOP)
-              case TIMER2A:   break; // protect TIMER2A
-              case TIMER2B: {
-                Temperature::Timer timer = {
-                  /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  NULL},
-                  /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, NULL},
-                  /*ICRn*/      NULL,
-                  /*n, q*/      2, 1
-                };
-                return timer;
-              }
-            #else
-              case TIMER2B:   q += 1;
-              case TIMER2A: {
-                Temperature::Timer timer = {
-                  /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  NULL},
-                  /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, NULL},
-                  /*ICRn*/      NULL,
-                                2, q
-                };
-                return timer;
-              }
-            #endif
-          #endif
-        #endif
-        #ifdef TCCR3A
-          case TIMER3C:   q += 1;
-          case TIMER3B:   q += 1;
-          case TIMER3A: {
-            Temperature::Timer timer = {
-              /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  &TCCR3C},
-              /*OCRnQ*/   { &OCR3A,   &OCR3B,   &OCR3C},
-              /*ICRn*/      &ICR3,
-              /*n, q*/      3, q
-            };
-            return timer;
-          }
-        #endif
-        #ifdef TCCR4A
-          case TIMER4C:   q += 1;
-          case TIMER4B:   q += 1;
-          case TIMER4A: {
-            Temperature::Timer timer = {
-              /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C},
-              /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C},
-              /*ICRn*/      &ICR4,
-              /*n, q*/      4, q
-            };
-            return timer;
-          }
-        #endif
-        #ifdef TCCR5A
-          case TIMER5C:   q += 1;
-          case TIMER5B:   q += 1;
-          case TIMER5A: {
-            Temperature::Timer timer = {
-              /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C},
-              /*OCRnQ*/   { &OCR5A,   &OCR5B,   &OCR5C },
-              /*ICRn*/      &ICR5,
-              /*n, q*/      5, q
-            };
-            return timer;
-          }
-        #endif
-      }
-      Temperature::Timer timer = {
-          /*TCCRnQ*/  { NULL, NULL, NULL},
-          /*OCRnQ*/   { NULL, NULL, NULL},
-          /*ICRn*/      NULL,
-                        0, 0
-      };
-      return timer;
-    #endif // ARDUINO && !ARDUINO_ARCH_SAM
-  }
-
-  void Temperature::set_pwm_frequency(const pin_t pin, int f_desired) {
-    #if defined(ARDUINO) && !defined(ARDUINO_ARCH_SAM)
-      Temperature::Timer timer = get_pwm_timer(pin);
-      if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
-      uint16_t size;
-      if (timer.n == 2) size = 255; else size = 65535;
-
-      uint16_t res = 255;   // resolution (TOP value)
-      uint8_t j = 0;        // prescaler index
-      uint8_t wgm = 1;      // waveform generation mode
-
-      // Calculating the prescaler and resolution to use to achieve closest frequency
-      if (f_desired != 0) {
-        int f = F_CPU/(2*1024*size) + 1; // Initialize frequency as lowest (non-zero) achievable
-        uint16_t prescaler[] = {0, 1, 8, /*TIMER2 ONLY*/32, 64, /*TIMER2 ONLY*/128, 256, 1024};
-
-        // loop over prescaler values
-        for (uint8_t i = 1; i < 8; i++) {
-          uint16_t res_temp_fast = 255, res_temp_phase_correct = 255;
-          if (timer.n == 2) {
-            // No resolution calculation for TIMER2 unless enabled USE_OCR2A_AS_TOP
-            #if ENABLED(USE_OCR2A_AS_TOP)
-              res_temp_fast = (F_CPU / (prescaler[i] * f_desired)) - 1;
-              res_temp_phase_correct = F_CPU / (2 * prescaler[i] * f_desired);
-            #endif
-          }
-          else {
-            // Skip TIMER2 specific prescalers when not TIMER2
-            if (i == 3 || i == 5) continue;
-            res_temp_fast = (F_CPU / (prescaler[i] * f_desired)) - 1;
-            res_temp_phase_correct = F_CPU / (2 * prescaler[i] * f_desired);
-          }
-
-          LIMIT(res_temp_fast, 1u, size);
-          LIMIT(res_temp_phase_correct, 1u, size);
-          // Calculate frequncies of test prescaler and resolution values
-          int f_temp_fast = F_CPU / (prescaler[i] * (1 + res_temp_fast));
-          int f_temp_phase_correct = F_CPU / (2 * prescaler[i] * res_temp_phase_correct);
-
-          // If FAST values are closest to desired f
-          if (ABS(f_temp_fast - f_desired) < ABS(f - f_desired)
-              && ABS(f_temp_fast - f_desired) <= ABS(f_temp_phase_correct - f_desired)) {
-            // Remember this combination
-            f = f_temp_fast;
-            res = res_temp_fast;
-            j = i;
-            // Set the Wave Generation Mode to FAST PWM
-            if(timer.n == 2){
-              wgm =
-                #if ENABLED(USE_OCR2A_AS_TOP)
-                  WGM2_FAST_PWM_OCR2A;
-                #else
-                  WGM2_FAST_PWM;
-                #endif
-            }
-            else wgm = WGM_FAST_PWM_ICRn;
-          }
-          // If PHASE CORRECT values are closes to desired f
-          else if (ABS(f_temp_phase_correct - f_desired) < ABS(f - f_desired)) {
-            f = f_temp_phase_correct;
-            res = res_temp_phase_correct;
-            j = i;
-            // Set the Wave Generation Mode to PWM PHASE CORRECT
-            if (timer.n == 2) {
-              wgm =
-                #if ENABLED(USE_OCR2A_AS_TOP)
-                  WGM2_PWM_PC_OCR2A;
-                #else
-                  WGM2_PWM_PC;
-                #endif
-            }
-            else wgm = WGM_PWM_PC_ICRn;
-          }
-        }
-      }
-      _SET_WGMnQ(timer.TCCRnQ, wgm);
-      _SET_CSn(timer.TCCRnQ, j);
-
-      if (timer.n == 2) {
-        #if ENABLED(USE_OCR2A_AS_TOP)
-          _SET_OCRnQ(timer.OCRnQ, 0, res);  // Set OCR2A value (TOP) = res
-        #endif
-      }
-      else {
-        _SET_ICRn(timer.ICRn, res);         // Set ICRn value (TOP) = res
-      }
-    #endif // ARDUINO && !ARDUINO_ARCH_SAM
-  }
-
-  void Temperature::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
-    #if defined(ARDUINO) && !defined(ARDUINO_ARCH_SAM)
-      // If v is 0 or v_size (max), digitalWrite to LOW or HIGH.
-      // Note that digitalWrite also disables pwm output for us (sets COM bit to 0)
-      if (v == 0)
-        digitalWrite(pin, invert);
-      else if (v == v_size)
-        digitalWrite(pin, !invert);
-      else {
-        Temperature::Timer timer = get_pwm_timer(pin);
-        if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
-        // Set compare output mode to CLEAR -> SET or SET -> CLEAR (if inverted)
-        _SET_COMnQ(timer.TCCRnQ, timer.q
-            #ifdef TCCR2
-              + (timer.q == 2) // COM20 is on bit 4 of TCCR2, thus requires q + 1 in the macro
-            #endif
-          , COM_CLEAR_SET + invert
-        );
-
-        uint16_t top;
-        if (timer.n == 2) { // if TIMER2
-          top =
-            #if ENABLED(USE_OCR2A_AS_TOP)
-              *timer.OCRnQ[0] // top = OCR2A
-            #else
-              255 // top = 0xFF (max)
-            #endif
-          ;
-        }
-        else
-          top = *timer.ICRn; // top = ICRn
-
-        _SET_OCRnQ(timer.OCRnQ, timer.q, v * float(top / v_size)); // Scale 8/16-bit v to top value
-      }
-    #endif // ARDUINO && !ARDUINO_ARCH_SAM
-  }
-
-#endif // FAST_PWM_FAN
-
 #if WATCH_HOTENDS
   /**
    * Start Heating Sanity Check for hotends that are below

Marlin/src/module/temperature.h

@@ -266,16 +266,6 @@ class Temperature {
                      soft_pwm_count_fan[FAN_COUNT];
     #endif
 
-    /**
-     * set_pwm_duty (8-bit AVRs only)
-     *  Sets 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]
-     */
-    #if ENABLED(FAST_PWM_FAN)
-      static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
-    #endif
-
     #if ENABLED(BABYSTEPPING)
       static volatile int16_t babystepsTodo[3];
     #endif
@@ -744,38 +734,7 @@ class Temperature {
     #endif
 
   private:
-
-    /**
-     * (8-bit AVRs only)
-     *
-     * get_pwm_timer
-     *  Grabs timer information and registers of the provided pin
-     *  returns Timer struct containing this information
-     *  Used by set_pwm_frequency, set_pwm_duty
-     *
-     * set_pwm_frequency
-     *  Sets the frequency of the timer corresponding to the provided pin
-     *  as close as possible to the provided desired frequency. Internally
-     *  calculates the required waveform generation mode, prescaler and
-     *  resolution values required and sets the timer registers accordingly.
-     *  NOTE that the frequency is applied to all pins on the timer (Ex OC3A, OC3B and OC3B)
-     *  NOTE that there are limitations, particularly if using TIMER2. (see Configuration_adv.h -> FAST FAN PWM Settings)
-     */
-    #if ENABLED(FAST_PWM_FAN)
-      typedef struct Timer {
-          volatile uint8_t* TCCRnQ[3];  // max 3 TCCR registers per timer
-          volatile uint16_t* OCRnQ[3];  // max 3 OCR registers per timer
-          volatile uint16_t* ICRn;      // max 1 ICR register per timer
-          uint8_t n;                    // the timer number [0->5]
-          uint8_t q;                    // the timer output [0->2] (A->C)
-      } Timer;
-
-      static Timer get_pwm_timer(const pin_t pin);
-      static void set_pwm_frequency(const pin_t pin, int f_desired);
-    #endif
-
     static void set_current_temp_raw();
-
     static void updateTemperaturesFromRawValues();
 
     #define HAS_MAX6675 EITHER(HEATER_0_USES_MAX6675, HEATER_1_USES_MAX6675)