Add HAS_FAN and others

Marlin/src/feature/pause.cpp

   // Wait for buffered blocks to complete
   planner.synchronize();
 
-  #if ENABLED(ADVANCED_PAUSE_FANS_PAUSE) && FAN_COUNT > 0
+  #if ENABLED(ADVANCED_PAUSE_FANS_PAUSE) && HAS_FAN
     thermalManager.set_fans_paused(true);
   #endif
 
     if (did_pause_print) { card.startFileprint(); --did_pause_print; }
   #endif
 
-  #if ENABLED(ADVANCED_PAUSE_FANS_PAUSE) && FAN_COUNT > 0
+  #if ENABLED(ADVANCED_PAUSE_FANS_PAUSE) && HAS_FAN
     thermalManager.set_fans_paused(false);
   #endif
 

Marlin/src/feature/powerloss.cpp

 
     TERN_(HAS_HEATED_BED, info.target_temperature_bed = thermalManager.temp_bed.target);
 
-    #if FAN_COUNT
+    #if HAS_FAN
       COPY(info.fan_speed, thermalManager.fan_speed);
     #endif
 
           DEBUG_ECHOLNPAIR("target_temperature_bed: ", info.target_temperature_bed);
         #endif
 
-        #if FAN_COUNT
+        #if HAS_FAN
           DEBUG_ECHOPGM("fan_speed: ");
           FANS_LOOP(i) {
             DEBUG_ECHO(int(info.fan_speed[i]));

Marlin/src/feature/powerloss.h

     int16_t target_temperature_bed;
   #endif
 
-  #if FAN_COUNT
+  #if HAS_FAN
     uint8_t fan_speed[FAN_COUNT];
   #endif
 

Marlin/src/feature/probe_temp_comp.h

     static constexpr xy_pos_t measure_point    = PTC_PROBE_POS;     // Coordinates to probe
                             //measure_point    = { 12.0f, 7.3f };   // Coordinates for the MK52 magnetic heatbed
 
-    static constexpr int  probe_calib_bed_temp = BED_MAXTEMP - 10,  // Bed temperature while calibrating probe
+    static constexpr int  probe_calib_bed_temp = BED_MAX_TARGET,  // Bed temperature while calibrating probe
                           bed_calib_probe_temp = 30;                // Probe temperature while calibrating bed
 
     static int16_t *sensor_z_offsets[TSI_COUNT],

Marlin/src/gcode/bedlevel/G26.cpp

   #if HAS_HEATED_BED
     if (parser.seenval('B')) {
       g26_bed_temp = parser.value_celsius();
-      if (g26_bed_temp && !WITHIN(g26_bed_temp, 40, (BED_MAXTEMP - 10))) {
-        SERIAL_ECHOLNPAIR("?Specified bed temperature not plausible (40-", int(BED_MAXTEMP - 10), "C).");
+      if (g26_bed_temp && !WITHIN(g26_bed_temp, 40, BED_MAX_TARGET)) {
+        SERIAL_ECHOLNPAIR("?Specified bed temperature not plausible (40-", int(BED_MAX_TARGET), "C).");
         return;
       }
     }

Marlin/src/gcode/calibrate/G76_M871.cpp

         report_temps(next_temp_report);
 
       const float measured_z = g76_probe(TSI_BED, target_bed, noz_pos_xyz);
-      if (isnan(measured_z) || target_bed > BED_MAXTEMP - 10) break;
+      if (isnan(measured_z) || target_bed > BED_MAX_TARGET) break;
     }
 
     SERIAL_ECHOLNPAIR("Retrieved measurements: ", temp_comp.get_index());

Marlin/src/gcode/config/M217.cpp

     if (parser.seenval('P')) { const int16_t v = parser.value_linear_units(); toolchange_settings.prime_speed = constrain(v, 10, 5400); }
     if (parser.seenval('R')) { const int16_t v = parser.value_linear_units(); toolchange_settings.retract_speed = constrain(v, 10, 5400); }
     if (parser.seenval('U')) { const int16_t v = parser.value_linear_units(); toolchange_settings.unretract_speed = constrain(v, 10, 5400); }
-    #if TOOLCHANGE_FS_FAN >= 0 && FAN_COUNT > 0
+    #if TOOLCHANGE_FS_FAN >= 0 && HAS_FAN
       if (parser.seenval('F')) { const int16_t v = parser.value_linear_units(); toolchange_settings.fan_speed = constrain(v, 0, 255); }
       if (parser.seenval('G')) { const int16_t v = parser.value_linear_units(); toolchange_settings.fan_time = constrain(v, 1, 30); }
     #endif

Marlin/src/gcode/control/M42.cpp

 #include "../../MarlinCore.h" // for pin_is_protected
 #include "../../inc/MarlinConfig.h"
 
-#if FAN_COUNT > 0
+#if HAS_FAN
   #include "../../module/temperature.h"
 #endif
 
   if (!parser.seenval('S')) return;
   const byte pin_status = parser.value_byte();
 
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     switch (pin) {
       #if HAS_FAN0
         case FAN0_PIN: thermalManager.fan_speed[0] = pin_status; return;

Marlin/src/gcode/control/M80_M81.cpp

   print_job_timer.stop();
   planner.finish_and_disable();
 
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     thermalManager.zero_fan_speeds();
     #if ENABLED(PROBING_FANS_OFF)
       thermalManager.fans_paused = false;

Marlin/src/gcode/gcode.cpp

 
       case 105: M105(); return;                                   // M105: Report Temperatures (and say "ok")
 
-      #if FAN_COUNT > 0
+      #if HAS_FAN
         case 106: M106(); break;                                  // M106: Fan On
         case 107: M107(); break;                                  // M107: Fan Off
       #endif

Marlin/src/gcode/gcode.h

 
   static void M105();
 
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     static void M106();
     static void M107();
   #endif

Marlin/src/gcode/lcd/M145.cpp

     #if TEMP_SENSOR_BED != 0
       if (parser.seenval('B')) {
         v = parser.value_int();
-        ui.preheat_bed_temp[material] = constrain(v, BED_MINTEMP, BED_MAXTEMP - 10);
+        ui.preheat_bed_temp[material] = constrain(v, BED_MINTEMP, BED_MAX_TARGET);
       }
     #endif
   }

Marlin/src/gcode/temp/M106_M107.cpp

 
 #include "../../inc/MarlinConfig.h"
 
-#if FAN_COUNT > 0
+#if HAS_FAN
 
 #include "../gcode.h"
 #include "../../module/motion.h"
   thermalManager.set_fan_speed(p, 0);
 }
 
-#endif // FAN_COUNT > 0
+#endif // HAS_FAN

Marlin/src/inc/Conditionals_LCD.h

  */
 
 #if EXTRUDERS == 0
+  #undef EXTRUDERS
+  #define EXTRUDERS 0
   #undef DISTINCT_E_FACTORS
   #undef SINGLENOZZLE
   #undef SWITCHING_EXTRUDER

Marlin/src/inc/Conditionals_post.h

 // Shorthand for common combinations
 #if HAS_TEMP_BED && HAS_HEATER_BED
   #define HAS_HEATED_BED 1
+  #define BED_MAX_TARGET (BED_MAXTEMP - 10)
 #endif
 #if HAS_HEATED_BED || HAS_TEMP_CHAMBER
   #define BED_OR_CHAMBER 1
 #endif
 
 #if FAN_COUNT > 0
+  #define HAS_FAN 1
   #define WRITE_FAN(n, v) WRITE(FAN##n##_PIN, (v) ^ FAN_INVERTING)
 #endif
 

Marlin/src/inc/SanityCheck.h

   #error "LCD_PIN_RESET is now LCD_RESET_PIN. Please update your pins definitions."
 #elif defined(EXTRUDER_0_AUTO_FAN_PIN) || defined(EXTRUDER_1_AUTO_FAN_PIN) || defined(EXTRUDER_2_AUTO_FAN_PIN) || defined(EXTRUDER_3_AUTO_FAN_PIN)
   #error "EXTRUDER_[0123]_AUTO_FAN_PIN is now E[0123]_AUTO_FAN_PIN. Please update your Configuration_adv.h."
-#elif defined(PID_FAN_SCALING) && FAN_COUNT <= 0
+#elif defined(PID_FAN_SCALING) && !HAS_FAN
   #error "PID_FAN_SCALING needs at least one fan enabled."
 #elif defined(min_software_endstops) || defined(max_software_endstops)
   #error "(min|max)_software_endstops are now (MIN|MAX)_SOFTWARE_ENDSTOPS. Please update your configuration."

Marlin/src/lcd/HD44780/ultralcd_HD44780.cpp

       if (TERN0(HAS_HEATED_BED, thermalManager.degTargetBed() > 0)) leds |= LED_A;
       if (TERN0(HAS_HOTEND, thermalManager.degTargetHotend(0) > 0)) leds |= LED_B;
 
-      #if FAN_COUNT > 0
+      #if HAS_FAN
         if ( TERN0(HAS_FAN0, thermalManager.fan_speed[0])
           || TERN0(HAS_FAN1, thermalManager.fan_speed[1])
           || TERN0(HAS_FAN2, thermalManager.fan_speed[2])
           || TERN0(HAS_FAN6, thermalManager.fan_speed[6])
           || TERN0(HAS_FAN7, thermalManager.fan_speed[7])
         ) leds |= LED_C;
-      #endif // FAN_COUNT > 0
+      #endif // HAS_FAN
 
       if (TERN0(HAS_MULTI_HOTEND, thermalManager.degTargetHotend(1) > 0)) leds |= LED_C;
 

Marlin/src/lcd/extui/lib/dgus/DGUSDisplay.cpp

 #endif
 
 // Send fan status value to the display.
-#if FAN_COUNT > 0
+#if HAS_FAN
   void DGUSScreenVariableHandler::DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var) {
     if (var.memadr) {
       DEBUG_ECHOPAIR(" DGUSLCD_SendFanStatusToDisplay ", var.VP);
   }
 #endif
 
-#if FAN_COUNT
+#if HAS_FAN
   void DGUSScreenVariableHandler::HandleFanControl(DGUS_VP_Variable &var, void *val_ptr) {
     DEBUG_ECHOLNPGM("HandleFanControl");
     *(uint8_t*)var.memadr = *(uint8_t*)var.memadr > 0 ? 0 : 255;

Marlin/src/lcd/extui/lib/dgus/DGUSDisplay.h

     // Hook for live z adjust action
     static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     // Hook for fan control
     static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr);
   #endif
     static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var);
     static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var);
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var);
   #endif
   static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var);

Marlin/src/lcd/extui/lib/dgus/fysetc/DGUSDisplayDef.cpp

   #if HAS_HEATED_BED
     VP_T_Bed_Is, VP_T_Bed_Set, VP_BED_STATUS,
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage, VP_FAN0_STATUS,
   #endif
   VP_XPos, VP_YPos, VP_ZPos,
   #if HAS_HEATED_BED
     VP_T_Bed_Is, VP_T_Bed_Set,
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage,
   #endif
   VP_XPos, VP_YPos, VP_ZPos,
   #if HAS_HEATED_BED
     VP_T_Bed_Is, VP_T_Bed_Set,
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage,
     #if FAN_COUNT > 1
       VP_Fan1_Percentage,
   #endif
 
   // Fan Data
-  #if FAN_COUNT
+  #if HAS_FAN
     #define FAN_VPHELPER(N) \
       VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], DGUSScreenVariableHandler::DGUSLCD_PercentageToUint8, &DGUSScreenVariableHandler::DGUSLCD_SendPercentageToDisplay), \
       VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], &DGUSScreenVariableHandler::HandleFanControl, nullptr), \

Marlin/src/lcd/extui/lib/dgus/hiprecy/DGUSDisplayDef.cpp

   #if HAS_HEATED_BED
     VP_T_Bed_Is, VP_T_Bed_Set, VP_BED_STATUS,
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage, VP_FAN0_STATUS,
   #endif
   VP_XPos, VP_YPos, VP_ZPos,
   #if HAS_HEATED_BED
     VP_T_Bed_Is, VP_T_Bed_Set,
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage,
   #endif
   VP_XPos, VP_YPos, VP_ZPos,
   #if HAS_HEATED_BED
     VP_T_Bed_Is, VP_T_Bed_Set,
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage,
     #if FAN_COUNT > 1
       VP_Fan1_Percentage,
     VP_T_Bed_Is, VP_T_Bed_Set,
   #endif
   VP_Feedrate_Percentage,
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage,
   #endif
   VP_Flowrate_E0,
   #endif
 
   // Fan Data
-  #if FAN_COUNT
+  #if HAS_FAN
     #define FAN_VPHELPER(N) \
       VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], DGUSScreenVariableHandler::DGUSLCD_PercentageToUint8, &DGUSScreenVariableHandler::DGUSLCD_SendPercentageToDisplay), \
       VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], &DGUSScreenVariableHandler::HandleFanControl, nullptr), \

Marlin/src/lcd/extui/lib/dgus/origin/DGUSDisplayDef.cpp

   #if HAS_HEATED_BED
     VP_T_Bed_Is, VP_T_Bed_Set,
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     VP_Fan0_Percentage,
   #endif
   VP_XPos, VP_YPos, VP_ZPos,
   #endif
 
   // Fan Data
-  #if FAN_COUNT
+  #if HAS_FAN
     #define FAN_VPHELPER(N) \
       VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], DGUSScreenVariableHandler::DGUSLCD_PercentageToUint8, &DGUSScreenVariableHandler::DGUSLCD_SendPercentageToDisplay), \
       VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], &DGUSScreenVariableHandler::HandleFanControl, nullptr), \

Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/screens/temperature_screen.cpp

   #if HAS_HEATED_CHAMBER
     w.adjuster(    22, GET_TEXT_F(MSG_CHAMBER), getTargetTemp_celsius(CHAMBER));
   #endif
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     w.color(fan_speed).units(GET_TEXT_F(MSG_UNITS_PERCENT));
     w.adjuster(    10, GET_TEXT_F(MSG_FAN_SPEED), getTargetFan_percent(FAN0));
   #endif
       case  8: UI_DECREMENT(TargetTemp_celsius, E3); break;
       case  9: UI_INCREMENT(TargetTemp_celsius, E3); break;
     #endif
-    #if FAN_COUNT > 0
+    #if HAS_FAN
       case 10: UI_DECREMENT(TargetFan_percent, FAN0); break;
       case 11: UI_INCREMENT(TargetFan_percent, FAN0); break;
     #endif
       REPEAT(HOTENDS, _HOTEND_OFF);
       TERN_(HAS_HEATED_BED, setTargetTemp_celsius(0,BED));
       TERN_(HAS_HEATED_CHAMBER, setTargetTemp_celsius(0,CHAMBER));
-      #if FAN_COUNT > 0
+      #if HAS_FAN
         setTargetFan_percent(0,FAN0);
       #endif
       break;

Marlin/src/lcd/extui/ui_api.cpp

   }
 
   float getTargetFan_percent(const fan_t fan) {
-    #if FAN_COUNT > 0
+    #if HAS_FAN
       return thermalManager.fanPercent(thermalManager.fan_speed[fan - FAN0]);
     #else
       UNUSED(fan);
   }
 
   float getActualFan_percent(const fan_t fan) {
-    #if FAN_COUNT > 0
+    #if HAS_FAN
       return thermalManager.fanPercent(thermalManager.scaledFanSpeed(fan - FAN0));
     #else
       UNUSED(fan);
     #endif
     #if HAS_HEATED_BED
       if (heater == BED)
-        thermalManager.setTargetBed(LROUND(constrain(value, 0, BED_MAXTEMP - 10)));
+        thermalManager.setTargetBed(LROUND(constrain(value, 0, BED_MAX_TARGET)));
       else
     #endif
       {
   }
 
   void setTargetFan_percent(const float value, const fan_t fan) {
-    #if FAN_COUNT > 0
+    #if HAS_FAN
       if (fan < FAN_COUNT)
         thermalManager.set_fan_speed(fan - FAN0, map(constrain(value, 0, 100), 0, 100, 0, 255));
     #else

Marlin/src/lcd/menu/menu.h

 #endif
 
 // First Fan Speed title in "Tune" and "Control>Temperature" menus
-#if FAN_COUNT > 0 && HAS_FAN0
+#if HAS_FAN && HAS_FAN0
   #if FAN_COUNT > 1
     #define FAN_SPEED_1_SUFFIX " 1"
   #else

Marlin/src/lcd/menu/menu_configuration.cpp

       EDIT_ITEM(int3, MSG_NOZZLE, &ui.preheat_hotend_temp[material], MINTEMP_ALL, MAXTEMP_ALL - 15);
     #endif
     #if HAS_HEATED_BED
-      EDIT_ITEM(int3, MSG_BED, &ui.preheat_bed_temp[material], BED_MINTEMP, BED_MAXTEMP - 10);
+      EDIT_ITEM(int3, MSG_BED, &ui.preheat_bed_temp[material], BED_MINTEMP, BED_MAX_TARGET);
     #endif
     #if ENABLED(EEPROM_SETTINGS)
       ACTION_ITEM(MSG_STORE_EEPROM, lcd_store_settings);

Marlin/src/lcd/menu/menu_temperature.cpp

 // "Temperature" submenu items
 //
 
-
 void Temperature::lcd_preheat(const int16_t e, const int8_t indh, const int8_t indb) {
   #if HAS_HOTEND
     if (indh >= 0 && ui.preheat_hotend_temp[indh] > 0)
       setTargetHotend(_MIN(heater_maxtemp[e] - 15, ui.preheat_hotend_temp[indh]), e);
   #else
+    UNUSED(e);
     UNUSED(temph);
   #endif
   #if HAS_HEATED_BED
-    if (indb >= 0 && ui.preheat_bed_temp[indb] >= 0) setTargetBed(ui.preheat_bed_temp[indb]);
+    if (indb >= 0 && ui.preheat_bed_temp[indb] > 0) setTargetBed(ui.preheat_bed_temp[indb]);
   #else
     UNUSED(indb);
   #endif
   #if HAS_FAN
     set_fan_speed((
       #if FAN_COUNT > 1
-        active_extruder < FAN_COUNT ? active_extruder : 0
-      #else
-        0
+        active_extruder < FAN_COUNT ? active_extruder :
       #endif
-    ), fan);
-  #else
-    UNUSED(fan);
+      0), ui.preheat_fan_speed[m]
+    );
   #endif
   ui.return_to_status();
 }
 
 #if HAS_TEMP_HOTEND
-  inline void _preheat_end(const uint8_t m, const uint8_t e) {
-    thermalManager.lcd_preheat(e, m, -1);
-  }
+  inline void _preheat_end(const uint8_t m, const uint8_t e) { thermalManager.lcd_preheat(e, m, -1); }
   #if HAS_HEATED_BED
-    inline void _preheat_both(const uint8_t m, const uint8_t e) {
-      thermalManager.lcd_preheat(e, m, m);
-    }
+    inline void _preheat_both(const uint8_t m, const uint8_t e) { thermalManager.lcd_preheat(e, m, m); }
   #endif
 #endif
 #if HAS_HEATED_BED
-  inline void _preheat_bed(const uint8_t m) {
-    thermalManager.lcd_preheat(-1, -1, m);
-  }
+  inline void _preheat_bed(const uint8_t m) { thermalManager.lcd_preheat(-1, -1, m); }
 #endif
 
 #if HAS_TEMP_HOTEND || HAS_HEATED_BED
   // Bed:
   //
   #if HAS_HEATED_BED
-    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAXTEMP - 10, thermalManager.start_watching_bed);
+    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAX_TARGET, thermalManager.start_watching_bed);
   #endif
 
   //
   //
   // Fan Speed:
   //
-  #if FAN_COUNT > 0
+  #if HAS_FAN
 
     auto on_fan_update = []{
       thermalManager.set_fan_speed(MenuItemBase::itemIndex, editable.uint8);
       singlenozzle_item(1);
     #endif
 
-  #endif // FAN_COUNT > 0
+  #endif // HAS_FAN
 
   #if HAS_TEMP_HOTEND
 

Marlin/src/lcd/menu/menu_tune.cpp

   // Bed:
   //
   #if HAS_HEATED_BED
-    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAXTEMP - 10, thermalManager.start_watching_bed);
+    EDIT_ITEM_FAST(int3, MSG_BED, &thermalManager.temp_bed.target, 0, BED_MAX_TARGET, thermalManager.start_watching_bed);
   #endif
 
   //
   // Fan Speed:
   //
-  #if FAN_COUNT > 0
+  #if HAS_FAN
 
     auto on_fan_update = []{
       thermalManager.set_fan_speed(MenuItemBase::itemIndex, editable.uint8);
       singlenozzle_item(1);
     #endif
 
-  #endif // FAN_COUNT > 0
+  #endif // HAS_FAN
 
   //
   // Flow:

Marlin/src/lcd/menu/menu_ubl.cpp

 void _lcd_ubl_custom_mesh() {
   START_MENU();
   BACK_ITEM(MSG_UBL_BUILD_MESH_MENU);
-  EDIT_ITEM(int3, MSG_UBL_HOTEND_TEMP_CUSTOM, &custom_hotend_temp, EXTRUDE_MINTEMP, (HEATER_0_MAXTEMP - 10));
+  EDIT_ITEM(int3, MSG_UBL_HOTEND_TEMP_CUSTOM, &custom_hotend_temp, EXTRUDE_MINTEMP, (HEATER_0_MAXTEMP - 15));
   #if HAS_HEATED_BED
-    EDIT_ITEM(int3, MSG_UBL_BED_TEMP_CUSTOM, &custom_bed_temp, BED_MINTEMP, (BED_MAXTEMP - 10));
+    EDIT_ITEM(int3, MSG_UBL_BED_TEMP_CUSTOM, &custom_bed_temp, BED_MINTEMP, BED_MAX_TARGET);
   #endif
   ACTION_ITEM(MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_build_custom_mesh);
   END_MENU();

Marlin/src/module/planner.cpp

     xyze_bool_t axis_active = { false };
   #endif
 
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     uint8_t tail_fan_speed[FAN_COUNT];
   #endif
 
 
   if (has_blocks_queued()) {
 
-    #if FAN_COUNT > 0 || ENABLED(BARICUDA)
+    #if HAS_FAN || ENABLED(BARICUDA)
       block_t *block = &block_buffer[block_buffer_tail];
     #endif
 
-    #if FAN_COUNT > 0
+    #if HAS_FAN
       FANS_LOOP(i)
         tail_fan_speed[i] = thermalManager.scaledFanSpeed(i, block->fan_speed[i]);
     #endif
 
     TERN_(HAS_CUTTER, cutter.refresh());
 
-    #if FAN_COUNT > 0
+    #if HAS_FAN
       FANS_LOOP(i)
         tail_fan_speed[i] = thermalManager.scaledFanSpeed(i);
     #endif
   //
   // Update Fan speeds
   //
-  #if FAN_COUNT > 0
+  #if HAS_FAN
 
     #if FAN_KICKSTART_TIME > 0
       static millis_t fan_kick_end[FAN_COUNT] = { 0 };
     TERN_(HAS_FAN5, FAN_SET(5));
     TERN_(HAS_FAN6, FAN_SET(6));
     TERN_(HAS_FAN7, FAN_SET(7));
-  #endif // FAN_COUNT > 0
+  #endif // HAS_FAN
 
   TERN_(AUTOTEMP, getHighESpeed());
 
 
   TERN_(HAS_CUTTER, block->cutter_power = cutter.power);
 
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     FANS_LOOP(i) block->fan_speed[i] = thermalManager.fan_speed[i];
   #endif
 

Marlin/src/module/planner.h

     cutter_power_t cutter_power;            // Power level for Spindle, Laser, etc.
   #endif
 
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     uint8_t fan_speed[FAN_COUNT];
   #endif
 

Marlin/src/module/temperature.cpp

   uint8_t Temperature::chamberfan_speed; // = 0
 #endif
 
-#if FAN_COUNT > 0
+#if HAS_FAN
 
   uint8_t Temperature::fan_speed[FAN_COUNT]; // = { 0 }
 
 
   #endif
 
-#endif // FAN_COUNT > 0
+#endif // HAS_FAN
 
 #if WATCH_HOTENDS
   hotend_watch_t Temperature::watch_hotend[HOTENDS]; // = { { 0 } }
 
     TERN_(HAS_AUTO_FAN, next_auto_fan_check_ms = next_temp_ms + 2500UL);
 
-    if (target > GHV(BED_MAXTEMP - 10, temp_range[heater].maxtemp - 15)) {
+    if (target > GHV(BED_MAX_TARGET, temp_range[heater].maxtemp - 15)) {
       SERIAL_ECHOLNPGM(STR_PID_TEMP_TOO_HIGH);
       TERN_(EXTENSIBLE_UI, ExtUI::onPidTuning(ExtUI::result_t::PID_TEMP_TOO_HIGH));
       return;

Marlin/src/module/temperature.h

       static float analog_to_celsius_chamber(const int raw);
     #endif
 
-    #if FAN_COUNT > 0
+    #if HAS_FAN
 
       static uint8_t fan_speed[FAN_COUNT];
       #define FANS_LOOP(I) LOOP_L_N(I, FAN_COUNT)
         void set_fans_paused(const bool p);
       #endif
 
-    #endif // FAN_COUNT > 0
+    #endif // HAS_FAN
 
     static inline void zero_fan_speeds() {
-      #if FAN_COUNT > 0
+      #if HAS_FAN
         FANS_LOOP(i) set_fan_speed(i, 0);
       #endif
     }
         TERN_(AUTO_POWER_CONTROL, powerManager.power_on());
         temp_bed.target =
           #ifdef BED_MAXTEMP
-            _MIN(celsius, BED_MAXTEMP - 10)
+            _MIN(celsius, BED_MAX_TARGET)
           #else
             celsius
           #endif

Marlin/src/module/tool_change.cpp

 
 #if ENABLED(SINGLENOZZLE)
   uint16_t singlenozzle_temp[EXTRUDERS];
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     uint8_t singlenozzle_fan_speed[EXTRUDERS];
   #endif
 #endif
     #endif
 
     // Cool down with fan
-    #if TOOLCHANGE_FS_FAN >= 0 && FAN_COUNT > 0
+    #if TOOLCHANGE_FS_FAN >= 0 && HAS_FAN
       const int16_t fansp = thermalManager.fan_speed[TOOLCHANGE_FS_FAN];
       thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = toolchange_settings.fan_speed;
       safe_delay(toolchange_settings.fan_time * 1000);
       if (should_move) {
 
         #if ENABLED(SINGLENOZZLE)
-          #if FAN_COUNT > 0
+          #if HAS_FAN
             singlenozzle_fan_speed[old_tool] = thermalManager.fan_speed[0];
             thermalManager.fan_speed[0] = singlenozzle_fan_speed[new_tool];
           #endif
             #endif
 
             // Cool down with fan
-            #if TOOLCHANGE_FS_FAN >= 0 && FAN_COUNT > 0
+            #if TOOLCHANGE_FS_FAN >= 0 && HAS_FAN
               const int16_t fansp = thermalManager.fan_speed[TOOLCHANGE_FS_FAN];
               thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = toolchange_settings.fan_speed;
               safe_delay(toolchange_settings.fan_time * 1000);

Marlin/src/module/tool_change.h

 
 #if ENABLED(SINGLENOZZLE)
   extern uint16_t singlenozzle_temp[EXTRUDERS];
-  #if FAN_COUNT > 0
+  #if HAS_FAN
     extern uint8_t singlenozzle_fan_speed[EXTRUDERS];
   #endif
 #endif