Clean up formatting, wrap macros

Marlin/src/HAL/STM32/usb_host.cpp

 }
 
 uint8_t BulkStorage::Write(uint8_t lun, uint32_t addr, uint16_t bsize, uint8_t blocks, const uint8_t * buf) {
-  return USBH_MSC_Write(&hUsbHost, lun, addr, const_cast <uint8_t*>(buf), blocks) != USBH_OK;
+  return USBH_MSC_Write(&hUsbHost, lun, addr, const_cast<uint8_t*>(buf), blocks) != USBH_OK;
 }
 
 #endif // USE_OTG_USB_HOST && USBHOST

Marlin/src/MarlinCore.cpp

   TERN_(HOTEND_IDLE_TIMEOUT, hotend_idle.check());
 
   #if ENABLED(EXTRUDER_RUNOUT_PREVENT)
-    if (thermalManager.degHotend(active_extruder) > EXTRUDER_RUNOUT_MINTEMP
+    if (thermalManager.degHotend(active_extruder) > (EXTRUDER_RUNOUT_MINTEMP)
       && ELAPSED(ms, gcode.previous_move_ms + SEC_TO_MS(EXTRUDER_RUNOUT_SECONDS))
       && !planner.has_blocks_queued()
     ) {

Marlin/src/feature/hotend_idle.cpp

   bool do_prot = false;
   HOTEND_LOOP() {
     const bool busy = (TERN0(HAS_RESUME_CONTINUE, wait_for_user) || planner.has_blocks_queued());
-    if (thermalManager.degHotend(e) >= HOTEND_IDLE_MIN_TRIGGER && !busy) {
+    if (thermalManager.degHotend(e) >= (HOTEND_IDLE_MIN_TRIGGER) && !busy) {
       do_prot = true; break;
     }
   }

Marlin/src/feature/leds/printer_event_leds.h

     static bool leds_off_after_print;
   #endif
 
-  static inline void set_done() {
-    #if ENABLED(LED_COLOR_PRESETS)
-      leds.set_default();
-    #else
-      leds.set_off();
-    #endif
-  }
+  static inline void set_done() { TERN(LED_COLOR_PRESETS, leds.set_default(), leds.set_off()); }
 
 public:
   #if HAS_TEMP_HOTEND

Marlin/src/feature/power.cpp

   if (TERN0(HAS_HEATED_BED, thermalManager.degTargetBed() > 0 || thermalManager.temp_bed.soft_pwm_amount > 0)) return true;
 
   #if HAS_HOTEND && AUTO_POWER_E_TEMP
-    HOTEND_LOOP() if (thermalManager.degHotend(e) >= AUTO_POWER_E_TEMP) return true;
+    HOTEND_LOOP() if (thermalManager.degHotend(e) >= (AUTO_POWER_E_TEMP)) return true;
   #endif
 
   #if HAS_HEATED_CHAMBER && AUTO_POWER_CHAMBER_TEMP
-    if (thermalManager.degChamber() >= AUTO_POWER_CHAMBER_TEMP) return true;
+    if (thermalManager.degChamber() >= (AUTO_POWER_CHAMBER_TEMP)) return true;
   #endif
 
   #if HAS_COOLER && AUTO_POWER_COOLER_TEMP
-    if (thermalManager.degCooler() >= AUTO_POWER_COOLER_TEMP) return true;
+    if (thermalManager.degCooler() >= (AUTO_POWER_COOLER_TEMP)) return true;
   #endif
 
   return false;

Marlin/src/feature/probe_temp_comp.cpp

   // Linear interpolation
   uint8_t idx = static_cast<uint8_t>((temp - start_temp) / res_temp);
 
-  // offset in um
+  // offset in µm
   float offset = 0.0f;
 
   #if !defined(PTC_LINEAR_EXTRAPOLATION) || PTC_LINEAR_EXTRAPOLATION <= 0

Marlin/src/feature/probe_temp_comp.h

 #endif
 
 static constexpr temp_calib_t cali_info_init[TSI_COUNT] = {
-    {  PTC_SAMPLE_COUNT, PTC_SAMPLE_RES, PTC_SAMPLE_START, PTC_SAMPLE_END },       // Probe
-    {  BTC_SAMPLE_COUNT, BTC_SAMPLE_RES, BTC_SAMPLE_START, BTC_SAMPLE_END },       // Bed
+  { PTC_SAMPLE_COUNT, PTC_SAMPLE_RES, PTC_SAMPLE_START, PTC_SAMPLE_END }, // Probe
+  { BTC_SAMPLE_COUNT, BTC_SAMPLE_RES, BTC_SAMPLE_START, BTC_SAMPLE_END }, // Bed
   #if ENABLED(USE_TEMP_EXT_COMPENSATION)
-    {  20,  5, 180, 180 +  5 * 20 }        // Extruder
+    { 20,  5, 180, 180 +  5 * 20 }                                        // Extruder
   #endif
 };
 

Marlin/src/gcode/calibrate/G76_M192_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_MAX_TARGET) break;
+      if (isnan(measured_z) || target_bed > (BED_MAX_TARGET)) break;
     }
 
     SERIAL_ECHOLNPAIR("Retrieved measurements: ", temp_comp.get_index());

Marlin/src/lcd/extui/lib/anycubic_chiron/chiron_tft.cpp

 
       if (!isPrinting()) { // Ignore request if printing
         char MoveCmnd[30];
-        sprintf_P(MoveCmnd, PSTR("G91\nG0 %s \nG90"), panel_command+3);
+        sprintf_P(MoveCmnd, PSTR("G91\nG0%s\nG90"), panel_command + 3);
         #if ACDEBUG(AC_ACTION)
           SERIAL_ECHOLNPAIR("Move: ", MoveCmnd);
         #endif

Marlin/src/lcd/extui/lib/anycubic_i3mega/anycubic_i3mega_lcd.cpp

             unsigned int tempvalue;
             if (CodeSeen('S')) {
               tempvalue = constrain(CodeValue(), 0, 275);
-              setTargetTemp_celsius(tempvalue, (extruder_t) E0);
+              setTargetTemp_celsius(tempvalue, (extruder_t)E0);
             }
             else if (CodeSeen('C') && !isPrinting()) {
               if (getAxisPosition_mm(Z) < 10)
                 injectCommands_P(PSTR("G1 Z10")); // RASE Z AXIS
               tempvalue = constrain(CodeValue(), 0, 275);
-              setTargetTemp_celsius(tempvalue, (extruder_t) E0);
+              setTargetTemp_celsius(tempvalue, (extruder_t)E0);
             }
           }
           break;
               if (getAxisPosition_mm(Z) < 10)
                 injectCommands_P(PSTR("G1 Z10")); // RASE Z AXIS
 
-              setTargetTemp_celsius(PREHEAT_1_TEMP_BED, (heater_t) BED);
-              setTargetTemp_celsius(PREHEAT_1_TEMP_HOTEND, (extruder_t) E0);
+              setTargetTemp_celsius(PREHEAT_1_TEMP_BED, (heater_t)BED);
+              setTargetTemp_celsius(PREHEAT_1_TEMP_HOTEND, (extruder_t)E0);
               SENDLINE_PGM("OK");
             }
             break;
               if (getAxisPosition_mm(Z) < 10)
                 injectCommands_P(PSTR("G1 Z10")); // RASE Z AXIS
 
-              setTargetTemp_celsius(PREHEAT_2_TEMP_BED, (heater_t) BED);
-              setTargetTemp_celsius(PREHEAT_2_TEMP_HOTEND, (extruder_t) E0);
+              setTargetTemp_celsius(PREHEAT_2_TEMP_BED, (heater_t)BED);
+              setTargetTemp_celsius(PREHEAT_2_TEMP_HOTEND, (extruder_t)E0);
               SENDLINE_PGM("OK");
             }
             break;

Marlin/src/lcd/extui/lib/mks_ui/draw_printing.cpp

 }
 
 void disp_fan_speed() {
-  sprintf_P(public_buf_l, PSTR("%d%%"), thermalManager.fanSpeedPercent(0));
+  sprintf_P(public_buf_l, PSTR("%d%%"), (int)thermalManager.fanSpeedPercent(0));
   lv_label_set_text(labelFan, public_buf_l);
 }
 

Marlin/src/lcd/extui/malyan_lcd.cpp

         #else
           0, 0,
         #endif
-        #if ENABLED(SDSUPPORT)
-          done_pct,
-        #else
-          0,
-        #endif
+        TERN(SDSUPPORT, done_pct, 0),
         elapsed_buffer
       );
       write_to_lcd(message_buffer);

Marlin/src/lcd/extui/ui_api.cpp

   }
 
   float getTargetFan_percent(const fan_t fan) {
-    #if HAS_FAN
-      return thermalManager.fanSpeedPercent(fan - FAN0);
-    #else
-      UNUSED(fan);
-      return 0;
-    #endif
+    UNUSED(fan);
+    return TERN0(HAS_FAN, thermalManager.fanSpeedPercent(fan - FAN0));
   }
 
   float getActualFan_percent(const fan_t fan) {
-    #if HAS_FAN
-      return thermalManager.scaledFanSpeedPercent(fan - FAN0);
-    #else
-      UNUSED(fan);
-      return 0;
-    #endif
+    UNUSED(fan);
+    return TERN0(HAS_FAN, thermalManager.scaledFanSpeedPercent(fan - FAN0));
   }
 
   float getAxisPosition_mm(const axis_t axis) {

Marlin/src/lcd/extui/ui_api.h

   #if HAS_TRINAMIC_CONFIG
     float getAxisCurrent_mA(const axis_t);
     float getAxisCurrent_mA(const extruder_t);
-    void  setAxisCurrent_mA(const_float_t , const axis_t);
-    void  setAxisCurrent_mA(const_float_t , const extruder_t);
+    void  setAxisCurrent_mA(const_float_t, const axis_t);
+    void  setAxisCurrent_mA(const_float_t, const extruder_t);
 
      int getTMCBumpSensitivity(const axis_t);
-    void setTMCBumpSensitivity(const_float_t , const axis_t);
+    void setTMCBumpSensitivity(const_float_t, const axis_t);
   #endif
 
   celsius_float_t getActualTemp_celsius(const heater_t);
     char* getFilamentUsed_str(char buffer[21]);
   #endif
 
-  void setTargetTemp_celsius(const_float_t , const heater_t);
-  void setTargetTemp_celsius(const_float_t , const extruder_t);
-  void setTargetFan_percent(const_float_t , const fan_t);
+  void setTargetTemp_celsius(const_float_t, const heater_t);
+  void setTargetTemp_celsius(const_float_t, const extruder_t);
+  void setTargetFan_percent(const_float_t, const fan_t);
   void coolDown();
-  void setAxisPosition_mm(const_float_t , const axis_t, const feedRate_t=0);
-  void setAxisPosition_mm(const_float_t , const extruder_t, const feedRate_t=0);
-  void setAxisSteps_per_mm(const_float_t , const axis_t);
-  void setAxisSteps_per_mm(const_float_t , const extruder_t);
+  void setAxisPosition_mm(const_float_t, const axis_t, const feedRate_t=0);
+  void setAxisPosition_mm(const_float_t, const extruder_t, const feedRate_t=0);
+  void setAxisSteps_per_mm(const_float_t, const axis_t);
+  void setAxisSteps_per_mm(const_float_t, const extruder_t);
   void setAxisMaxFeedrate_mm_s(const feedRate_t, const axis_t);
   void setAxisMaxFeedrate_mm_s(const feedRate_t, const extruder_t);
-  void setAxisMaxAcceleration_mm_s2(const_float_t , const axis_t);
-  void setAxisMaxAcceleration_mm_s2(const_float_t , const extruder_t);
+  void setAxisMaxAcceleration_mm_s2(const_float_t, const axis_t);
+  void setAxisMaxAcceleration_mm_s2(const_float_t, const extruder_t);
   void setFeedrate_mm_s(const feedRate_t);
   void setMinFeedrate_mm_s(const feedRate_t);
   void setMinTravelFeedrate_mm_s(const feedRate_t);
 
   #if ENABLED(LIN_ADVANCE)
     float getLinearAdvance_mm_mm_s(const extruder_t);
-    void setLinearAdvance_mm_mm_s(const_float_t , const extruder_t);
+    void setLinearAdvance_mm_mm_s(const_float_t, const extruder_t);
   #endif
 
   #if HAS_JUNCTION_DEVIATION
   #else
     float getAxisMaxJerk_mm_s(const axis_t);
     float getAxisMaxJerk_mm_s(const extruder_t);
-    void setAxisMaxJerk_mm_s(const_float_t , const axis_t);
-    void setAxisMaxJerk_mm_s(const_float_t , const extruder_t);
+    void setAxisMaxJerk_mm_s(const_float_t, const axis_t);
+    void setAxisMaxJerk_mm_s(const_float_t, const extruder_t);
   #endif
 
   extruder_t getTool(const uint8_t extruder);
 
   #if HAS_HOTEND_OFFSET
     float getNozzleOffset_mm(const axis_t, const extruder_t);
-    void setNozzleOffset_mm(const_float_t , const axis_t, const extruder_t);
+    void setNozzleOffset_mm(const_float_t, const axis_t, const extruder_t);
     void normalizeNozzleOffset(const axis_t axis);
   #endif
 
 
   #if HAS_BED_PROBE
     float getProbeOffset_mm(const axis_t);
-    void setProbeOffset_mm(const_float_t , const axis_t);
+    void setProbeOffset_mm(const_float_t, const axis_t);
   #endif
 
   #if ENABLED(BACKLASH_GCODE)
     float getAxisBacklash_mm(const axis_t);
-    void setAxisBacklash_mm(const_float_t , const axis_t);
+    void setAxisBacklash_mm(const_float_t, const axis_t);
 
     float getBacklashCorrection_percent();
     void setBacklashCorrection_percent(const_float_t );
     float getPIDValues_Kp(const extruder_t);
     float getPIDValues_Ki(const extruder_t);
     float getPIDValues_Kd(const extruder_t);
-    void setPIDValues(const_float_t , const_float_t , const_float_t , extruder_t);
-    void startPIDTune(const_float_t , extruder_t);
+    void setPIDValues(const_float_t, const_float_t , const_float_t , extruder_t);
+    void startPIDTune(const_float_t, extruder_t);
   #endif
 
   #if ENABLED(PIDTEMPBED)
     float getBedPIDValues_Kp();
     float getBedPIDValues_Ki();
     float getBedPIDValues_Kd();
-    void setBedPIDValues(const_float_t , const_float_t , const_float_t );
+    void setBedPIDValues(const_float_t, const_float_t , const_float_t );
     void startBedPIDTune(const_float_t );
   #endif
 

Marlin/src/module/temperature.cpp

     SHV(bias);
 
     #if ENABLED(PRINTER_EVENT_LEDS)
-      const celsius_float_t start_temp = GHV(temp_chamber.celsius, temp_bed.celsius, temp_hotend[heater_id].celsius);
+      const celsius_float_t start_temp = GHV(degChamber(), degBed(), degHotend(heater_id));
       LEDColor color = ONHEATINGSTART();
     #endif
 
         updateTemperaturesFromRawValues();
 
         // Get the current temperature and constrain it
-        current_temp = GHV(temp_chamber.celsius, temp_bed.celsius, temp_hotend[heater_id].celsius);
+        current_temp = GHV(degChamber(), degBed(), degHotend(heater_id));
         NOLESS(maxT, current_temp);
         NOMORE(minT, current_temp);
 

Marlin/src/module/tool_change.cpp

         first_tool_is_primed = true;
         TERN_(TOOLCHANGE_FS_INIT_BEFORE_SWAP, toolchange_extruder_ready[old_tool] = true); // Primed and initialized
       }
-    #else
-      constexpr bool first_tool_is_primed = true;
     #endif
 
     if (new_tool != old_tool || TERN0(PARKING_EXTRUDER, extruder_parked)) { // PARKING_EXTRUDER may need to attach old_tool when homing
           }
           else {
             // For first new tool, change without unloading the old. 'Just prime/init the new'
-            if (first_tool_is_primed)
+            if (TERN1(TOOLCHANGE_FS_PRIME_FIRST_USED, first_tool_is_primed))
               unscaled_e_move(-toolchange_settings.swap_length, MMM_TO_MMS(toolchange_settings.retract_speed));
             TERN_(TOOLCHANGE_FS_PRIME_FIRST_USED, first_tool_is_primed = true); // The first new tool will be primed by toolchanging
           }