0x90/Marlin
12
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

🐛 Fix / refactor shared PID (#24673)

Browse source 
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
This commit is contained in:
Giuliano Zaro 2022-09-04 02:51:53 +02:00 committed by GitHub
parent f6d109287f
commit 094701cc71
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 323 additions and 266 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
Marlin/src/gcode/config/M301.cpp
View file

@ -57,19 +57,18 @@ void GcodeSuite::M301() {
if (e < HOTENDS) { // catch bad input value if (e < HOTENDS) { // catch bad input value
if (parser.seenval('P')) PID_PARAM(Kp, e) = parser.value_float(); if (parser.seenval('P')) SET_HOTEND_PID(Kp, e, parser.value_float());
if (parser.seenval('I')) PID_PARAM(Ki, e) = scalePID_i(parser.value_float()); if (parser.seenval('I')) SET_HOTEND_PID(Ki, e, parser.value_float());
if (parser.seenval('D')) PID_PARAM(Kd, e) = scalePID_d(parser.value_float()); if (parser.seenval('D')) SET_HOTEND_PID(Kd, e, parser.value_float());
#if ENABLED(PID_EXTRUSION_SCALING) #if ENABLED(PID_EXTRUSION_SCALING)
if (parser.seenval('C')) PID_PARAM(Kc, e) = parser.value_float(); if (parser.seenval('C')) SET_HOTEND_PID(Kc, e, parser.value_float());
if (parser.seenval('L')) thermalManager.lpq_len = parser.value_int(); if (parser.seenval('L')) thermalManager.lpq_len = parser.value_int();
NOMORE(thermalManager.lpq_len, LPQ_MAX_LEN); LIMIT(thermalManager.lpq_len, 0, LPQ_MAX_LEN);
NOLESS(thermalManager.lpq_len, 0);
#endif #endif
#if ENABLED(PID_FAN_SCALING) #if ENABLED(PID_FAN_SCALING)
if (parser.seenval('F')) PID_PARAM(Kf, e) = parser.value_float(); if (parser.seenval('F')) SET_HOTEND_PID(Kf, e, parser.value_float());
#endif #endif
thermalManager.updatePID(); thermalManager.updatePID();
@ -83,6 +82,7 @@ void GcodeSuite::M301_report(const bool forReplay/*=true*/ E_OPTARG(const int8_t
IF_DISABLED(HAS_MULTI_EXTRUDER, constexpr int8_t eindex = -1); IF_DISABLED(HAS_MULTI_EXTRUDER, constexpr int8_t eindex = -1);
HOTEND_LOOP() { HOTEND_LOOP() {
if (e == eindex || eindex == -1) { if (e == eindex || eindex == -1) {
const hotend_pid_t &pid = thermalManager.temp_hotend[e].pid;
report_echo_start(forReplay); report_echo_start(forReplay);
SERIAL_ECHOPGM_P( SERIAL_ECHOPGM_P(
#if ENABLED(PID_PARAMS_PER_HOTEND) #if ENABLED(PID_PARAMS_PER_HOTEND)
@ -90,16 +90,14 @@ void GcodeSuite::M301_report(const bool forReplay/*=true*/ E_OPTARG(const int8_t
#else #else
PSTR(" M301 P") PSTR(" M301 P")
#endif #endif
, PID_PARAM(Kp, e) , pid.p(), PSTR(" I"), pid.i(), PSTR(" D"), pid.d()
, PSTR(" I"), unscalePID_i(PID_PARAM(Ki, e))
, PSTR(" D"), unscalePID_d(PID_PARAM(Kd, e))
); );
#if ENABLED(PID_EXTRUSION_SCALING) #if ENABLED(PID_EXTRUSION_SCALING)
SERIAL_ECHOPGM_P(SP_C_STR, PID_PARAM(Kc, e)); SERIAL_ECHOPGM_P(SP_C_STR, pid.c());
if (e == 0) SERIAL_ECHOPGM(" L", thermalManager.lpq_len); if (e == 0) SERIAL_ECHOPGM(" L", thermalManager.lpq_len);
#endif #endif
#if ENABLED(PID_FAN_SCALING) #if ENABLED(PID_FAN_SCALING)
SERIAL_ECHOPGM(" F", PID_PARAM(Kf, e)); SERIAL_ECHOPGM(" F", pid.f());
#endif #endif
SERIAL_EOL(); SERIAL_EOL();
} }

14
Marlin/src/gcode/config/M304.cpp
View file

@ -36,17 +36,17 @@
*/ */
void GcodeSuite::M304() { void GcodeSuite::M304() {
if (!parser.seen("PID")) return M304_report(); if (!parser.seen("PID")) return M304_report();
if (parser.seenval('P')) thermalManager.temp_bed.pid.Kp = parser.value_float(); if (parser.seenval('P')) thermalManager.temp_bed.pid.set_Kp(parser.value_float());
if (parser.seenval('I')) thermalManager.temp_bed.pid.Ki = scalePID_i(parser.value_float()); if (parser.seenval('I')) thermalManager.temp_bed.pid.set_Ki(parser.value_float());
if (parser.seenval('D')) thermalManager.temp_bed.pid.Kd = scalePID_d(parser.value_float()); if (parser.seenval('D')) thermalManager.temp_bed.pid.set_Kd(parser.value_float());
} }
void GcodeSuite::M304_report(const bool forReplay/*=true*/) { void GcodeSuite::M304_report(const bool forReplay/*=true*/) {
report_heading_etc(forReplay, F(STR_BED_PID)); report_heading_etc(forReplay, F(STR_BED_PID));
SERIAL_ECHOLNPGM( SERIAL_ECHOLNPGM(" M304"
" M304 P", thermalManager.temp_bed.pid.Kp " P", thermalManager.temp_bed.pid.p()
, " I", unscalePID_i(thermalManager.temp_bed.pid.Ki) , " I", thermalManager.temp_bed.pid.i()
, " D", unscalePID_d(thermalManager.temp_bed.pid.Kd) , " D", thermalManager.temp_bed.pid.d()
); );
} }

14
Marlin/src/gcode/config/M309.cpp
View file

@ -36,17 +36,17 @@
*/ */
void GcodeSuite::M309() { void GcodeSuite::M309() {
if (!parser.seen("PID")) return M309_report(); if (!parser.seen("PID")) return M309_report();
if (parser.seen('P')) thermalManager.temp_chamber.pid.Kp = parser.value_float(); if (parser.seenval('P')) thermalManager.temp_chamber.pid.set_Kp(parser.value_float());
if (parser.seen('I')) thermalManager.temp_chamber.pid.Ki = scalePID_i(parser.value_float()); if (parser.seenval('I')) thermalManager.temp_chamber.pid.set_Ki(parser.value_float());
if (parser.seen('D')) thermalManager.temp_chamber.pid.Kd = scalePID_d(parser.value_float()); if (parser.seenval('D')) thermalManager.temp_chamber.pid.set_Kd(parser.value_float());
} }
void GcodeSuite::M309_report(const bool forReplay/*=true*/) { void GcodeSuite::M309_report(const bool forReplay/*=true*/) {
report_heading_etc(forReplay, F(STR_CHAMBER_PID)); report_heading_etc(forReplay, F(STR_CHAMBER_PID));
SERIAL_ECHOLNPGM( SERIAL_ECHOLNPGM(" M309"
" M309 P", thermalManager.temp_chamber.pid.Kp " P", thermalManager.temp_chamber.pid.p()
, " I", unscalePID_i(thermalManager.temp_chamber.pid.Ki) , " I", thermalManager.temp_chamber.pid.i()
, " D", unscalePID_d(thermalManager.temp_chamber.pid.Kd) , " D", thermalManager.temp_chamber.pid.d()
); );
} }

12
Marlin/src/lcd/e3v2/jyersui/dwin.cpp
View file

@ -2140,7 +2140,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
case HOTENDPID_KP: case HOTENDPID_KP:
if (draw) { if (draw) {
Draw_Menu_Item(row, ICON_Version, F("Kp Value")); Draw_Menu_Item(row, ICON_Version, F("Kp Value"));
Draw_Float(thermalManager.temp_hotend[0].pid.Kp, row, false, 100); Draw_Float(thermalManager.temp_hotend[0].pid.p(), row, false, 100);
} }
else else
Modify_Value(thermalManager.temp_hotend[0].pid.Kp, 0, 5000, 100, thermalManager.updatePID); Modify_Value(thermalManager.temp_hotend[0].pid.Kp, 0, 5000, 100, thermalManager.updatePID);
@ -2148,7 +2148,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
case HOTENDPID_KI: case HOTENDPID_KI:
if (draw) { if (draw) {
Draw_Menu_Item(row, ICON_Version, F("Ki Value")); Draw_Menu_Item(row, ICON_Version, F("Ki Value"));
Draw_Float(unscalePID_i(thermalManager.temp_hotend[0].pid.Ki), row, false, 100); Draw_Float(thermalManager.temp_hotend[0].pid.i(), row, false, 100);
} }
else else
Modify_Value(thermalManager.temp_hotend[0].pid.Ki, 0, 5000, 100, thermalManager.updatePID); Modify_Value(thermalManager.temp_hotend[0].pid.Ki, 0, 5000, 100, thermalManager.updatePID);
@ -2156,7 +2156,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
case HOTENDPID_KD: case HOTENDPID_KD:
if (draw) { if (draw) {
Draw_Menu_Item(row, ICON_Version, F("Kd Value")); Draw_Menu_Item(row, ICON_Version, F("Kd Value"));
Draw_Float(unscalePID_d(thermalManager.temp_hotend[0].pid.Kd), row, false, 100); Draw_Float(thermalManager.temp_hotend[0].pid.d(), row, false, 100);
} }
else else
Modify_Value(thermalManager.temp_hotend[0].pid.Kd, 0, 5000, 100, thermalManager.updatePID); Modify_Value(thermalManager.temp_hotend[0].pid.Kd, 0, 5000, 100, thermalManager.updatePID);
@ -2207,7 +2207,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
case BEDPID_KP: case BEDPID_KP:
if (draw) { if (draw) {
Draw_Menu_Item(row, ICON_Version, F("Kp Value")); Draw_Menu_Item(row, ICON_Version, F("Kp Value"));
Draw_Float(thermalManager.temp_bed.pid.Kp, row, false, 100); Draw_Float(thermalManager.temp_bed.pid.p(), row, false, 100);
} }
else { else {
Modify_Value(thermalManager.temp_bed.pid.Kp, 0, 5000, 100, thermalManager.updatePID); Modify_Value(thermalManager.temp_bed.pid.Kp, 0, 5000, 100, thermalManager.updatePID);
@ -2216,7 +2216,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
case BEDPID_KI: case BEDPID_KI:
if (draw) { if (draw) {
Draw_Menu_Item(row, ICON_Version, F("Ki Value")); Draw_Menu_Item(row, ICON_Version, F("Ki Value"));
Draw_Float(unscalePID_i(thermalManager.temp_bed.pid.Ki), row, false, 100); Draw_Float(thermalManager.temp_bed.pid.i(), row, false, 100);
} }
else else
Modify_Value(thermalManager.temp_bed.pid.Ki, 0, 5000, 100, thermalManager.updatePID); Modify_Value(thermalManager.temp_bed.pid.Ki, 0, 5000, 100, thermalManager.updatePID);
@ -2224,7 +2224,7 @@ void CrealityDWINClass::Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw/
case BEDPID_KD: case BEDPID_KD:
if (draw) { if (draw) {
Draw_Menu_Item(row, ICON_Version, F("Kd Value")); Draw_Menu_Item(row, ICON_Version, F("Kd Value"));
Draw_Float(unscalePID_d(thermalManager.temp_bed.pid.Kd), row, false, 100); Draw_Float(thermalManager.temp_bed.pid.d(), row, false, 100);
} }
else else
Modify_Value(thermalManager.temp_bed.pid.Kd, 0, 5000, 100, thermalManager.updatePID); Modify_Value(thermalManager.temp_bed.pid.Kd, 0, 5000, 100, thermalManager.updatePID);

20
Marlin/src/lcd/e3v2/proui/dwin.cpp
View file

@ -2667,13 +2667,15 @@ void SetStepsY() { HMI_value.axis = Y_AXIS, SetPFloatOnClick( MIN_STEP, MAX_STEP
void SetStepsZ() { HMI_value.axis = Z_AXIS, SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); } void SetStepsZ() { HMI_value.axis = Z_AXIS, SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); }
#if HAS_HOTEND #if HAS_HOTEND
void SetStepsE() { HMI_value.axis = E_AXIS; SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); } void SetStepsE() { HMI_value.axis = E_AXIS; SetPFloatOnClick( MIN_STEP, MAX_STEP, UNITFDIGITS); }
void SetHotendPidT() { SetPIntOnClick(MIN_ETEMP, MAX_ETEMP); } #if ENABLED(PIDTEMP)
void SetHotendPidT() { SetPIntOnClick(MIN_ETEMP, MAX_ETEMP); }
#endif
#endif #endif
#if HAS_HEATED_BED #if ENABLED(PIDTEMPBED)
void SetBedPidT() { SetPIntOnClick(MIN_BEDTEMP, MAX_BEDTEMP); } void SetBedPidT() { SetPIntOnClick(MIN_BEDTEMP, MAX_BEDTEMP); }
#endif #endif
#if HAS_HOTEND || HAS_HEATED_BED #if EITHER(PIDTEMP, PIDTEMPBED)
void SetPidCycles() { SetPIntOnClick(3, 50); } void SetPidCycles() { SetPIntOnClick(3, 50); }
void SetKp() { SetPFloatOnClick(0, 1000, 2); } void SetKp() { SetPFloatOnClick(0, 1000, 2); }
void ApplyPIDi() { void ApplyPIDi() {
@ -3222,10 +3224,10 @@ void Draw_AdvancedSettings_Menu() {
#if HAS_HOME_OFFSET #if HAS_HOME_OFFSET
MENU_ITEM_F(ICON_HomeOffset, MSG_SET_HOME_OFFSETS, onDrawSubMenu, Draw_HomeOffset_Menu); MENU_ITEM_F(ICON_HomeOffset, MSG_SET_HOME_OFFSETS, onDrawSubMenu, Draw_HomeOffset_Menu);
#endif #endif
#if HAS_HOTEND #if ENABLED(PIDTEMP)
MENU_ITEM(ICON_PIDNozzle, F(STR_HOTEND_PID " Settings"), onDrawSubMenu, Draw_HotendPID_Menu); MENU_ITEM(ICON_PIDNozzle, F(STR_HOTEND_PID " Settings"), onDrawSubMenu, Draw_HotendPID_Menu);
#endif #endif
#if HAS_HEATED_BED #if ENABLED(PIDTEMPBED)
MENU_ITEM(ICON_PIDbed, F(STR_BED_PID " Settings"), onDrawSubMenu, Draw_BedPID_Menu); MENU_ITEM(ICON_PIDbed, F(STR_BED_PID " Settings"), onDrawSubMenu, Draw_BedPID_Menu);
#endif #endif
MENU_ITEM_F(ICON_FilSet, MSG_FILAMENT_SET, onDrawSubMenu, Draw_FilSet_Menu); MENU_ITEM_F(ICON_FilSet, MSG_FILAMENT_SET, onDrawSubMenu, Draw_FilSet_Menu);
@ -3668,10 +3670,10 @@ void Draw_Steps_Menu() {
CurrentMenu->draw(); CurrentMenu->draw();
} }
#if HAS_HOTEND #if ENABLED(PIDTEMP)
void Draw_HotendPID_Menu() { void Draw_HotendPID_Menu() {
checkkey = Menu; checkkey = Menu;
if (SetMenu(HotendPIDMenu, F(STR_HOTEND_PID " Settings"),8)) { if (SetMenu(HotendPIDMenu, F(STR_HOTEND_PID " Settings"), 8)) {
BACK_ITEM(Draw_AdvancedSettings_Menu); BACK_ITEM(Draw_AdvancedSettings_Menu);
MENU_ITEM(ICON_PIDNozzle, F(STR_HOTEND_PID), onDrawMenuItem, HotendPID); MENU_ITEM(ICON_PIDNozzle, F(STR_HOTEND_PID), onDrawMenuItem, HotendPID);
EDIT_ITEM(ICON_PIDValue, F("Set" STR_KP), onDrawPFloat2Menu, SetKp, &thermalManager.temp_hotend[0].pid.Kp); EDIT_ITEM(ICON_PIDValue, F("Set" STR_KP), onDrawPFloat2Menu, SetKp, &thermalManager.temp_hotend[0].pid.Kp);
@ -3687,10 +3689,10 @@ void Draw_Steps_Menu() {
} }
#endif #endif
#if HAS_HEATED_BED #if ENABLED(PIDTEMPBED)
void Draw_BedPID_Menu() { void Draw_BedPID_Menu() {
checkkey = Menu; checkkey = Menu;
if (SetMenu(BedPIDMenu, F(STR_BED_PID " Settings"),8)) { if (SetMenu(BedPIDMenu, F(STR_BED_PID " Settings"), 8)) {
BACK_ITEM(Draw_AdvancedSettings_Menu); BACK_ITEM(Draw_AdvancedSettings_Menu);
MENU_ITEM(ICON_PIDNozzle, F(STR_BED_PID), onDrawMenuItem,BedPID); MENU_ITEM(ICON_PIDNozzle, F(STR_BED_PID), onDrawMenuItem,BedPID);
EDIT_ITEM(ICON_PIDValue, F("Set" STR_KP), onDrawPFloat2Menu, SetKp, &thermalManager.temp_bed.pid.Kp); EDIT_ITEM(ICON_PIDValue, F("Set" STR_KP), onDrawPFloat2Menu, SetKp, &thermalManager.temp_bed.pid.Kp);

6
Marlin/src/lcd/e3v2/proui/dwin.h
View file

@ -264,7 +264,9 @@ void Draw_Motion_Menu();
void Draw_Preheat1_Menu(); void Draw_Preheat1_Menu();
void Draw_Preheat2_Menu(); void Draw_Preheat2_Menu();
void Draw_Preheat3_Menu(); void Draw_Preheat3_Menu();
void Draw_HotendPID_Menu(); #if ENABLED(PIDTEMP)
void Draw_HotendPID_Menu();
#endif
#endif #endif
void Draw_Temperature_Menu(); void Draw_Temperature_Menu();
void Draw_MaxSpeed_Menu(); void Draw_MaxSpeed_Menu();
@ -273,7 +275,7 @@ void Draw_MaxAccel_Menu();
void Draw_MaxJerk_Menu(); void Draw_MaxJerk_Menu();
#endif #endif
void Draw_Steps_Menu(); void Draw_Steps_Menu();
#if HAS_HEATED_BED #if ENABLED(PIDTEMPBED)
void Draw_BedPID_Menu(); void Draw_BedPID_Menu();
#endif #endif
#if EITHER(HAS_BED_PROBE, BABYSTEPPING) #if EITHER(HAS_BED_PROBE, BABYSTEPPING)

18
Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.cpp
View file

@ -421,16 +421,16 @@ void DGUSTxHandler::PIDKp(DGUS_VP &vp) {
default: return; default: return;
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
case DGUS_Data::Heater::BED: case DGUS_Data::Heater::BED:
value = ExtUI::getBedPIDValues_Kp(); value = ExtUI::getBedPID_Kp();
break; break;
#endif #endif
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
case DGUS_Data::Heater::H0: case DGUS_Data::Heater::H0:
value = ExtUI::getPIDValues_Kp(ExtUI::E0); value = ExtUI::getPID_Kp(ExtUI::E0);
break; break;
#if HAS_MULTI_HOTEND #if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1: case DGUS_Data::Heater::H1:
value = ExtUI::getPIDValues_Kp(ExtUI::E1); value = ExtUI::getPID_Kp(ExtUI::E1);
break; break;
#endif #endif
#endif #endif
@ -447,16 +447,16 @@ void DGUSTxHandler::PIDKi(DGUS_VP &vp) {
default: return; default: return;
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
case DGUS_Data::Heater::BED: case DGUS_Data::Heater::BED:
value = ExtUI::getBedPIDValues_Ki(); value = ExtUI::getBedPID_Ki();
break; break;
#endif #endif
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
case DGUS_Data::Heater::H0: case DGUS_Data::Heater::H0:
value = ExtUI::getPIDValues_Ki(ExtUI::E0); value = ExtUI::getPID_Ki(ExtUI::E0);
break; break;
#if HAS_MULTI_HOTEND #if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1: case DGUS_Data::Heater::H1:
value = ExtUI::getPIDValues_Ki(ExtUI::E1); value = ExtUI::getPID_Ki(ExtUI::E1);
break; break;
#endif #endif
#endif #endif
@ -473,16 +473,16 @@ void DGUSTxHandler::PIDKd(DGUS_VP &vp) {
default: return; default: return;
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
case DGUS_Data::Heater::BED: case DGUS_Data::Heater::BED:
value = ExtUI::getBedPIDValues_Kd(); value = ExtUI::getBedPID_Kd();
break; break;
#endif #endif
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
case DGUS_Data::Heater::H0: case DGUS_Data::Heater::H0:
value = ExtUI::getPIDValues_Kd(ExtUI::E0); value = ExtUI::getPID_Kd(ExtUI::E0);
break; break;
#if HAS_MULTI_HOTEND #if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1: case DGUS_Data::Heater::H1:
value = ExtUI::getPIDValues_Kd(ExtUI::E1); value = ExtUI::getPID_Kd(ExtUI::E1);
break; break;
#endif #endif
#endif #endif

6
Marlin/src/lcd/extui/nextion/nextion_tft.cpp
View file

@ -459,17 +459,17 @@ void NextionTFT::PanelInfo(uint8_t req) {
case 37: // PID case 37: // PID
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
#define SEND_PID_INFO_0(A, B) SEND_VALasTXT(A, getPIDValues_K##B(E0)) #define SEND_PID_INFO_0(A, B) SEND_VALasTXT(A, getPID_K##B(E0))
#else #else
#define SEND_PID_INFO_0(A, B) SEND_NA(A) #define SEND_PID_INFO_0(A, B) SEND_NA(A)
#endif #endif
#if BOTH(PIDTEMP, HAS_MULTI_EXTRUDER) #if BOTH(PIDTEMP, HAS_MULTI_EXTRUDER)
#define SEND_PID_INFO_1(A, B) SEND_VALasTXT(A, getPIDValues_K##B(E1)) #define SEND_PID_INFO_1(A, B) SEND_VALasTXT(A, getPID_K##B(E1))
#else #else
#define SEND_PID_INFO_1(A, B) SEND_NA(A) #define SEND_PID_INFO_1(A, B) SEND_NA(A)
#endif #endif
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
#define SEND_PID_INFO_BED(A, B) SEND_VALasTXT(A, getBedPIDValues_K##B()) #define SEND_PID_INFO_BED(A, B) SEND_VALasTXT(A, getBedPID_K##B())
#else #else
#define SEND_PID_INFO_BED(A, B) SEND_NA(A) #define SEND_PID_INFO_BED(A, B) SEND_NA(A)
#endif #endif

28
Marlin/src/lcd/extui/ui_api.cpp
View file

@ -976,32 +976,26 @@ namespace ExtUI {
float getFeedrate_percent() { return feedrate_percentage; } float getFeedrate_percent() { return feedrate_percentage; }
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
float getPIDValues_Kp(const extruder_t tool) { return PID_PARAM(Kp, tool); } float getPID_Kp(const extruder_t tool) { return thermalManager.temp_hotend[tool].pid.p(); }
float getPIDValues_Ki(const extruder_t tool) { return unscalePID_i(PID_PARAM(Ki, tool)); } float getPID_Ki(const extruder_t tool) { return thermalManager.temp_hotend[tool].pid.i(); }
float getPIDValues_Kd(const extruder_t tool) { return unscalePID_d(PID_PARAM(Kd, tool)); } float getPID_Kd(const extruder_t tool) { return thermalManager.temp_hotend[tool].pid.d(); }
void setPIDValues(const_float_t p, const_float_t i, const_float_t d, extruder_t tool) { void setPID(const_float_t p, const_float_t i, const_float_t d, extruder_t tool) {
thermalManager.temp_hotend[tool].pid.Kp = p; thermalManager.setPID(uint8_t(tool), p, i, d);
thermalManager.temp_hotend[tool].pid.Ki = scalePID_i(i);
thermalManager.temp_hotend[tool].pid.Kd = scalePID_d(d);
thermalManager.updatePID();
} }
void startPIDTune(const celsius_t temp, extruder_t tool) { void startPIDTune(const celsius_t temp, extruder_t tool) {
thermalManager.PID_autotune(temp, (heater_id_t)tool, 8, true); thermalManager.PID_autotune(temp, heater_id_t(tool), 8, true);
} }
#endif #endif
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
float getBedPIDValues_Kp() { return thermalManager.temp_bed.pid.Kp; } float getBedPID_Kp() { return thermalManager.temp_bed.pid.p(); }
float getBedPIDValues_Ki() { return unscalePID_i(thermalManager.temp_bed.pid.Ki); } float getBedPID_Ki() { return thermalManager.temp_bed.pid.i(); }
float getBedPIDValues_Kd() { return unscalePID_d(thermalManager.temp_bed.pid.Kd); } float getBedPID_Kd() { return thermalManager.temp_bed.pid.d(); }
void setBedPIDValues(const_float_t p, const_float_t i, const_float_t d) { void setBedPID(const_float_t p, const_float_t i, const_float_t d) {
thermalManager.temp_bed.pid.Kp = p; thermalManager.temp_bed.pid.set(p, i, d);
thermalManager.temp_bed.pid.Ki = scalePID_i(i);
thermalManager.temp_bed.pid.Kd = scalePID_d(d);
thermalManager.updatePID();
} }
void startBedPIDTune(const celsius_t temp) { void startBedPIDTune(const celsius_t temp) {

16
Marlin/src/lcd/extui/ui_api.h
View file

@ -324,18 +324,18 @@ namespace ExtUI {
#endif #endif
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
float getPIDValues_Kp(const extruder_t); float getPID_Kp(const extruder_t);
float getPIDValues_Ki(const extruder_t); float getPID_Ki(const extruder_t);
float getPIDValues_Kd(const extruder_t); float getPID_Kd(const extruder_t);
void setPIDValues(const_float_t, const_float_t , const_float_t , extruder_t); void setPID(const_float_t, const_float_t , const_float_t , extruder_t);
void startPIDTune(const celsius_t, extruder_t); void startPIDTune(const celsius_t, extruder_t);
#endif #endif
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
float getBedPIDValues_Kp(); float getBedPID_Kp();
float getBedPIDValues_Ki(); float getBedPID_Ki();
float getBedPIDValues_Kd(); float getBedPID_Kd();
void setBedPIDValues(const_float_t, const_float_t , const_float_t); void setBedPID(const_float_t, const_float_t , const_float_t);
void startBedPIDTune(const celsius_t); void startBedPIDTune(const celsius_t);
#endif #endif

72
Marlin/src/lcd/menu/menu_advanced.cpp
View file

@ -209,37 +209,59 @@ void menu_backlash();
#if ENABLED(PID_EDIT_MENU) #if ENABLED(PID_EDIT_MENU)
float raw_Ki, raw_Kd; // place-holders for Ki and Kd edits // Placeholders for PID editing
float raw_Kp, raw_Ki, raw_Kd;
#if ENABLED(PID_EXTRUSION_SCALING)
float raw_Kc;
#endif
#if ENABLED(PID_FAN_SCALING)
float raw_Kf;
#endif
// Helpers for editing PID Ki & Kd values // Helpers for editing PID Kp, Ki and Kd values
// grab the PID value out of the temp variable; scale it; then update the PID driver void apply_PID_p(const int8_t e) {
void copy_and_scalePID_i(const int8_t e) {
switch (e) { switch (e) {
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
case H_BED: thermalManager.temp_bed.pid.Ki = scalePID_i(raw_Ki); break; case H_BED: thermalManager.temp_bed.pid.set_Ki(raw_Ki); break;
#endif #endif
#if ENABLED(PIDTEMPCHAMBER) #if ENABLED(PIDTEMPCHAMBER)
case H_CHAMBER: thermalManager.temp_chamber.pid.Ki = scalePID_i(raw_Ki); break; case H_CHAMBER: thermalManager.temp_chamber.pid.set_Ki(raw_Ki); break;
#endif #endif
default: default:
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
PID_PARAM(Ki, e) = scalePID_i(raw_Ki); SET_HOTEND_PID(Kp, e, raw_Kp);
thermalManager.updatePID(); thermalManager.updatePID();
#endif #endif
break; break;
} }
} }
void copy_and_scalePID_d(const int8_t e) { void apply_PID_i(const int8_t e) {
switch (e) { switch (e) {
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
case H_BED: thermalManager.temp_bed.pid.Kd = scalePID_d(raw_Kd); break; case H_BED: thermalManager.temp_bed.pid.set_Ki(raw_Ki); break;
#endif #endif
#if ENABLED(PIDTEMPCHAMBER) #if ENABLED(PIDTEMPCHAMBER)
case H_CHAMBER: thermalManager.temp_chamber.pid.Kd = scalePID_d(raw_Kd); break; case H_CHAMBER: thermalManager.temp_chamber.pid.set_Ki(raw_Ki); break;
#endif #endif
default: default:
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
PID_PARAM(Kd, e) = scalePID_d(raw_Kd); SET_HOTEND_PID(Ki, e, raw_Ki);
thermalManager.updatePID();
#endif
break;
}
}
void apply_PID_d(const int8_t e) {
switch (e) {
#if ENABLED(PIDTEMPBED)
case H_BED: thermalManager.temp_bed.pid.set_Kd(raw_Kd); break;
#endif
#if ENABLED(PIDTEMPCHAMBER)
case H_CHAMBER: thermalManager.temp_chamber.pid.set_Kd(raw_Kd); break;
#endif
default:
#if ENABLED(PIDTEMP)
SET_HOTEND_PID(Kd, e, raw_Kd);
thermalManager.updatePID(); thermalManager.updatePID();
#endif #endif
break; break;
@ -291,16 +313,18 @@ void menu_backlash();
#if BOTH(PIDTEMP, PID_EDIT_MENU) #if BOTH(PIDTEMP, PID_EDIT_MENU)
#define __PID_HOTEND_MENU_ITEMS(N) \ #define __PID_HOTEND_MENU_ITEMS(N) \
raw_Ki = unscalePID_i(PID_PARAM(Ki, N)); \ raw_Kp = thermalManager.temp_hotend[N].pid.p(); \
raw_Kd = unscalePID_d(PID_PARAM(Kd, N)); \ raw_Ki = thermalManager.temp_hotend[N].pid.i(); \
EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_P_E, &PID_PARAM(Kp, N), 1, 9990); \ raw_Kd = thermalManager.temp_hotend[N].pid.d(); \
EDIT_ITEM_FAST_N(float52sign, N, MSG_PID_I_E, &raw_Ki, 0.01f, 9990, []{ copy_and_scalePID_i(N); }); \ EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_P_E, &raw_Kp, 1, 9990, []{ apply_PID_p(N); }); \
EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_D_E, &raw_Kd, 1, 9990, []{ copy_and_scalePID_d(N); }) EDIT_ITEM_FAST_N(float52sign, N, MSG_PID_I_E, &raw_Ki, 0.01f, 9990, []{ apply_PID_i(N); }); \
EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_D_E, &raw_Kd, 1, 9990, []{ apply_PID_d(N); })
#if ENABLED(PID_EXTRUSION_SCALING) #if ENABLED(PID_EXTRUSION_SCALING)
#define _PID_HOTEND_MENU_ITEMS(N) \ #define _PID_HOTEND_MENU_ITEMS(N) \
__PID_HOTEND_MENU_ITEMS(N); \ __PID_HOTEND_MENU_ITEMS(N); \
EDIT_ITEM_N(float4, N, MSG_PID_C_E, &PID_PARAM(Kc, N), 1, 9990) raw_Kc = thermalManager.temp_hotend[N].pid.c(); \
EDIT_ITEM_N(float4, N, MSG_PID_C_E, &raw_Kc, 1, 9990, []{ SET_HOTEND_PID(Kc, N, raw_Kc); thermalManager.updatePID(); });
#else #else
#define _PID_HOTEND_MENU_ITEMS(N) __PID_HOTEND_MENU_ITEMS(N) #define _PID_HOTEND_MENU_ITEMS(N) __PID_HOTEND_MENU_ITEMS(N)
#endif #endif
@ -308,7 +332,8 @@ void menu_backlash();
#if ENABLED(PID_FAN_SCALING) #if ENABLED(PID_FAN_SCALING)
#define _HOTEND_PID_EDIT_MENU_ITEMS(N) \ #define _HOTEND_PID_EDIT_MENU_ITEMS(N) \
_PID_HOTEND_MENU_ITEMS(N); \ _PID_HOTEND_MENU_ITEMS(N); \
EDIT_ITEM_N(float4, N, MSG_PID_F_E, &PID_PARAM(Kf, N), 1, 9990) raw_Kf = thermalManager.temp_hotend[N].pid.f(); \
EDIT_ITEM_N(float4, N, MSG_PID_F_E, &raw_Kf, 1, 9990, []{ SET_HOTEND_PID(Kf, N, raw_Kf); thermalManager.updatePID(); });
#else #else
#define _HOTEND_PID_EDIT_MENU_ITEMS(N) _PID_HOTEND_MENU_ITEMS(N) #define _HOTEND_PID_EDIT_MENU_ITEMS(N) _PID_HOTEND_MENU_ITEMS(N)
#endif #endif
@ -321,11 +346,12 @@ void menu_backlash();
#if ENABLED(PID_EDIT_MENU) && EITHER(PIDTEMPBED, PIDTEMPCHAMBER) #if ENABLED(PID_EDIT_MENU) && EITHER(PIDTEMPBED, PIDTEMPCHAMBER)
#define _PID_EDIT_ITEMS_TMPL(N,T) \ #define _PID_EDIT_ITEMS_TMPL(N,T) \
raw_Ki = unscalePID_i(T.pid.Ki); \ raw_Kp = T.pid.p(); \
raw_Kd = unscalePID_d(T.pid.Kd); \ raw_Ki = T.pid.i(); \
EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_P_E, &T.pid.Kp, 1, 9990); \ raw_Kd = T.pid.d(); \
EDIT_ITEM_FAST_N(float52sign, N, MSG_PID_I_E, &raw_Ki, 0.01f, 9990, []{ copy_and_scalePID_i(N); }); \ EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_P_E, &raw_Kp, 1, 9990, []{ apply_PID_p(N); }); \
EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_D_E, &raw_Kd, 1, 9990, []{ copy_and_scalePID_d(N); }) EDIT_ITEM_FAST_N(float52sign, N, MSG_PID_I_E, &raw_Ki, 0.01f, 9990, []{ apply_PID_i(N); }); \
EDIT_ITEM_FAST_N(float41sign, N, MSG_PID_D_E, &raw_Kd, 1, 9990, []{ apply_PID_d(N); })
#endif #endif
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)

132
Marlin/src/module/settings.cpp
View file

@ -364,18 +364,18 @@ typedef struct SettingsDataStruct {
// //
// PIDTEMP // PIDTEMP
// //
PIDCF_t hotendPID[HOTENDS]; // M301 En PIDCF / M303 En U raw_pidcf_t hotendPID[HOTENDS]; // M301 En PIDCF / M303 En U
int16_t lpq_len; // M301 L int16_t lpq_len; // M301 L
// //
// PIDTEMPBED // PIDTEMPBED
// //
PID_t bedPID; // M304 PID / M303 E-1 U raw_pid_t bedPID; // M304 PID / M303 E-1 U
// //
// PIDTEMPCHAMBER // PIDTEMPCHAMBER
// //
PID_t chamberPID; // M309 PID / M303 E-2 U raw_pid_t chamberPID; // M309 PID / M303 E-2 U
// //
// User-defined Thermistors // User-defined Thermistors
@ -1052,27 +1052,20 @@ void MarlinSettings::postprocess() {
// //
{ {
_FIELD_TEST(hotendPID); _FIELD_TEST(hotendPID);
#if DISABLED(PIDTEMP)
raw_pidcf_t pidcf = { NAN, NAN, NAN, NAN, NAN };
#endif
HOTEND_LOOP() { HOTEND_LOOP() {
PIDCF_t pidcf = { #if ENABLED(PIDTEMP)
#if DISABLED(PIDTEMP) const hotend_pid_t &pid = thermalManager.temp_hotend[e].pid;
NAN, NAN, NAN, raw_pidcf_t pidcf = { pid.p(), pid.i(), pid.d(), pid.c(), pid.f() };
NAN, NAN #endif
#else
PID_PARAM(Kp, e),
unscalePID_i(PID_PARAM(Ki, e)),
unscalePID_d(PID_PARAM(Kd, e)),
PID_PARAM(Kc, e),
PID_PARAM(Kf, e)
#endif
};
EEPROM_WRITE(pidcf); EEPROM_WRITE(pidcf);
} }
_FIELD_TEST(lpq_len); _FIELD_TEST(lpq_len);
#if DISABLED(PID_EXTRUSION_SCALING) const int16_t lpq_len = TERN(PID_EXTRUSION_SCALING, thermalManager.lpq_len, 20);
const int16_t lpq_len = 20; EEPROM_WRITE(lpq_len);
#endif
EEPROM_WRITE(TERN(PID_EXTRUSION_SCALING, thermalManager.lpq_len, lpq_len));
} }
// //
@ -1080,17 +1073,12 @@ void MarlinSettings::postprocess() {
// //
{ {
_FIELD_TEST(bedPID); _FIELD_TEST(bedPID);
#if ENABLED(PIDTEMPBED)
const PID_t bed_pid = { const PID_t &pid = thermalManager.temp_bed.pid;
#if DISABLED(PIDTEMPBED) const raw_pid_t bed_pid = { pid.p(), pid.i(), pid.d() };
NAN, NAN, NAN #else
#else const raw_pid_t bed_pid = { NAN, NAN, NAN };
// Store the unscaled PID values #endif
thermalManager.temp_bed.pid.Kp,
unscalePID_i(thermalManager.temp_bed.pid.Ki),
unscalePID_d(thermalManager.temp_bed.pid.Kd)
#endif
};
EEPROM_WRITE(bed_pid); EEPROM_WRITE(bed_pid);
} }
@ -1099,17 +1087,12 @@ void MarlinSettings::postprocess() {
// //
{ {
_FIELD_TEST(chamberPID); _FIELD_TEST(chamberPID);
#if ENABLED(PIDTEMPCHAMBER)
const PID_t chamber_pid = { const PID_t &pid = thermalManager.temp_chamber.pid;
#if DISABLED(PIDTEMPCHAMBER) const raw_pid_t chamber_pid = { pid.p(), pid.i(), pid.d() };
NAN, NAN, NAN #else
#else const raw_pid_t chamber_pid = { NAN, NAN, NAN };
// Store the unscaled PID values #endif
thermalManager.temp_chamber.pid.Kp,
unscalePID_i(thermalManager.temp_chamber.pid.Ki),
unscalePID_d(thermalManager.temp_chamber.pid.Kd)
#endif
};
EEPROM_WRITE(chamber_pid); EEPROM_WRITE(chamber_pid);
} }
@ -1117,10 +1100,8 @@ void MarlinSettings::postprocess() {
// User-defined Thermistors // User-defined Thermistors
// //
#if HAS_USER_THERMISTORS #if HAS_USER_THERMISTORS
{
_FIELD_TEST(user_thermistor); _FIELD_TEST(user_thermistor);
EEPROM_WRITE(thermalManager.user_thermistor); EEPROM_WRITE(thermalManager.user_thermistor);
}
#endif #endif
// //
@ -2003,17 +1984,11 @@ void MarlinSettings::postprocess() {
// //
{ {
HOTEND_LOOP() { HOTEND_LOOP() {
PIDCF_t pidcf; raw_pidcf_t pidcf;
EEPROM_READ(pidcf); EEPROM_READ(pidcf);
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
if (!validating && !isnan(pidcf.Kp)) { if (!validating && !isnan(pidcf.p))
// Scale PID values since EEPROM values are unscaled thermalManager.temp_hotend[e].pid.set(pidcf);
PID_PARAM(Kp, e) = pidcf.Kp;
PID_PARAM(Ki, e) = scalePID_i(pidcf.Ki);
PID_PARAM(Kd, e) = scalePID_d(pidcf.Kd);
TERN_(PID_EXTRUSION_SCALING, PID_PARAM(Kc, e) = pidcf.Kc);
TERN_(PID_FAN_SCALING, PID_PARAM(Kf, e) = pidcf.Kf);
}
#endif #endif
} }
} }
@ -2035,15 +2010,11 @@ void MarlinSettings::postprocess() {
// Heated Bed PID // Heated Bed PID
// //
{ {
PID_t pid; raw_pid_t pid;
EEPROM_READ(pid); EEPROM_READ(pid);
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
if (!validating && !isnan(pid.Kp)) { if (!validating && !isnan(pid.p))
// Scale PID values since EEPROM values are unscaled thermalManager.temp_bed.pid.set(pid);
thermalManager.temp_bed.pid.Kp = pid.Kp;
thermalManager.temp_bed.pid.Ki = scalePID_i(pid.Ki);
thermalManager.temp_bed.pid.Kd = scalePID_d(pid.Kd);
}
#endif #endif
} }
@ -2051,15 +2022,11 @@ void MarlinSettings::postprocess() {
// Heated Chamber PID // Heated Chamber PID
// //
{ {
PID_t pid; raw_pid_t pid;
EEPROM_READ(pid); EEPROM_READ(pid);
#if ENABLED(PIDTEMPCHAMBER) #if ENABLED(PIDTEMPCHAMBER)
if (!validating && !isnan(pid.Kp)) { if (!validating && !isnan(pid.p))
// Scale PID values since EEPROM values are unscaled thermalManager.temp_chamber.pid.set(pid);
thermalManager.temp_chamber.pid.Kp = pid.Kp;
thermalManager.temp_chamber.pid.Ki = scalePID_i(pid.Ki);
thermalManager.temp_chamber.pid.Kd = scalePID_d(pid.Kd);
}
#endif #endif
} }
@ -3142,11 +3109,13 @@ void MarlinSettings::reset() {
#define PID_DEFAULT(N,E) DEFAULT_##N #define PID_DEFAULT(N,E) DEFAULT_##N
#endif #endif
HOTEND_LOOP() { HOTEND_LOOP() {
PID_PARAM(Kp, e) = float(PID_DEFAULT(Kp, ALIM(e, defKp))); thermalManager.temp_hotend[e].pid.set(
PID_PARAM(Ki, e) = scalePID_i(PID_DEFAULT(Ki, ALIM(e, defKi))); PID_DEFAULT(Kp, ALIM(e, defKp)),
PID_PARAM(Kd, e) = scalePID_d(PID_DEFAULT(Kd, ALIM(e, defKd))); PID_DEFAULT(Ki, ALIM(e, defKi)),
TERN_(PID_EXTRUSION_SCALING, PID_PARAM(Kc, e) = float(PID_DEFAULT(Kc, ALIM(e, defKc)))); PID_DEFAULT(Kd, ALIM(e, defKd))
TERN_(PID_FAN_SCALING, PID_PARAM(Kf, e) = float(PID_DEFAULT(Kf, ALIM(e, defKf)))); OPTARG(PID_EXTRUSION_SCALING, PID_DEFAULT(Kc, ALIM(e, defKc)))
OPTARG(PID_FAN_SCALING, PID_DEFAULT(Kf, ALIM(e, defKf)))
);
} }
#endif #endif
@ -3160,9 +3129,7 @@ void MarlinSettings::reset() {
// //
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
thermalManager.temp_bed.pid.Kp = DEFAULT_bedKp; thermalManager.temp_bed.pid.set(DEFAULT_bedKp, DEFAULT_bedKi, DEFAULT_bedKd);
thermalManager.temp_bed.pid.Ki = scalePID_i(DEFAULT_bedKi);
thermalManager.temp_bed.pid.Kd = scalePID_d(DEFAULT_bedKd);
#endif #endif
// //
@ -3170,9 +3137,7 @@ void MarlinSettings::reset() {
// //
#if ENABLED(PIDTEMPCHAMBER) #if ENABLED(PIDTEMPCHAMBER)
thermalManager.temp_chamber.pid.Kp = DEFAULT_chamberKp; thermalManager.temp_chamber.pid.set(DEFAULT_chamberKp, DEFAULT_chamberKi, DEFAULT_chamberKd);
thermalManager.temp_chamber.pid.Ki = scalePID_i(DEFAULT_chamberKi);
thermalManager.temp_chamber.pid.Kd = scalePID_d(DEFAULT_chamberKd);
#endif #endif
// //
@ -3342,14 +3307,15 @@ void MarlinSettings::reset() {
static_assert(COUNT(_filament_heat_capacity_permm) == HOTENDS, "FILAMENT_HEAT_CAPACITY_PERMM must have HOTENDS items."); static_assert(COUNT(_filament_heat_capacity_permm) == HOTENDS, "FILAMENT_HEAT_CAPACITY_PERMM must have HOTENDS items.");
HOTEND_LOOP() { HOTEND_LOOP() {
thermalManager.temp_hotend[e].constants.heater_power = _mpc_heater_power[e]; MPC_t &constants = thermalManager.temp_hotend[e].constants;
thermalManager.temp_hotend[e].constants.block_heat_capacity = _mpc_block_heat_capacity[e]; constants.heater_power = _mpc_heater_power[e];
thermalManager.temp_hotend[e].constants.sensor_responsiveness = _mpc_sensor_responsiveness[e]; constants.block_heat_capacity = _mpc_block_heat_capacity[e];
thermalManager.temp_hotend[e].constants.ambient_xfer_coeff_fan0 = _mpc_ambient_xfer_coeff[e]; constants.sensor_responsiveness = _mpc_sensor_responsiveness[e];
constants.ambient_xfer_coeff_fan0 = _mpc_ambient_xfer_coeff[e];
#if ENABLED(MPC_INCLUDE_FAN) #if ENABLED(MPC_INCLUDE_FAN)
thermalManager.temp_hotend[e].constants.fan255_adjustment = _mpc_ambient_xfer_coeff_fan255[e] - _mpc_ambient_xfer_coeff[e]; constants.fan255_adjustment = _mpc_ambient_xfer_coeff_fan255[e] - _mpc_ambient_xfer_coeff[e];
#endif #endif
thermalManager.temp_hotend[e].constants.filament_heat_capacity_permm = _filament_heat_capacity_permm[e]; constants.filament_heat_capacity_permm = _filament_heat_capacity_permm[e];
} }
#endif #endif

47
Marlin/src/module/temperature.cpp
View file

@ -597,7 +597,7 @@ volatile bool Temperature::raw_temps_ready = false;
millis_t next_temp_ms = millis(), t1 = next_temp_ms, t2 = next_temp_ms; millis_t next_temp_ms = millis(), t1 = next_temp_ms, t2 = next_temp_ms;
long t_high = 0, t_low = 0; long t_high = 0, t_low = 0;
PID_t tune_pid = { 0, 0, 0 }; raw_pid_t tune_pid = { 0, 0, 0 };
celsius_float_t maxT = 0, minT = 10000; celsius_float_t maxT = 0, minT = 10000;
const bool isbed = (heater_id == H_BED), const bool isbed = (heater_id == H_BED),
@ -716,16 +716,16 @@ volatile bool Temperature::raw_temps_ready = false;
pf = (ischamber || isbed) ? 0.2f : 0.6f, pf = (ischamber || isbed) ? 0.2f : 0.6f,
df = (ischamber || isbed) ? 1.0f / 3.0f : 1.0f / 8.0f; df = (ischamber || isbed) ? 1.0f / 3.0f : 1.0f / 8.0f;
tune_pid.Kp = Ku * pf; tune_pid.p = Ku * pf;
tune_pid.Ki = tune_pid.Kp * 2.0f / Tu; tune_pid.i = tune_pid.p * 2.0f / Tu;
tune_pid.Kd = tune_pid.Kp * Tu * df; tune_pid.d = tune_pid.p * Tu * df;
SERIAL_ECHOLNPGM(STR_KU, Ku, STR_TU, Tu); SERIAL_ECHOLNPGM(STR_KU, Ku, STR_TU, Tu);
if (ischamber || isbed) if (ischamber || isbed)
SERIAL_ECHOLNPGM(" No overshoot"); SERIAL_ECHOLNPGM(" No overshoot");
else else
SERIAL_ECHOLNPGM(STR_CLASSIC_PID); SERIAL_ECHOLNPGM(STR_CLASSIC_PID);
SERIAL_ECHOLNPGM(STR_KP, tune_pid.Kp, STR_KI, tune_pid.Ki, STR_KD, tune_pid.Kd); SERIAL_ECHOLNPGM(STR_KP, tune_pid.p, STR_KI, tune_pid.i, STR_KD, tune_pid.d);
} }
} }
SHV((bias + d) >> 1); SHV((bias + d) >> 1);
@ -795,39 +795,36 @@ volatile bool Temperature::raw_temps_ready = false;
#if EITHER(PIDTEMPBED, PIDTEMPCHAMBER) #if EITHER(PIDTEMPBED, PIDTEMPCHAMBER)
FSTR_P const estring = GHV(F("chamber"), F("bed"), FPSTR(NUL_STR)); FSTR_P const estring = GHV(F("chamber"), F("bed"), FPSTR(NUL_STR));
say_default_(); SERIAL_ECHOF(estring); SERIAL_ECHOLNPGM("Kp ", tune_pid.Kp); say_default_(); SERIAL_ECHOF(estring); SERIAL_ECHOLNPGM("Kp ", tune_pid.p);
say_default_(); SERIAL_ECHOF(estring); SERIAL_ECHOLNPGM("Ki ", tune_pid.Ki); say_default_(); SERIAL_ECHOF(estring); SERIAL_ECHOLNPGM("Ki ", tune_pid.i);
say_default_(); SERIAL_ECHOF(estring); SERIAL_ECHOLNPGM("Kd ", tune_pid.Kd); say_default_(); SERIAL_ECHOF(estring); SERIAL_ECHOLNPGM("Kd ", tune_pid.d);
#else #else
say_default_(); SERIAL_ECHOLNPGM("Kp ", tune_pid.Kp); say_default_(); SERIAL_ECHOLNPGM("Kp ", tune_pid.p);
say_default_(); SERIAL_ECHOLNPGM("Ki ", tune_pid.Ki); say_default_(); SERIAL_ECHOLNPGM("Ki ", tune_pid.i);
say_default_(); SERIAL_ECHOLNPGM("Kd ", tune_pid.Kd); say_default_(); SERIAL_ECHOLNPGM("Kd ", tune_pid.d);
#endif #endif
auto _set_hotend_pid = [](const uint8_t e, const PID_t &in_pid) { auto _set_hotend_pid = [](const uint8_t tool, const raw_pid_t &in_pid) {
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
PID_PARAM(Kp, e) = in_pid.Kp; #if ENABLED(PID_PARAMS_PER_HOTEND)
PID_PARAM(Ki, e) = scalePID_i(in_pid.Ki); thermalManager.temp_hotend[tool].pid.set(in_pid);
PID_PARAM(Kd, e) = scalePID_d(in_pid.Kd); #else
HOTEND_LOOP() thermalManager.temp_hotend[e].pid.set(in_pid);
#endif
updatePID(); updatePID();
#else
UNUSED(e); UNUSED(in_pid);
#endif #endif
UNUSED(tool); UNUSED(in_pid);
}; };
#if ENABLED(PIDTEMPBED) #if ENABLED(PIDTEMPBED)
auto _set_bed_pid = [](const PID_t &in_pid) { auto _set_bed_pid = [](const raw_pid_t &in_pid) {
temp_bed.pid.Kp = in_pid.Kp; temp_bed.pid.set(in_pid);
temp_bed.pid.Ki = scalePID_i(in_pid.Ki);
temp_bed.pid.Kd = scalePID_d(in_pid.Kd);
}; };
#endif #endif
#if ENABLED(PIDTEMPCHAMBER) #if ENABLED(PIDTEMPCHAMBER)
auto _set_chamber_pid = [](const PID_t &in_pid) { auto _set_chamber_pid = [](const raw_pid_t &in_pid) {
temp_chamber.pid.Kp = in_pid.Kp; temp_chamber.pid.set(in_pid);
temp_chamber.pid.Ki = scalePID_i(in_pid.Ki);
temp_chamber.pid.Kd = scalePID_d(in_pid.Kd);
}; };
#endif #endif

180
Marlin/src/module/temperature.h
View file

@ -60,53 +60,6 @@ typedef enum : int8_t {
H_NONE = -128 H_NONE = -128
} heater_id_t; } heater_id_t;
// PID storage
typedef struct { float Kp, Ki, Kd; } PID_t;
typedef struct { float Kp, Ki, Kd, Kc; } PIDC_t;
typedef struct { float Kp, Ki, Kd, Kf; } PIDF_t;
typedef struct { float Kp, Ki, Kd, Kc, Kf; } PIDCF_t;
typedef
#if BOTH(PID_EXTRUSION_SCALING, PID_FAN_SCALING)
PIDCF_t
#elif ENABLED(PID_EXTRUSION_SCALING)
PIDC_t
#elif ENABLED(PID_FAN_SCALING)
PIDF_t
#else
PID_t
#endif
hotend_pid_t;
#if ENABLED(PID_EXTRUSION_SCALING)
typedef IF<(LPQ_MAX_LEN > 255), uint16_t, uint8_t>::type lpq_ptr_t;
#endif
#define PID_PARAM(F,H) _PID_##F(TERN(PID_PARAMS_PER_HOTEND, H, 0 & H)) // Always use 'H' to suppress warning
#define _PID_Kp(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Kp, NAN)
#define _PID_Ki(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Ki, NAN)
#define _PID_Kd(H) TERN(PIDTEMP, Temperature::temp_hotend[H].pid.Kd, NAN)
#if ENABLED(PIDTEMP)
#define _PID_Kc(H) TERN(PID_EXTRUSION_SCALING, Temperature::temp_hotend[H].pid.Kc, 1)
#define _PID_Kf(H) TERN(PID_FAN_SCALING, Temperature::temp_hotend[H].pid.Kf, 0)
#else
#define _PID_Kc(H) 1
#define _PID_Kf(H) 0
#endif
#if ENABLED(MPCTEMP)
typedef struct {
float heater_power; // M306 P
float block_heat_capacity; // M306 C
float sensor_responsiveness; // M306 R
float ambient_xfer_coeff_fan0; // M306 A
#if ENABLED(MPC_INCLUDE_FAN)
float fan255_adjustment; // M306 F
#endif
float filament_heat_capacity_permm; // M306 H
} MPC_t;
#endif
/** /**
* States for ADC reading in the ISR * States for ADC reading in the ISR
*/ */
@ -188,7 +141,15 @@ enum ADCSensorState : char {
#define ACTUAL_ADC_SAMPLES _MAX(int(MIN_ADC_ISR_LOOPS), int(SensorsReady)) #define ACTUAL_ADC_SAMPLES _MAX(int(MIN_ADC_ISR_LOOPS), int(SensorsReady))
//
// PID
//
typedef struct { float p, i, d; } raw_pid_t;
typedef struct { float p, i, d, c, f; } raw_pidcf_t;
#if HAS_PID_HEATING #if HAS_PID_HEATING
#define PID_K2 (1-float(PID_K1)) #define PID_K2 (1-float(PID_K1))
#define PID_dT ((OVERSAMPLENR * float(ACTUAL_ADC_SAMPLES)) / (TEMP_TIMER_FREQUENCY)) #define PID_dT ((OVERSAMPLENR * float(ACTUAL_ADC_SAMPLES)) / (TEMP_TIMER_FREQUENCY))
@ -197,10 +158,116 @@ enum ADCSensorState : char {
#define unscalePID_i(i) ( float(i) / PID_dT ) #define unscalePID_i(i) ( float(i) / PID_dT )
#define scalePID_d(d) ( float(d) / PID_dT ) #define scalePID_d(d) ( float(d) / PID_dT )
#define unscalePID_d(d) ( float(d) * PID_dT ) #define unscalePID_d(d) ( float(d) * PID_dT )
typedef struct {
float Kp, Ki, Kd;
float p() const { return Kp; }
float i() const { return unscalePID_i(Ki); }
float d() const { return unscalePID_d(Kd); }
float c() const { return 1; }
float f() const { return 0; }
void set_Kp(float p) { Kp = p; }
void set_Ki(float i) { Ki = scalePID_i(i); }
void set_Kd(float d) { Kd = scalePID_d(d); }
void set_Kc(float) {}
void set_Kf(float) {}
void set(float p, float i, float d, float c=1, float f=0) { set_Kp(p); set_Ki(i); set_Kd(d); UNUSED(c); UNUSED(f); }
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d); }
} PID_t;
#endif #endif
#if ENABLED(MPCTEMP) #if ENABLED(PIDTEMP)
typedef struct {
float Kp, Ki, Kd, Kc;
float p() const { return Kp; }
float i() const { return unscalePID_i(Ki); }
float d() const { return unscalePID_d(Kd); }
float c() const { return Kc; }
float f() const { return 0; }
void set_Kp(float p) { Kp = p; }
void set_Ki(float i) { Ki = scalePID_i(i); }
void set_Kd(float d) { Kd = scalePID_d(d); }
void set_Kc(float c) { Kc = c; }
void set_Kf(float) {}
void set(float p, float i, float d, float c=1, float f=0) { set_Kp(p); set_Ki(i); set_Kd(d); set_Kc(c); set_Kf(f); }
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c); }
} PIDC_t;
typedef struct {
float Kp, Ki, Kd, Kf;
float p() const { return Kp; }
float i() const { return unscalePID_i(Ki); }
float d() const { return unscalePID_d(Kd); }
float c() const { return 1; }
float f() const { return Kf; }
void set_Kp(float p) { Kp = p; }
void set_Ki(float i) { Ki = scalePID_i(i); }
void set_Kd(float d) { Kd = scalePID_d(d); }
void set_Kc(float) {}
void set_Kf(float f) { Kf = f; }
void set(float p, float i, float d, float c=1, float f=0) { set_Kp(p); set_Ki(i); set_Kd(d); set_Kf(f); }
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.f); }
} PIDF_t;
typedef struct {
float Kp, Ki, Kd, Kc, Kf;
float p() const { return Kp; }
float i() const { return unscalePID_i(Ki); }
float d() const { return unscalePID_d(Kd); }
float c() const { return Kc; }
float f() const { return Kf; }
void set_Kp(float p) { Kp = p; }
void set_Ki(float i) { Ki = scalePID_i(i); }
void set_Kd(float d) { Kd = scalePID_d(d); }
void set_Kc(float c) { Kc = c; }
void set_Kf(float f) { Kf = f; }
void set(float p, float i, float d, float c=1, float f=0) { set_Kp(p); set_Ki(i); set_Kd(d); set_Kc(c); set_Kf(f); }
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); }
} PIDCF_t;
typedef
#if BOTH(PID_EXTRUSION_SCALING, PID_FAN_SCALING)
PIDCF_t
#elif ENABLED(PID_EXTRUSION_SCALING)
PIDC_t
#elif ENABLED(PID_FAN_SCALING)
PIDF_t
#else
PID_t
#endif
hotend_pid_t;
#if ENABLED(PID_EXTRUSION_SCALING)
typedef IF<(LPQ_MAX_LEN > 255), uint16_t, uint8_t>::type lpq_ptr_t;
#endif
#if ENABLED(PID_PARAMS_PER_HOTEND)
#define SET_HOTEND_PID(F,H,V) thermalManager.temp_hotend[H].pid.set_##F(V)
#else
#define SET_HOTEND_PID(F,_,V) do{ HOTEND_LOOP() thermalManager.temp_hotend[e].pid.set_##F(V); }while(0)
#endif
#elif ENABLED(MPCTEMP)
typedef struct {
float heater_power; // M306 P
float block_heat_capacity; // M306 C
float sensor_responsiveness; // M306 R
float ambient_xfer_coeff_fan0; // M306 A
#if ENABLED(MPC_INCLUDE_FAN)
float fan255_adjustment; // M306 F
#endif
float filament_heat_capacity_permm; // M306 H
} MPC_t;
#define MPC_dT ((OVERSAMPLENR * float(ACTUAL_ADC_SAMPLES)) / (TEMP_TIMER_FREQUENCY)) #define MPC_dT ((OVERSAMPLENR * float(ACTUAL_ADC_SAMPLES)) / (TEMP_TIMER_FREQUENCY))
#endif #endif
#if ENABLED(G26_MESH_VALIDATION) && EITHER(HAS_MARLINUI_MENU, EXTENSIBLE_UI) #if ENABLED(G26_MESH_VALIDATION) && EITHER(HAS_MARLINUI_MENU, EXTENSIBLE_UI)
@ -218,7 +285,7 @@ public:
inline void sample(const raw_adc_t s) { acc += s; } inline void sample(const raw_adc_t s) { acc += s; }
inline void update() { raw = acc; } inline void update() { raw = acc; }
void setraw(const raw_adc_t r) { raw = r; } void setraw(const raw_adc_t r) { raw = r; }
raw_adc_t getraw() { return raw; } raw_adc_t getraw() const { return raw; }
} temp_info_t; } temp_info_t;
#if HAS_TEMP_REDUNDANT #if HAS_TEMP_REDUNDANT
@ -393,6 +460,7 @@ class Temperature {
static const celsius_t hotend_maxtemp[HOTENDS]; static const celsius_t hotend_maxtemp[HOTENDS];
static celsius_t hotend_max_target(const uint8_t e) { return hotend_maxtemp[e] - (HOTEND_OVERSHOOT); } static celsius_t hotend_max_target(const uint8_t e) { return hotend_maxtemp[e] - (HOTEND_OVERSHOOT); }
#endif #endif
#if HAS_HEATED_BED #if HAS_HEATED_BED
static bed_info_t temp_bed; static bed_info_t temp_bed;
#endif #endif
@ -965,12 +1033,16 @@ class Temperature {
static constexpr bool adaptive_fan_slowing = true; static constexpr bool adaptive_fan_slowing = true;
#endif #endif
/** // Update the temp manager when PID values change
* Update the temp manager when PID values change
*/
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
static void updatePID() { static void updatePID() { TERN_(PID_EXTRUSION_SCALING, pes_e_position = 0); }
TERN_(PID_EXTRUSION_SCALING, pes_e_position = 0); static void setPID(const uint8_t hotend, const_float_t p, const_float_t i, const_float_t d) {
#if ENABLED(PID_PARAMS_PER_HOTEND)
temp_hotend[hotend].pid.set(p, i, d);
#else
HOTEND_LOOP() temp_hotend[e].pid.set(p, i, d);
#endif
updatePID();
} }
#endif #endif

2
buildroot/tests/rambo
View file

@ -23,7 +23,7 @@ opt_enable USE_ZMAX_PLUG REPRAP_DISCOUNT_SMART_CONTROLLER LCD_PROGRESS_BAR LCD_P
EEPROM_SETTINGS SDSUPPORT SD_REPRINT_LAST_SELECTED_FILE BINARY_FILE_TRANSFER \ EEPROM_SETTINGS SDSUPPORT SD_REPRINT_LAST_SELECTED_FILE BINARY_FILE_TRANSFER \
BLINKM PCA9533 PCA9632 RGB_LED RGB_LED_R_PIN RGB_LED_G_PIN RGB_LED_B_PIN LED_CONTROL_MENU \ BLINKM PCA9533 PCA9632 RGB_LED RGB_LED_R_PIN RGB_LED_G_PIN RGB_LED_B_PIN LED_CONTROL_MENU \
NEOPIXEL_LED NEOPIXEL_PIN CASE_LIGHT_ENABLE CASE_LIGHT_USE_NEOPIXEL CASE_LIGHT_MENU \ NEOPIXEL_LED NEOPIXEL_PIN CASE_LIGHT_ENABLE CASE_LIGHT_USE_NEOPIXEL CASE_LIGHT_MENU \
PID_PARAMS_PER_HOTEND PID_AUTOTUNE_MENU PID_EDIT_MENU LCD_SHOW_E_TOTAL \ PID_PARAMS_PER_HOTEND PID_AUTOTUNE_MENU PID_EDIT_MENU PID_EXTRUSION_SCALING LCD_SHOW_E_TOTAL \
PRINTCOUNTER SERVICE_NAME_1 SERVICE_INTERVAL_1 LCD_BED_TRAMMING BED_TRAMMING_INCLUDE_CENTER \ PRINTCOUNTER SERVICE_NAME_1 SERVICE_INTERVAL_1 LCD_BED_TRAMMING BED_TRAMMING_INCLUDE_CENTER \
NOZZLE_PARK_FEATURE FILAMENT_RUNOUT_SENSOR FILAMENT_RUNOUT_DISTANCE_MM \ NOZZLE_PARK_FEATURE FILAMENT_RUNOUT_SENSOR FILAMENT_RUNOUT_DISTANCE_MM \
ADVANCED_PAUSE_FEATURE FILAMENT_LOAD_UNLOAD_GCODES FILAMENT_UNLOAD_ALL_EXTRUDERS \ ADVANCED_PAUSE_FEATURE FILAMENT_LOAD_UNLOAD_GCODES FILAMENT_UNLOAD_ALL_EXTRUDERS \