Merge pull request #6559 from thinkyhead/rc_more_optimal

Compact smart_fill_mesh slightly

Marlin/G26_Mesh_Validation_Tool.cpp

   void set_destination_to_current();
   void set_current_to_destination();
   float code_value_float();
+  float code_value_linear_units();
+  float code_value_axis_units(const AxisEnum axis);
   bool code_value_bool();
   bool code_has_value();
   void lcd_init();
                filament_diameter = FILAMENT,
                prime_length = PRIME_LENGTH,
                x_pos, y_pos,
-               bed_temp = BED_TEMP,
-               hotend_temp = HOTEND_TEMP,
                ooze_amount = OOZE_AMOUNT;
 
+  static int16_t bed_temp = BED_TEMP,
+                 hotend_temp = HOTEND_TEMP;
+
   static int8_t prime_flag = 0;
 
   static bool keep_heaters_on = false;
 
     if (!keep_heaters_on) {
       #if HAS_TEMP_BED
-        thermalManager.setTargetBed(0.0);
+        thermalManager.setTargetBed(0);
       #endif
-      thermalManager.setTargetHotend(0.0, 0);
+      thermalManager.setTargetHotend(0, 0);
     }
   }
 
     keep_heaters_on       = false;
 
     if (code_seen('B')) {
-      bed_temp = code_value_float();
-      if (!WITHIN(bed_temp, 15.0, 140.0)) {
+      bed_temp = code_value_temp_abs();
+      if (!WITHIN(bed_temp, 15, 140)) {
         SERIAL_PROTOCOLLNPGM("?Specified bed temperature not plausible.");
         return UBL_ERR;
       }
     if (code_seen('C')) continue_with_closest++;
 
     if (code_seen('L')) {
-      layer_height = code_value_float();
+      layer_height = code_value_linear_units();
       if (!WITHIN(layer_height, 0.0, 2.0)) {
         SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible.");
         return UBL_ERR;
     if (code_seen('K')) keep_heaters_on++;
 
     if (code_seen('O') && code_has_value())
-      ooze_amount = code_value_float();
+      ooze_amount = code_value_linear_units();
 
     if (code_seen('P')) {
       if (!code_has_value())
         prime_flag = -1;
       else {
         prime_flag++;
-        prime_length = code_value_float();
+        prime_length = code_value_linear_units();
         if (!WITHIN(prime_length, 0.0, 25.0)) {
           SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible.");
           return UBL_ERR;
     }
 
     if (code_seen('F')) {
-      filament_diameter = code_value_float();
+      filament_diameter = code_value_linear_units();
       if (!WITHIN(filament_diameter, 1.0, 4.0)) {
         SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible.");
         return UBL_ERR;
     extrusion_multiplier *= filament_diameter * sq(nozzle) / sq(0.3); // Scale up by nozzle size
 
     if (code_seen('H')) {
-      hotend_temp = code_value_float();
-      if (!WITHIN(hotend_temp, 165.0, 280.0)) {
+      hotend_temp = code_value_temp_abs();
+      if (!WITHIN(hotend_temp, 165, 280)) {
         SERIAL_PROTOCOLLNPGM("?Specified nozzle temperature not plausible.");
         return UBL_ERR;
       }
     y_pos = current_position[Y_AXIS];
 
     if (code_seen('X')) {
-      x_pos = code_value_float();
+      x_pos = code_value_axis_units(X_AXIS);
       if (!WITHIN(x_pos, X_MIN_POS, X_MAX_POS)) {
         SERIAL_PROTOCOLLNPGM("?Specified X coordinate not plausible.");
         return UBL_ERR;
     else
 
     if (code_seen('Y')) {
-      y_pos = code_value_float();
+      y_pos = code_value_axis_units(Y_AXIS);
       if (!WITHIN(y_pos, Y_MIN_POS, Y_MAX_POS)) {
         SERIAL_PROTOCOLLNPGM("?Specified Y coordinate not plausible.");
         return UBL_ERR;

Marlin/M100_Free_Mem_Chk.cpp

   SERIAL_ECHOPAIR("\n__brkval : ", hex_address(__brkval));
   SERIAL_ECHOPAIR("\n__bss_end : ", hex_address(&__bss_end));
 
-  uint8_t *ptr = END_OF_HEAP(), *sp = top_of_stack();
+  char *ptr = END_OF_HEAP(), *sp = top_of_stack();
 
   SERIAL_ECHOPAIR("\nstart of free space : ", hex_address(ptr));
   SERIAL_ECHOLNPAIR("\nStack Pointer : ", hex_address(sp));

Marlin/Marlin.h

 // GCode support for external objects
 bool code_seen(char);
 int code_value_int();
-float code_value_temp_abs();
-float code_value_temp_diff();
+int16_t code_value_temp_abs();
+int16_t code_value_temp_diff();
+
+#if ENABLED(INCH_MODE_SUPPORT)
+  float code_value_linear_units();
+  float code_value_axis_units(const AxisEnum axis);
+  float code_value_per_axis_unit(const AxisEnum axis);
+#else
+  #define code_value_linear_units() code_value_float()
+  #define code_value_axis_units(A) code_value_float()
+  #define code_value_per_axis_unit(A) code_value_float()
+#endif
 
 #if IS_KINEMATIC
   extern float delta[ABC];
 #endif
 
 #if FAN_COUNT > 0
-  extern int fanSpeeds[FAN_COUNT];
+  extern int16_t fanSpeeds[FAN_COUNT];
 #endif
 
 #if ENABLED(BARICUDA)

Marlin/Marlin_main.cpp

       soft_endstop_max[XYZ] = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS };
 
 #if FAN_COUNT > 0
-  int fanSpeeds[FAN_COUNT] = { 0 };
+  int16_t fanSpeeds[FAN_COUNT] = { 0 };
 #endif
 
 // The active extruder (tool). Set with T<extruder> command.
   inline float code_value_linear_units() { return code_value_float() * linear_unit_factor; }
   inline float code_value_axis_units(const AxisEnum axis) { return code_value_float() * axis_unit_factor(axis); }
   inline float code_value_per_axis_unit(const AxisEnum axis) { return code_value_float() / axis_unit_factor(axis); }
-
-#else
-
-  #define code_value_linear_units() code_value_float()
-  #define code_value_axis_units(A) code_value_float()
-  #define code_value_per_axis_unit(A) code_value_float()
-
 #endif
 
 #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
   inline void set_input_temp_units(TempUnit units) { input_temp_units = units; }
 
-  float code_value_temp_abs() {
+  int16_t code_value_temp_abs() {
     switch (input_temp_units) {
-      case TEMPUNIT_C:
-        return code_value_float();
       case TEMPUNIT_F:
         return (code_value_float() - 32) * 0.5555555556;
       case TEMPUNIT_K:
         return code_value_float() - 273.15;
+      case TEMPUNIT_C:
       default:
-        return code_value_float();
+        return code_value_int();
     }
   }
 
-  float code_value_temp_diff() {
+  int16_t code_value_temp_diff() {
     switch (input_temp_units) {
       case TEMPUNIT_C:
       case TEMPUNIT_K:
     }
   }
 #else
-  float code_value_temp_abs() { return code_value_float(); }
-  float code_value_temp_diff() { return code_value_float(); }
+  int16_t code_value_temp_abs() { return code_value_int(); }
+  int16_t code_value_temp_diff() { return code_value_int(); }
 #endif
 
 FORCE_INLINE millis_t code_value_millis() { return code_value_ulong(); }
   static float raised_parked_position[XYZE];         // used in mode 1
   static millis_t delayed_move_time = 0;             // used in mode 1
   static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET; // used in mode 2
-  static float duplicate_extruder_temp_offset = 0;   // used in mode 2
+  static int16_t duplicate_extruder_temp_offset = 0; // used in mode 2
 
 #endif // DUAL_X_CARRIAGE
 
       void set_heaters_for_bltouch(const bool deploy) {
         static bool heaters_were_disabled = false;
         static millis_t next_emi_protection = 0;
-        static float temps_at_entry[HOTENDS];
+        static int16_t temps_at_entry[HOTENDS];
 
         #if HAS_TEMP_BED
-          static float bed_temp_at_entry;
+          static int16_t bed_temp_at_entry;
         #endif
 
         // If called out of order or far apart something is seriously wrong
   /**
    * Extrapolate a single point from its neighbors
    */
-  static void extrapolate_one_point(uint8_t x, uint8_t y, int8_t xdir, int8_t ydir) {
+  static void extrapolate_one_point(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir) {
     #if ENABLED(DEBUG_LEVELING_FEATURE)
       if (DEBUGGING(LEVELING)) {
         SERIAL_ECHOPGM("Extrapolate [");
     SERIAL_EOL;
 
     // Get X neighbors, Y neighbors, and XY neighbors
-    float a1 = z_values[x + xdir][y], a2 = z_values[x + xdir * 2][y],
-          b1 = z_values[x][y + ydir], b2 = z_values[x][y + ydir * 2],
-          c1 = z_values[x + xdir][y + ydir], c2 = z_values[x + xdir * 2][y + ydir * 2];
+    const uint8_t x1 = x + xdir, y1 = y + ydir, x2 = x1 + xdir, y2 = y1 + ydir;
+    float a1 = z_values[x1][y ], a2 = z_values[x2][y ],
+          b1 = z_values[x ][y1], b2 = z_values[x ][y2],
+          c1 = z_values[x1][y1], c2 = z_values[x2][y2];
 
     // Treat far unprobed points as zero, near as equal to far
     if (isnan(a2)) a2 = 0.0; if (isnan(a1)) a1 = a2;
    */
   static void extrapolate_unprobed_bed_level() {
     #ifdef HALF_IN_X
-      const uint8_t ctrx2 = 0, xlen = GRID_MAX_POINTS_X - 1;
+      constexpr uint8_t ctrx2 = 0, xlen = GRID_MAX_POINTS_X - 1;
     #else
-      const uint8_t ctrx1 = (GRID_MAX_POINTS_X - 1) / 2, // left-of-center
-                    ctrx2 = GRID_MAX_POINTS_X / 2,       // right-of-center
-                    xlen = ctrx1;
+      constexpr uint8_t ctrx1 = (GRID_MAX_POINTS_X - 1) / 2, // left-of-center
+                        ctrx2 = (GRID_MAX_POINTS_X) / 2,     // right-of-center
+                        xlen = ctrx1;
     #endif
 
     #ifdef HALF_IN_Y
-      const uint8_t ctry2 = 0, ylen = GRID_MAX_POINTS_Y - 1;
+      constexpr uint8_t ctry2 = 0, ylen = GRID_MAX_POINTS_Y - 1;
     #else
-      const uint8_t ctry1 = (GRID_MAX_POINTS_Y - 1) / 2, // top-of-center
-                    ctry2 = GRID_MAX_POINTS_Y / 2,       // bottom-of-center
-                    ylen = ctry1;
+      constexpr uint8_t ctry1 = (GRID_MAX_POINTS_Y - 1) / 2, // top-of-center
+                        ctry2 = (GRID_MAX_POINTS_Y) / 2,     // bottom-of-center
+                        ylen = ctry1;
     #endif
 
     for (uint8_t xo = 0; xo <= xlen; xo++)
   #endif
 
   if (code_seen('S')) {
-    thermalManager.setTargetHotend(code_value_temp_abs(), target_extruder);
+    const int16_t temp = code_value_temp_abs();
+    thermalManager.setTargetHotend(temp, target_extruder);
     #if ENABLED(DUAL_X_CARRIAGE)
       if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
-        thermalManager.setTargetHotend(code_value_temp_abs() == 0.0 ? 0.0 : code_value_temp_abs() + duplicate_extruder_temp_offset, 1);
+        thermalManager.setTargetHotend(temp ? temp + duplicate_extruder_temp_offset : 0, 1);
     #endif
 
     #if ENABLED(PRINTJOB_TIMER_AUTOSTART)
        * standby mode, for instance in a dual extruder setup, without affecting
        * the running print timer.
        */
-      if (code_value_temp_abs() <= (EXTRUDE_MINTEMP)/2) {
+      if (code_value_temp_abs() <= (EXTRUDE_MINTEMP) / 2) {
         print_job_timer.stop();
         LCD_MESSAGEPGM(WELCOME_MSG);
       }
       SERIAL_PROTOCOLPGM(" /");
       SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(target_extruder), 1);
       #if ENABLED(SHOW_TEMP_ADC_VALUES)
-        SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[target_extruder] / OVERSAMPLENR);
+        SERIAL_PROTOCOLPAIR(" (", thermalManager.rawHotendTemp(target_extruder) / OVERSAMPLENR);
         SERIAL_PROTOCOLCHAR(')');
       #endif
     #endif
       SERIAL_PROTOCOLPGM(" /");
       SERIAL_PROTOCOL_F(thermalManager.degTargetBed(), 1);
       #if ENABLED(SHOW_TEMP_ADC_VALUES)
-        SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_bed_raw / OVERSAMPLENR);
+        SERIAL_PROTOCOLPAIR(" (", thermalManager.rawBedTemp() / OVERSAMPLENR);
         SERIAL_PROTOCOLCHAR(')');
       #endif
     #endif
         SERIAL_PROTOCOLPGM(" /");
         SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(e), 1);
         #if ENABLED(SHOW_TEMP_ADC_VALUES)
-          SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[e] / OVERSAMPLENR);
+          SERIAL_PROTOCOLPAIR(" (", thermalManager.rawHotendTemp(e) / OVERSAMPLENR);
           SERIAL_PROTOCOLCHAR(')');
         #endif
       }
 
   const bool no_wait_for_cooling = code_seen('S');
   if (no_wait_for_cooling || code_seen('R')) {
-    thermalManager.setTargetHotend(code_value_temp_abs(), target_extruder);
+    const int16_t temp = code_value_temp_abs();
+    thermalManager.setTargetHotend(temp, target_extruder);
     #if ENABLED(DUAL_X_CARRIAGE)
       if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
-        thermalManager.setTargetHotend(code_value_temp_abs() == 0.0 ? 0.0 : code_value_temp_abs() + duplicate_extruder_temp_offset, 1);
+        thermalManager.setTargetHotend(temp ? temp + duplicate_extruder_temp_offset : 0, 1);
     #endif
 
     #if ENABLED(PRINTJOB_TIMER_AUTOSTART)
   LOOP_XYZE(i) {
     if (code_seen(axis_codes[i])) {
       if (i == E_AXIS) {
-        const float value = code_value_per_axis_unit(E_AXIS + TARGET_EXTRUDER);
+        const float value = code_value_per_axis_unit((AxisEnum)(E_AXIS + TARGET_EXTRUDER));
         if (value < 20.0) {
           float factor = planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] / value; // increase e constants if M92 E14 is given for netfab.
           planner.max_jerk[E_AXIS] *= factor;
         planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] = value;
       }
       else {
-        planner.axis_steps_per_mm[i] = code_value_per_axis_unit(i);
+        planner.axis_steps_per_mm[i] = code_value_per_axis_unit((AxisEnum)i);
       }
     }
   }
  */
 inline void gcode_M303() {
   #if HAS_PID_HEATING
-    int e = code_seen('E') ? code_value_int() : 0;
-    int c = code_seen('C') ? code_value_int() : 5;
-    bool u = code_seen('U') && code_value_bool();
+    const int e = code_seen('E') ? code_value_int() : 0,
+              c = code_seen('C') ? code_value_int() : 5;
+    const bool u = code_seen('U') && code_value_bool();
 
-    float temp = code_seen('S') ? code_value_temp_abs() : (e < 0 ? 70.0 : 150.0);
+    int16_t temp = code_seen('S') ? code_value_temp_abs() : (e < 0 ? 70 : 150);
 
     if (WITHIN(e, 0, HOTENDS - 1))
       target_extruder = e;
 
     const millis_t nozzle_timeout = millis() + (millis_t)(FILAMENT_CHANGE_NOZZLE_TIMEOUT) * 1000UL;
     bool nozzle_timed_out = false;
-    float temps[4];
 
     // Wait for filament insert by user and press button
     lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_INSERT);
 
     idle();
 
+    int16_t temps[HOTENDS];
     HOTEND_LOOP() temps[e] = thermalManager.target_temperature[e]; // Save nozzle temps
 
     KEEPALIVE_STATE(PAUSED_FOR_USER);

Marlin/planner.cpp

 
     float t = autotemp_min + high * autotemp_factor;
     t = constrain(t, autotemp_min, autotemp_max);
-    if (oldt > t) {
-      t *= (1 - (AUTOTEMP_OLDWEIGHT));
-      t += (AUTOTEMP_OLDWEIGHT) * oldt;
-    }
+    if (t < oldt) t = t * (1 - (AUTOTEMP_OLDWEIGHT)) + oldt * (AUTOTEMP_OLDWEIGHT);
     oldt = t;
     thermalManager.setTargetHotend(t, 0);
   }

Marlin/temperature.cpp

 
 float Temperature::current_temperature[HOTENDS] = { 0.0 },
       Temperature::current_temperature_bed = 0.0;
-int   Temperature::current_temperature_raw[HOTENDS] = { 0 },
-      Temperature::target_temperature[HOTENDS] = { 0 },
-      Temperature::current_temperature_bed_raw = 0,
-      Temperature::target_temperature_bed = 0;
+int16_t Temperature::current_temperature_raw[HOTENDS] = { 0 },
+        Temperature::target_temperature[HOTENDS] = { 0 },
+        Temperature::current_temperature_bed_raw = 0,
+        Temperature::target_temperature_bed = 0;
 
 #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
   float Temperature::redundant_temperature = 0.0;
   millis_t Temperature::next_bed_check_ms;
 #endif
 
-unsigned long Temperature::raw_temp_value[MAX_EXTRUDERS] = { 0 };
-unsigned long Temperature::raw_temp_bed_value = 0;
+uint16_t Temperature::raw_temp_value[MAX_EXTRUDERS] = { 0 },
+         Temperature::raw_temp_bed_value = 0;
 
 // Init min and max temp with extreme values to prevent false errors during startup
-int Temperature::minttemp_raw[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_RAW_LO_TEMP , HEATER_1_RAW_LO_TEMP , HEATER_2_RAW_LO_TEMP, HEATER_3_RAW_LO_TEMP, HEATER_4_RAW_LO_TEMP),
-    Temperature::maxttemp_raw[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_RAW_HI_TEMP , HEATER_1_RAW_HI_TEMP , HEATER_2_RAW_HI_TEMP, HEATER_3_RAW_HI_TEMP, HEATER_4_RAW_HI_TEMP),
-    Temperature::minttemp[HOTENDS] = { 0 },
-    Temperature::maxttemp[HOTENDS] = ARRAY_BY_HOTENDS1(16383);
+int16_t Temperature::minttemp_raw[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_RAW_LO_TEMP , HEATER_1_RAW_LO_TEMP , HEATER_2_RAW_LO_TEMP, HEATER_3_RAW_LO_TEMP, HEATER_4_RAW_LO_TEMP),
+        Temperature::maxttemp_raw[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_RAW_HI_TEMP , HEATER_1_RAW_HI_TEMP , HEATER_2_RAW_HI_TEMP, HEATER_3_RAW_HI_TEMP, HEATER_4_RAW_HI_TEMP),
+        Temperature::minttemp[HOTENDS] = { 0 },
+        Temperature::maxttemp[HOTENDS] = ARRAY_BY_HOTENDS1(16383);
 
 #ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
-  int Temperature::consecutive_low_temperature_error[HOTENDS] = { 0 };
+  uint8_t Temperature::consecutive_low_temperature_error[HOTENDS] = { 0 };
 #endif
 
 #ifdef MILLISECONDS_PREHEAT_TIME
-  unsigned long Temperature::preheat_end_time[HOTENDS] = { 0 };
+  millis_t Temperature::preheat_end_time[HOTENDS] = { 0 };
 #endif
 
 #ifdef BED_MINTEMP
-  int Temperature::bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP;
+  int16_t Temperature::bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP;
 #endif
 
 #ifdef BED_MAXTEMP
-  int Temperature::bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;
+  int16_t Temperature::bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;
 #endif
 
 #if ENABLED(FILAMENT_WIDTH_SENSOR)
-  int Temperature::meas_shift_index;  // Index of a delayed sample in buffer
+  int16_t Temperature::meas_shift_index;  // Index of a delayed sample in buffer
 #endif
 
 #if HAS_AUTO_FAN
     millis_t Temperature::thermal_runaway_bed_timer;
   #endif
 
-  void Temperature::thermal_runaway_protection(Temperature::TRState* state, millis_t* timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc) {
+  void Temperature::thermal_runaway_protection(Temperature::TRState* state, millis_t* timer, float current, float target, int heater_id, int period_seconds, int hysteresis_degc) {
 
     static float tr_target_temperature[HOTENDS + 1] = { 0.0 };
 
         if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHO(heater_id);
         SERIAL_ECHOPAIR(" ;  State:", *state);
         SERIAL_ECHOPAIR(" ;  Timer:", *timer);
-        SERIAL_ECHOPAIR(" ;  Temperature:", temperature);
-        SERIAL_ECHOPAIR(" ;  Target Temp:", target_temperature);
+        SERIAL_ECHOPAIR(" ;  Temperature:", current);
+        SERIAL_ECHOPAIR(" ;  Target Temp:", target);
         SERIAL_EOL;
     */
 
     int heater_index = heater_id >= 0 ? heater_id : HOTENDS;
 
     // If the target temperature changes, restart
-    if (tr_target_temperature[heater_index] != target_temperature) {
-      tr_target_temperature[heater_index] = target_temperature;
-      *state = target_temperature > 0 ? TRFirstHeating : TRInactive;
+    if (tr_target_temperature[heater_index] != target) {
+      tr_target_temperature[heater_index] = target;
+      *state = target > 0 ? TRFirstHeating : TRInactive;
     }
 
     switch (*state) {
       case TRInactive: break;
       // When first heating, wait for the temperature to be reached then go to Stable state
       case TRFirstHeating:
-        if (temperature < tr_target_temperature[heater_index]) break;
+        if (current < tr_target_temperature[heater_index]) break;
         *state = TRStable;
       // While the temperature is stable watch for a bad temperature
       case TRStable:
-        if (temperature >= tr_target_temperature[heater_index] - hysteresis_degc) {
+        if (current >= tr_target_temperature[heater_index] - hysteresis_degc) {
           *timer = millis() + period_seconds * 1000UL;
           break;
         }
     };
 
     for (uint8_t e = 0; e < COUNT(temp_dir); e++) {
-      const int tdir = temp_dir[e], rawtemp = current_temperature_raw[e] * tdir;
-      if (rawtemp > maxttemp_raw[e] * tdir && target_temperature[e] > 0.0f) max_temp_error(e);
-      if (rawtemp < minttemp_raw[e] * tdir && !is_preheating(e) && target_temperature[e] > 0.0f) {
+      const int16_t tdir = temp_dir[e], rawtemp = current_temperature_raw[e] * tdir;
+      if (rawtemp > maxttemp_raw[e] * tdir && target_temperature[e] > 0) max_temp_error(e);
+      if (rawtemp < minttemp_raw[e] * tdir && !is_preheating(e) && target_temperature[e] > 0) {
         #ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
           if (++consecutive_low_temperature_error[e] >= MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED)
         #endif
       #else
         #define GEBED >=
       #endif
-      if (current_temperature_bed_raw GEBED bed_maxttemp_raw && target_temperature_bed > 0.0f) max_temp_error(-1);
-      if (bed_minttemp_raw GEBED current_temperature_bed_raw && target_temperature_bed > 0.0f) min_temp_error(-1);
+      if (current_temperature_bed_raw GEBED bed_maxttemp_raw && target_temperature_bed > 0) max_temp_error(-1);
+      if (bed_minttemp_raw GEBED current_temperature_bed_raw && target_temperature_bed > 0) min_temp_error(-1);
     #endif
 
   } // temp_count >= OVERSAMPLENR

Marlin/temperature.h

 
     static float current_temperature[HOTENDS],
                  current_temperature_bed;
-    static int   current_temperature_raw[HOTENDS],
-                 target_temperature[HOTENDS],
-                 current_temperature_bed_raw,
-                 target_temperature_bed;
+    static int16_t current_temperature_raw[HOTENDS],
+                   target_temperature[HOTENDS],
+                   current_temperature_bed_raw,
+                   target_temperature_bed;
 
     static volatile bool in_temp_isr;
 
       static millis_t next_bed_check_ms;
     #endif
 
-    static unsigned long raw_temp_value[MAX_EXTRUDERS],
-                         raw_temp_bed_value;
+    static uint16_t raw_temp_value[MAX_EXTRUDERS],
+                    raw_temp_bed_value;
 
     // Init min and max temp with extreme values to prevent false errors during startup
-    static int minttemp_raw[HOTENDS],
-               maxttemp_raw[HOTENDS],
-               minttemp[HOTENDS],
-               maxttemp[HOTENDS];
+    static int16_t minttemp_raw[HOTENDS],
+                   maxttemp_raw[HOTENDS],
+                   minttemp[HOTENDS],
+                   maxttemp[HOTENDS];
 
     #ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
-      static int consecutive_low_temperature_error[HOTENDS];
+      static uint8_t consecutive_low_temperature_error[HOTENDS];
     #endif
 
     #ifdef MILLISECONDS_PREHEAT_TIME
-      static unsigned long preheat_end_time[HOTENDS];
+      static millis_t preheat_end_time[HOTENDS];
     #endif
 
     #ifdef BED_MINTEMP
-      static int bed_minttemp_raw;
+      static int16_t bed_minttemp_raw;
     #endif
 
     #ifdef BED_MAXTEMP
-      static int bed_maxttemp_raw;
+      static int16_t bed_maxttemp_raw;
     #endif
 
     #if ENABLED(FILAMENT_WIDTH_SENSOR)
-      static int meas_shift_index;  // Index of a delayed sample in buffer
+      static int16_t meas_shift_index;  // Index of a delayed sample in buffer
     #endif
 
     #if HAS_AUTO_FAN
     //inline so that there is no performance decrease.
     //deg=degreeCelsius
 
-    static float degHotend(uint8_t e) {
+    static int16_t degHotend(uint8_t e) {
       #if HOTENDS == 1
         UNUSED(e);
       #endif
       return current_temperature[HOTEND_INDEX];
     }
-    static float degBed() { return current_temperature_bed; }
+    static int16_t degBed() { return current_temperature_bed; }
 
     #if ENABLED(SHOW_TEMP_ADC_VALUES)
-    static float rawHotendTemp(uint8_t e) {
-      #if HOTENDS == 1
-        UNUSED(e);
-      #endif
-      return current_temperature_raw[HOTEND_INDEX];
-    }
-    static float rawBedTemp() { return current_temperature_bed_raw; }
+      static int16_t rawHotendTemp(uint8_t e) {
+        #if HOTENDS == 1
+          UNUSED(e);
+        #endif
+        return current_temperature_raw[HOTEND_INDEX];
+      }
+      static int16_t rawBedTemp() { return current_temperature_bed_raw; }
     #endif
 
-    static float degTargetHotend(uint8_t e) {
+    static int16_t degTargetHotend(uint8_t e) {
       #if HOTENDS == 1
         UNUSED(e);
       #endif
       return target_temperature[HOTEND_INDEX];
     }
-    static float degTargetBed() { return target_temperature_bed; }
+    static int16_t degTargetBed() { return target_temperature_bed; }
 
     #if WATCH_HOTENDS
       static void start_watching_heater(uint8_t e = 0);
       static void start_watching_bed();
     #endif
 
-    static void setTargetHotend(const float& celsius, uint8_t e) {
+    static void setTargetHotend(const int16_t &celsius, uint8_t e) {
       #if HOTENDS == 1
         UNUSED(e);
       #endif
       #ifdef MILLISECONDS_PREHEAT_TIME
-        if (celsius == 0.0f)
+        if (celsius == 0)
           reset_preheat_time(HOTEND_INDEX);
-        else if (target_temperature[HOTEND_INDEX] == 0.0f)
+        else if (target_temperature[HOTEND_INDEX] == 0)
           start_preheat_time(HOTEND_INDEX);
       #endif
       target_temperature[HOTEND_INDEX] = celsius;
       #endif
     }
 
-    static void setTargetBed(const float& celsius) {
+    static void setTargetBed(const int16_t &celsius) {
       target_temperature_bed = celsius;
       #if WATCH_THE_BED
         start_watching_bed();

Marlin/ubl_G29.cpp

     if (isnan(ubl.z_values[x][y]) && !isnan(ubl.z_values[x1][y1]) && !isnan(ubl.z_values[x2][y2])) {
       if (ubl.z_values[x1][y1] < ubl.z_values[x2][y2])                  // Angled downward?
         ubl.z_values[x][y] = ubl.z_values[x1][y1];                      // Use nearest (maybe a little too high.)
-      else {
-        const float diff = ubl.z_values[x1][y1] - ubl.z_values[x2][y2]; // Angled upward
-        ubl.z_values[x][y] = ubl.z_values[x1][y1] + diff;               // Use closest plus difference
-      }
+      else
+        ubl.z_values[x][y] = 2.0 * ubl.z_values[x1][y1] - ubl.z_values[x2][y2];   // Angled upward...
       return true;
     }
     return false;
 
   typedef struct { uint8_t sx, ex, sy, ey; bool yfirst; } smart_fill_info;
 
-  void smart_fill_loop(const smart_fill_info &f) {
-    if (f.yfirst) {
-      const int8_t dir = f.ex > f.sx ? 1 : -1;
-      for (uint8_t y = f.sy; y != f.ey; ++y)
-        for (uint8_t x = f.sx; x != f.ex; x += dir)
-          if (smart_fill_one(x, y, dir, 0)) break;
-    }
-    else {
-      const int8_t dir = f.ey > f.sy ? 1 : -1;
-       for (uint8_t x = f.sx; x != f.ex; ++x)
-        for (uint8_t y = f.sy; y != f.ey; y += dir)
-          if (smart_fill_one(x, y, 0, dir)) break;
-    }
-  }
-
   void smart_fill_mesh() {
     const smart_fill_info info[] = {
       { 0, GRID_MAX_POINTS_X,      0, GRID_MAX_POINTS_Y - 2,  false },  // Bottom of the mesh looking up
       { 0, GRID_MAX_POINTS_X - 2,  0, GRID_MAX_POINTS_Y,      true  },  // Left side of the mesh looking right
       { GRID_MAX_POINTS_X - 1, 0,  0, GRID_MAX_POINTS_Y,      true  }   // Right side of the mesh looking left
     };
-    for (uint8_t i = 0; i < COUNT(info); ++i) smart_fill_loop(info[i]);
+    for (uint8_t i = 0; i < COUNT(info); ++i) {
+      const smart_fill_info &f = info[i];
+      if (f.yfirst) {
+        const int8_t dir = f.ex > f.sx ? 1 : -1;
+        for (uint8_t y = f.sy; y != f.ey; ++y)
+          for (uint8_t x = f.sx; x != f.ex; x += dir)
+            if (smart_fill_one(x, y, dir, 0)) break;
+      }
+      else {
+        const int8_t dir = f.ey > f.sy ? 1 : -1;
+         for (uint8_t x = f.sx; x != f.ex; ++x)
+          for (uint8_t y = f.sy; y != f.ey; y += dir)
+            if (smart_fill_one(x, y, 0, dir)) break;
+      }
+    }
   }
 
   void unified_bed_leveling::tilt_mesh_based_on_probed_grid(const bool do_ubl_mesh_map) {

Marlin/ultralcd.cpp

     }
   #endif
 
-  constexpr int heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP);
+  constexpr int16_t heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP);
 
   /**
    *
    * "Prepare" submenu items
    *
    */
-  void _lcd_preheat(int endnum, const float temph, const float tempb, const int fan) {
+  void _lcd_preheat(const int endnum, const int16_t temph, const int16_t tempb, const int16_t fan) {
     if (temph > 0) thermalManager.setTargetHotend(min(heater_maxtemp[endnum], temph), endnum);
     #if TEMP_SENSOR_BED != 0
       if (tempb >= 0) thermalManager.setTargetBed(tempb);