Keep smaller option

Author: thinkyhead

Marlin/Configuration.h

@@ -686,7 +686,8 @@
  * @section mpctemp
  */
 #if ENABLED(MPCTEMP)
-  //#define MPC_AUTOTUNE                              // Include a method to do MPC auto-tuning (~7120 bytes of flash)
+  //#define MPC_AUTOTUNE                              // Include a method to do MPC auto-tuning (~5664-5882 bytes of flash)
+  //#define MPC_AUTOTUNE_FANCY                        // Include a fancier method to do MPC auto-tuning (~7120 bytes of flash)
   //#define MPC_EDIT_MENU                             // Add MPC editing to the "Advanced Settings" menu. (~1300 bytes of flash)
   //#define MPC_AUTOTUNE_MENU                         // Add MPC auto-tuning to the "Advanced Settings" menu. (~350 bytes of flash)
 

Marlin/src/gcode/temp/M306.cpp

@@ -43,6 +43,8 @@
  *
  *  With MPC_AUTOTUNE:
  *  T                         Autotune the extruder specified with 'E' or the active extruder.
+ *
+ *  With MPC_AUTOTUNE_FANCY:
  *                            S0 : Autotuning method AUTO (default)
  *                            S1 : Autotuning method DIFFERENTIAL
  *                            S2 : Autotuning method ASYMPTOTIC
@@ -55,23 +57,26 @@ void GcodeSuite::M306() {
     return;
   }
 
-  if (parser.seen_test('T')) {
-    #if ENABLED(MPC_AUTOTUNE)
-      Temperature::MPCTuningType tuning_type;
-      const uint8_t type = parser.byteval('S', 0);
-      switch (type) {
-        case 1: tuning_type = Temperature::MPCTuningType::FORCE_DIFFERENTIAL; break;
-        case 2: tuning_type = Temperature::MPCTuningType::FORCE_ASYMPTOTIC; break;
-        default: tuning_type = Temperature::MPCTuningType::AUTO; break;
-      }
-      LCD_MESSAGE(MSG_MPC_AUTOTUNE);
-      thermalManager.MPC_autotune(e, tuning_type);
+  #if EITHER(MPC_AUTOTUNE, MPC_AUTOTUNE_FANCY)
+    if (parser.seen_test('T')) {
+      #if ENABLED(MPC_AUTOTUNE_FANCY)
+        Temperature::MPCTuningType tuning_type;
+        const uint8_t type = parser.byteval('S', 0);
+        switch (type) {
+          case 1: tuning_type = Temperature::MPCTuningType::FORCE_DIFFERENTIAL; break;
+          case 2: tuning_type = Temperature::MPCTuningType::FORCE_ASYMPTOTIC; break;
+          default: tuning_type = Temperature::MPCTuningType::AUTO; break;
+        }
+        LCD_MESSAGE(MSG_MPC_AUTOTUNE);
+        thermalManager.MPC_autotune(e, tuning_type);
+      #else
+        LCD_MESSAGE(MSG_MPC_AUTOTUNE);
+        thermalManager.MPC_autotune(e);
+      #endif
       ui.reset_status();
-    #else
-      SERIAL_ECHOLNPGM("M306 T requires MPC_AUTOTUNE.");
-    #endif
-    return;
-  }
+      return;
+    }
+  #endif
 
   if (parser.seen("ACFPRH")) {
     MPC_t &mpc = thermalManager.temp_hotend[e].mpc;

Marlin/src/inc/SanityCheck.h

@@ -976,9 +976,14 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
   #error "Only enable PIDTEMP or MPCTEMP, but not both."
   #undef MPCTEMP
   #undef MPC_AUTOTUNE
+  #undef MPC_AUTOTUNE_FANCY
   #undef MPC_EDIT_MENU
   #undef MPC_AUTOTUNE_MENU
 #endif
+#if BOTH(MPC_AUTOTUNE, MPC_AUTOTUNE_FANCY)
+  #error "Only enable MPC_AUTOTUNE or MPC_AUTOTUNE_FANCY, but not both."
+  #undef MPC_AUTOTUNE_FANCY
+#endif
 
 #if ENABLED(MPC_INCLUDE_FAN)
   #if !HAS_FAN

Marlin/src/module/temperature.cpp

@@ -938,7 +938,7 @@ volatile bool Temperature::raw_temps_ready = false;
 
 #endif // HAS_PID_HEATING
 
-#if ENABLED(MPC_AUTOTUNE)
+#if ENABLED(MPC_AUTOTUNE_FANCY)
 
   #if EITHER(MPC_FAN_0_ALL_HOTENDS, MPC_FAN_0_ACTIVE_HOTEND)
     #define SINGLEFAN 1
@@ -1041,7 +1041,8 @@ volatile bool Temperature::raw_temps_ready = false;
 
           next_test_time_ms += test_interval_ms;
 
-        } else if (current_temp < 200.0f) {
+        }
+        else if (current_temp < 200.0f) {
           // Second regime (after 100deg) measure 3 points to determine asymptotic temperature
 
           // If there are too many samples, space them more widely
@@ -1059,7 +1060,8 @@ volatile bool Temperature::raw_temps_ready = false;
 
           next_test_time_ms += test_interval_ms * sample_distance;
 
-        } else {
+        }
+        else {
           // Third regime (after 200deg) finished gathering data so finish
           break;
         }
@@ -1302,6 +1304,249 @@ volatile bool Temperature::raw_temps_ready = false;
     TERN_(HAS_FAN, SERIAL_ECHOLNPAIR_F("MPC_AMBIENT_XFER_COEFF_FAN255 ", ambient_xfer_coeff_fan255, 4));
   }
 
+#elif ENABLED(MPC_AUTOTUNE)
+
+  #if EITHER(MPC_FAN_0_ALL_HOTENDS, MPC_FAN_0_ACTIVE_HOTEND)
+    #define SINGLEFAN 1
+  #endif
+
+  void Temperature::MPC_autotune(const uint8_t e) {
+    auto housekeeping = [] (millis_t &ms, const uint8_t e, celsius_float_t &current_temp, millis_t &next_report_ms) {
+      ms = millis();
+
+      if (updateTemperaturesIfReady()) { // temp sample ready
+        current_temp = degHotend(e);
+        TERN_(HAS_FAN_LOGIC, manage_extruder_fans(ms));
+      }
+
+      if (ELAPSED(ms, next_report_ms)) {
+        next_report_ms += 1000UL;
+
+        print_heater_states(e);
+        SERIAL_EOL();
+      }
+
+      hal.idletask();
+      TERN(DWIN_CREALITY_LCD, DWIN_Update(), ui.update());
+
+      if (!wait_for_heatup) {
+        SERIAL_ECHOLNPGM(STR_MPC_AUTOTUNE_INTERRUPTED);
+        TERN_(DWIN_LCD_PROUI, DWIN_MPCTuning(MPC_INTERRUPTED));
+        return true;
+      }
+
+      return false;
+    };
+
+    struct OnExit {
+      uint8_t e;
+      OnExit(const uint8_t _e) { this->e = _e; }
+      ~OnExit() {
+        wait_for_heatup = false;
+
+        ui.reset_status();
+
+        temp_hotend[e].target = 0.0f;
+        temp_hotend[e].soft_pwm_amount = 0;
+        #if HAS_FAN
+          set_fan_speed(TERN(SINGLEFAN, 0, e), 0);
+          planner.sync_fan_speeds(fan_speed);
+        #endif
+
+        do_z_clearance(MPC_TUNING_END_Z, false);
+
+        TERN_(TEMP_TUNING_MAINTAIN_FAN, adaptive_fan_slowing = true);
+      }
+    } on_exit(e);
+
+    SERIAL_ECHOLNPGM(STR_MPC_AUTOTUNE_START, e);
+    MPCHeaterInfo &hotend = temp_hotend[e];
+    MPC_t &mpc = hotend.mpc;
+
+    TERN_(TEMP_TUNING_MAINTAIN_FAN, adaptive_fan_slowing = false);
+
+    // Move to center of bed, just above bed height and cool with max fan
+    gcode.home_all_axes(true);
+    disable_all_heaters();
+    #if HAS_FAN
+      zero_fan_speeds();
+      set_fan_speed(TERN(SINGLEFAN, 0, e), 255);
+      planner.sync_fan_speeds(fan_speed);
+    #endif
+    do_blocking_move_to(xyz_pos_t(MPC_TUNING_POS));
+
+    SERIAL_ECHOLNPGM(STR_MPC_COOLING_TO_AMBIENT);
+    #if ENABLED(DWIN_LCD_PROUI)
+      DWIN_MPCTuning(MPCTEMP_START);
+      LCD_ALERTMESSAGE(MSG_MPC_COOLING_TO_AMBIENT);
+    #else
+      LCD_MESSAGE(MSG_COOLING);
+    #endif
+
+    millis_t ms = millis(), next_report_ms = ms, next_test_ms = ms + 10000UL;
+    celsius_float_t current_temp = degHotend(e),
+                    ambient_temp = current_temp;
+
+    wait_for_heatup = true;
+    for (;;) { // Can be interrupted with M108
+      if (housekeeping(ms, e, current_temp, next_report_ms)) return;
+
+      if (ELAPSED(ms, next_test_ms)) {
+        if (current_temp >= ambient_temp) {
+          ambient_temp = (ambient_temp + current_temp) / 2.0f;
+          break;
+        }
+        ambient_temp = current_temp;
+        next_test_ms += 10000UL;
+      }
+    }
+    wait_for_heatup = false;
+
+    #if HAS_FAN
+      set_fan_speed(TERN(SINGLEFAN, 0, e), 0);
+      planner.sync_fan_speeds(fan_speed);
+    #endif
+
+    hotend.modeled_ambient_temp = ambient_temp;
+
+    SERIAL_ECHOLNPGM(STR_MPC_HEATING_PAST_200);
+    TERN(DWIN_LCD_PROUI, LCD_ALERTMESSAGE(MSG_MPC_HEATING_PAST_200), LCD_MESSAGE(MSG_HEATING));
+    hotend.target = 200.0f;   // So M105 looks nice
+    hotend.soft_pwm_amount = (MPC_MAX) >> 1;
+    const millis_t heat_start_time = next_test_ms = ms;
+    celsius_float_t temp_samples[16];
+    uint8_t sample_count = 0;
+    uint16_t sample_distance = 1;
+    float t1_time = 0;
+
+    wait_for_heatup = true;
+    for (;;) { // Can be interrupted with M108
+      if (housekeeping(ms, e, current_temp, next_report_ms)) return;
+
+      if (ELAPSED(ms, next_test_ms)) {
+        // Record samples between 100C and 200C
+        if (current_temp >= 100.0f) {
+          // If there are too many samples, space them more widely
+          if (sample_count == COUNT(temp_samples)) {
+            for (uint8_t i = 0; i < COUNT(temp_samples) / 2; i++)
+              temp_samples[i] = temp_samples[i*2];
+            sample_count /= 2;
+            sample_distance *= 2;
+          }
+
+          if (sample_count == 0) t1_time = float(ms - heat_start_time) / 1000.0f;
+          temp_samples[sample_count++] = current_temp;
+        }
+
+        if (current_temp >= 200.0f) break;
+
+        next_test_ms += 1000UL * sample_distance;
+      }
+    }
+    wait_for_heatup = false;
+
+    hotend.soft_pwm_amount = 0;
+
+    // Calculate physical constants from three equally-spaced samples
+    sample_count = (sample_count + 1) / 2 * 2 - 1;
+    const float t1 = temp_samples[0],
+                t2 = temp_samples[(sample_count - 1) >> 1],
+                t3 = temp_samples[sample_count - 1];
+    float asymp_temp = (t2 * t2 - t1 * t3) / (2 * t2 - t1 - t3),
+          block_responsiveness = -log((t2 - asymp_temp) / (t1 - asymp_temp)) / (sample_distance * (sample_count >> 1));
+
+    mpc.ambient_xfer_coeff_fan0 = mpc.heater_power * (MPC_MAX) / 255 / (asymp_temp - ambient_temp);
+    mpc.block_heat_capacity = mpc.ambient_xfer_coeff_fan0 / block_responsiveness;
+    mpc.sensor_responsiveness = block_responsiveness / (1.0f - (ambient_temp - asymp_temp) * exp(-block_responsiveness * t1_time) / (t1 - asymp_temp));
+    TERN_(MPC_INCLUDE_FAN, mpc.fan255_adjustment = 0.0f);
+
+    hotend.modeled_block_temp = asymp_temp + (ambient_temp - asymp_temp) * exp(-block_responsiveness * (ms - heat_start_time) / 1000.0f);
+    hotend.modeled_sensor_temp = current_temp;
+
+    // Allow the system to stabilize under MPC, then get a better measure of ambient loss with and without fan
+    SERIAL_ECHOLNPGM(STR_MPC_MEASURING_AMBIENT, hotend.modeled_block_temp);
+    TERN(DWIN_LCD_PROUI, LCD_ALERTMESSAGE(MSG_MPC_MEASURING_AMBIENT), LCD_MESSAGE(MSG_MPC_MEASURING_AMBIENT));
+    hotend.target = hotend.modeled_block_temp;
+    next_test_ms = ms + MPC_dT * 1000;
+    constexpr millis_t settle_time = 20000UL, test_duration = 20000UL;
+    millis_t settle_end_ms = ms + settle_time,
+             test_end_ms = settle_end_ms + test_duration;
+    float total_energy_fan0 = 0.0f;
+    #if HAS_FAN
+      bool fan0_done = false;
+      float total_energy_fan255 = 0.0f;
+    #endif
+    float last_temp = current_temp;
+
+    wait_for_heatup = true;
+    for (;;) { // Can be interrupted with M108
+      if (housekeeping(ms, e, current_temp, next_report_ms)) return;
+
+      if (ELAPSED(ms, next_test_ms)) {
+        hotend.soft_pwm_amount = (int)get_pid_output_hotend(e) >> 1;
+
+        if (ELAPSED(ms, settle_end_ms) && !ELAPSED(ms, test_end_ms) && TERN1(HAS_FAN, !fan0_done))
+          total_energy_fan0 += mpc.heater_power * hotend.soft_pwm_amount / 127 * MPC_dT + (last_temp - current_temp) * mpc.block_heat_capacity;
+        #if HAS_FAN
+          else if (ELAPSED(ms, test_end_ms) && !fan0_done) {
+            set_fan_speed(TERN(SINGLEFAN, 0, e), 255);
+            planner.sync_fan_speeds(fan_speed);
+            settle_end_ms = ms + settle_time;
+            test_end_ms = settle_end_ms + test_duration;
+            fan0_done = true;
+          }
+          else if (ELAPSED(ms, settle_end_ms) && !ELAPSED(ms, test_end_ms))
+            total_energy_fan255 += mpc.heater_power * hotend.soft_pwm_amount / 127 * MPC_dT + (last_temp - current_temp) * mpc.block_heat_capacity;
+        #endif
+        else if (ELAPSED(ms, test_end_ms)) break;
+
+        last_temp = current_temp;
+        next_test_ms += MPC_dT * 1000;
+      }
+
+      if (!WITHIN(current_temp, t3 - 15.0f, hotend.target + 15.0f)) {
+        SERIAL_ECHOLNPGM(STR_MPC_TEMPERATURE_ERROR);
+        TERN_(DWIN_LCD_PROUI, DWIN_MPCTuning(MPC_TEMP_ERROR));
+        break;
+      }
+    }
+    wait_for_heatup = false;
+
+    const float power_fan0 = total_energy_fan0 * 1000 / test_duration;
+    mpc.ambient_xfer_coeff_fan0 = power_fan0 / (hotend.target - ambient_temp);
+
+    #if HAS_FAN
+      const float power_fan255 = total_energy_fan255 * 1000 / test_duration,
+                  ambient_xfer_coeff_fan255 = power_fan255 / (hotend.target - ambient_temp);
+      mpc.applyFanAdjustment(ambient_xfer_coeff_fan255);
+    #endif
+
+    // Calculate a new and better asymptotic temperature and re-evaluate the other constants
+    asymp_temp = ambient_temp + mpc.heater_power * (MPC_MAX) / 255 / mpc.ambient_xfer_coeff_fan0;
+    block_responsiveness = -log((t2 - asymp_temp) / (t1 - asymp_temp)) / (sample_distance * (sample_count >> 1));
+    mpc.block_heat_capacity = mpc.ambient_xfer_coeff_fan0 / block_responsiveness;
+    mpc.sensor_responsiveness = block_responsiveness / (1.0f - (ambient_temp - asymp_temp) * exp(-block_responsiveness * t1_time) / (t1 - asymp_temp));
+
+    SERIAL_ECHOLNPGM(STR_MPC_AUTOTUNE_FINISHED);
+    TERN_(DWIN_LCD_PROUI, DWIN_MPCTuning(MPC_DONE));
+
+    #if 0
+      SERIAL_ECHOLNPGM("t1_time ", t1_time);
+      SERIAL_ECHOLNPGM("sample_count ", sample_count);
+      SERIAL_ECHOLNPGM("sample_distance ", sample_distance);
+      for (uint8_t i = 0; i < sample_count; i++)
+        SERIAL_ECHOLNPGM("sample ", i, " : ", temp_samples[i]);
+      SERIAL_ECHOLNPGM("t1 ", t1, " t2 ", t2, " t3 ", t3);
+      SERIAL_ECHOLNPGM("asymp_temp ", asymp_temp);
+      SERIAL_ECHOLNPAIR_F("block_responsiveness ", block_responsiveness, 4);
+    #endif
+
+    SERIAL_ECHOLNPGM("MPC_BLOCK_HEAT_CAPACITY ", mpc.block_heat_capacity);
+    SERIAL_ECHOLNPAIR_F("MPC_SENSOR_RESPONSIVENESS ", mpc.sensor_responsiveness, 4);
+    SERIAL_ECHOLNPAIR_F("MPC_AMBIENT_XFER_COEFF ", mpc.ambient_xfer_coeff_fan0, 4);
+    TERN_(HAS_FAN, SERIAL_ECHOLNPAIR_F("MPC_AMBIENT_XFER_COEFF_FAN255 ", ambient_xfer_coeff_fan255, 4));
+  }
+
 #endif // MPC_AUTOTUNE
 
 int16_t Temperature::getHeaterPower(const heater_id_t heater_id) {

Marlin/src/module/temperature.h

@@ -1217,7 +1217,8 @@ class Temperature {
 
     #endif // HAS_PID_HEATING
 
-    #if ENABLED(MPC_AUTOTUNE)
+    #if ENABLED(MPC_AUTOTUNE_FANCY)
+
       // Utility class to perform MPCTEMP auto tuning measurements
       class MPC_autotuner {
         public:
@@ -1274,7 +1275,11 @@ class Temperature {
       enum MPCTuningType { AUTO, FORCE_ASYMPTOTIC, FORCE_DIFFERENTIAL };
       static void MPC_autotune(const uint8_t e, MPCTuningType tuning_type);
 
-    #endif // MPC_AUTOTUNE
+    #elif ENABLED(MPC_AUTOTUNE)
+
+      void MPC_autotune(const uint8_t e);
+
+    #endif
 
     #if ENABLED(PROBING_HEATERS_OFF)
       static void pause_heaters(const bool p);

buildroot/tests/STM32F103RE_creality

@@ -20,7 +20,7 @@ exec_test $1 $2 "Ender-3 v2 - JyersUI (ABL Bilinear/Manual)" "$3"
 
 use_example_configs "Creality/Ender-3 V2/CrealityV422/CrealityUI"
 opt_disable DWIN_CREALITY_LCD PIDTEMP
-opt_enable DWIN_MARLINUI_LANDSCAPE LCD_ENDSTOP_TEST AUTO_BED_LEVELING_UBL BLTOUCH Z_SAFE_HOMING MPCTEMP MPC_AUTOTUNE
+opt_enable DWIN_MARLINUI_LANDSCAPE LCD_ENDSTOP_TEST AUTO_BED_LEVELING_UBL BLTOUCH Z_SAFE_HOMING MPCTEMP MPC_AUTOTUNE_FANCY
 exec_test $1 $2 "Ender-3 v2 - MarlinUI (UBL+BLTOUCH, MPCTEMP, LCD_ENDSTOP_TEST)" "$3"
 
 use_example_configs "Creality/Ender-3 S1/STM32F1"