From 6860a572c2744a8f3519b470b3f86e0d98b90182 Mon Sep 17 00:00:00 2001 From: DRracer Date: Tue, 23 Jul 2019 15:55:53 +0200 Subject: [PATCH 01/24] detection of faulty RAMBo (incorrect capacitor on fan tach pin) for MK3/S --- Firmware/Marlin_main.cpp | 52 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 7f2efe35..b5b0ad1e 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -3274,6 +3274,56 @@ static void gcode_PRUSA_SN() puts_P(_N("Not in farm mode.")); } } +//! Detection of faulty RAMBo 1.1b boards equipped with bigger capacitors +//! at the TACH_1 pin, which causes bad detection of print fan speed. +//! Warning: This function is not to be used by ordinary users, it is here only for automated testing purposes, +//! it may even interfere with other functions of the printer! You have been warned! +//! The test idea is to measure the time necessary to charge the capacitor. +//! So the algorithm is as follows: +//! 1. Set TACH_1 pin to INPUT mode and LOW +//! 2. Wait a few ms +//! 3. disable interrupts and measure the time until the TACH_1 pin reaches HIGH +//! Repeat 1.-3. several times +//! Good RAMBo's times are in the range of approx. 260-320 us +//! Bad RAMBo's times are approx. 260-1200 us +//! So basically we are interested in maximum time, the minima are mostly the same. +//! May be that's why the bad RAMBo's still produce some fan RPM reading, but not corresponding to reality +static void gcode_PRUSA_BadRAMBoFanTest(){ + //printf_P(PSTR("Enter fan pin test\n")); +#if !defined(DEBUG_DISABLE_FANCHECK) && defined(FANCHECK) && defined(TACH_1) && TACH_1 >-1 + fan_measuring = false; // prevent EXTINT7 breaking into the measurement + unsigned long tach1max = 0; + uint8_t tach1cntr = 0; + for( /* nothing */; tach1cntr < 100; ++tach1cntr){ + //printf_P(PSTR("TACH_1: %d\n"), tach1cntr); + SET_OUTPUT(TACH_1); + WRITE(TACH_1, LOW); + delay2(20); // the delay may be lower + unsigned long tachMeasure = micros2(); + cli(); + SET_INPUT(TACH_1); + // just wait brutally in an endless cycle until we reach HIGH + // if this becomes a problem it may be improved to non-endless cycle + while( READ(TACH_1) == 0 ) ; + sei(); + tachMeasure = micros2() - tachMeasure; + if( tach1max < tachMeasure ) + tach1max = tachMeasure; + //printf_P(PSTR("TACH_1: %d: capacitor check time=%lu us\n"), (int)tach1cntr, tachMeasure); + } + //printf_P(PSTR("TACH_1: max=%lu us\n"), tach1max); + SERIAL_PROTOCOLPGM("RAMBo FAN "); + if( tach1max > 500 ){ + // bad RAMBo + SERIAL_PROTOCOLLNPGM("BAD"); + } else { + SERIAL_PROTOCOLLNPGM("OK"); + } + // cleanup after the test function + SET_INPUT(TACH_1); + WRITE(TACH_1, HIGH); +#endif +} #ifdef BACKLASH_X extern uint8_t st_backlash_x; @@ -3559,6 +3609,8 @@ void process_commands() else if (code_seen("PRN")) { //! PRUSA PRN printf_P(_N("%d"), status_number); + } else if( code_seen("FANPINTST") ){ + gcode_PRUSA_BadRAMBoFanTest(); }else if (code_seen("FAN")) { //! PRUSA FAN printf_P(_N("E0:%d RPM\nPRN0:%d RPM\n"), 60*fan_speed[0], 60*fan_speed[1]); }else if (code_seen("fn")) { //! PRUSA fn From 593675c667ea6075df27412977a1ce54d589e589 Mon Sep 17 00:00:00 2001 From: DRracer Date: Tue, 23 Jul 2019 16:40:21 +0200 Subject: [PATCH 02/24] delay, micros for the 3.7.x branch --- Firmware/Marlin_main.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index b5b0ad1e..bdfb29d2 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -3298,15 +3298,15 @@ static void gcode_PRUSA_BadRAMBoFanTest(){ //printf_P(PSTR("TACH_1: %d\n"), tach1cntr); SET_OUTPUT(TACH_1); WRITE(TACH_1, LOW); - delay2(20); // the delay may be lower - unsigned long tachMeasure = micros2(); + delay(20); // the delay may be lower + unsigned long tachMeasure = micros(); cli(); SET_INPUT(TACH_1); // just wait brutally in an endless cycle until we reach HIGH // if this becomes a problem it may be improved to non-endless cycle while( READ(TACH_1) == 0 ) ; sei(); - tachMeasure = micros2() - tachMeasure; + tachMeasure = micros() - tachMeasure; if( tach1max < tachMeasure ) tach1max = tachMeasure; //printf_P(PSTR("TACH_1: %d: capacitor check time=%lu us\n"), (int)tach1cntr, tachMeasure); From 3e60cf453752bf40b291ca1d0a9bd6b28b3746a7 Mon Sep 17 00:00:00 2001 From: DRracer Date: Tue, 23 Jul 2019 16:51:02 +0200 Subject: [PATCH 03/24] enable only for MK3S (out of FLASH on the MK3) --- Firmware/Marlin_main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index bdfb29d2..16a1b66b 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -3290,7 +3290,7 @@ static void gcode_PRUSA_SN() //! May be that's why the bad RAMBo's still produce some fan RPM reading, but not corresponding to reality static void gcode_PRUSA_BadRAMBoFanTest(){ //printf_P(PSTR("Enter fan pin test\n")); -#if !defined(DEBUG_DISABLE_FANCHECK) && defined(FANCHECK) && defined(TACH_1) && TACH_1 >-1 +#if !defined(DEBUG_DISABLE_FANCHECK) && defined(FANCHECK) && defined(TACH_1) && TACH_1 >-1 && defined(IR_SENSOR) fan_measuring = false; // prevent EXTINT7 breaking into the measurement unsigned long tach1max = 0; uint8_t tach1cntr = 0; From cb19f0958b5716f255c0a150b7e67a7673f48c80 Mon Sep 17 00:00:00 2001 From: DRracer Date: Mon, 5 Aug 2019 09:51:06 +0200 Subject: [PATCH 04/24] Use _delay() and _micros() for future compatibility --- Firmware/Marlin_main.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 16a1b66b..0df61045 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -3298,15 +3298,15 @@ static void gcode_PRUSA_BadRAMBoFanTest(){ //printf_P(PSTR("TACH_1: %d\n"), tach1cntr); SET_OUTPUT(TACH_1); WRITE(TACH_1, LOW); - delay(20); // the delay may be lower - unsigned long tachMeasure = micros(); + _delay(20); // the delay may be lower + unsigned long tachMeasure = _micros(); cli(); SET_INPUT(TACH_1); // just wait brutally in an endless cycle until we reach HIGH // if this becomes a problem it may be improved to non-endless cycle while( READ(TACH_1) == 0 ) ; sei(); - tachMeasure = micros() - tachMeasure; + tachMeasure = _micros() - tachMeasure; if( tach1max < tachMeasure ) tach1max = tachMeasure; //printf_P(PSTR("TACH_1: %d: capacitor check time=%lu us\n"), (int)tach1cntr, tachMeasure); From 7da2ee5fc3bd1e40847bbddbf101aff781637a5d Mon Sep 17 00:00:00 2001 From: Robert Pelnar Date: Tue, 6 Aug 2019 15:37:23 +0200 Subject: [PATCH 05/24] Version changed (3.7.3 build 2370) --- Firmware/Configuration.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Firmware/Configuration.h b/Firmware/Configuration.h index acdadfe7..4cd69697 100644 --- a/Firmware/Configuration.h +++ b/Firmware/Configuration.h @@ -7,8 +7,8 @@ #define STR(x) STR_HELPER(x) // Firmware version -#define FW_VERSION "3.7.2" -#define FW_COMMIT_NR 2363 +#define FW_VERSION "3.7.3" +#define FW_COMMIT_NR 2370 // FW_VERSION_UNKNOWN means this is an unofficial build. // The firmware should only be checked into github with this symbol. #define FW_DEV_VERSION FW_VERSION_UNKNOWN From 2ddbd606f2e9a803a0eac396698e14655e9879c9 Mon Sep 17 00:00:00 2001 From: DRracer Date: Thu, 8 Aug 2019 16:44:16 +0200 Subject: [PATCH 06/24] Version changed (3.8.0 build 2608) --- Firmware/Configuration.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Firmware/Configuration.h b/Firmware/Configuration.h index 7a782d71..870eee89 100644 --- a/Firmware/Configuration.h +++ b/Firmware/Configuration.h @@ -16,8 +16,8 @@ extern uint16_t nPrinterType; extern PGM_P sPrinterName; // Firmware version -#define FW_VERSION "3.7.2" -#define FW_COMMIT_NR 2363 +#define FW_VERSION "3.8.0" +#define FW_COMMIT_NR 2608 // FW_VERSION_UNKNOWN means this is an unofficial build. // The firmware should only be checked into github with this symbol. #define FW_DEV_VERSION FW_VERSION_UNKNOWN From dc78bc7362be3236ad8d63c261a48d99fc4388c8 Mon Sep 17 00:00:00 2001 From: DRracer Date: Wed, 14 Aug 2019 17:53:08 +0200 Subject: [PATCH 07/24] Improve performance of bed PWM automaton - proof of concept There are still some artefacts on the output pin - work in progress. --- Firmware/heatbed_pwm.cpp | 215 ++++++++++++++++++++++++++------------- Firmware/timer02.c | 2 +- 2 files changed, 144 insertions(+), 73 deletions(-) diff --git a/Firmware/heatbed_pwm.cpp b/Firmware/heatbed_pwm.cpp index 8a913b63..a3e5444c 100755 --- a/Firmware/heatbed_pwm.cpp +++ b/Firmware/heatbed_pwm.cpp @@ -19,91 +19,162 @@ // So the automaton runs atop of inner 8 (or 16) cycles. // The finite automaton is running in the ISR(TIMER0_OVF_vect) +// 2019-08-14 update: the original algorithm worked very well, however there were 2 regressions: +// 1. 62kHz ISR requires considerable amount of processing power, +// USB transfer speed dropped by 20%, which was most notable when doing short G-code segments. +// 2. Some users reported TLed PSU started clicking when running at 120V/60Hz. +// This looks like the original algorithm didn't maintain base PWM 30Hz, but only 15Hz +// To address both issues, there is an improved approach based on the idea of leveraging +// different CLK prescalers in some automaton states - i.e. when holding LOW or HIGH on the output pin, +// we don't have to clock 62kHz, but we can increase the CLK prescaler for these states to 8 (or even 64). +// That shall result in the ISR not being called that much resulting in regained performance +// Theoretically this is relatively easy, however one must be very carefull handling the AVR's timer +// control registers correctly, especially setting them in a correct order. +// Some registers are double buffered, some changes are applied in next cycles etc. +// The biggest problem was with the CLK prescaler itself - this circuit is shared among almost all timers, +// we don't want to reset the prescaler counted value when transiting among automaton states. +// Resetting the prescaler would make the PWM more precise, right now there are temporal segments +// of variable period ranging from 0 to 7 62kHz ticks - that's logical, the timer must "sync" +// to the new slower CLK after setting the slower prescaler value. +// In our application, this isn't any significant problem and may be ignored. +// Doing changes in timer's registers non-correctly results in artefacts on the output pin +// - it can toggle unnoticed, which will result in bed clicking again. +// That's why there are special transition states ZERO_TO_RISE and ONE_TO_FALL, which enable the +// counter change its operation atomically and without artefacts on the output pin. +// The resulting signal on the output pin was checked with an osciloscope. +// If there are any change requirements in the future, the signal must be checked with an osciloscope again, +// ad-hoc changes may completely screw things up! + ///! Definition off finite automaton states enum class States : uint8_t { - ZERO = 0, - RISE = 1, - ONE = 2, - FALL = 3 -}; - -///! State table for the inner part of the finite automaton -///! Basically it specifies what shall happen if the outer automaton is requesting setting the heat pin to 0 (OFF) or 1 (ON) -///! ZERO: steady 0 (OFF), no change for the whole period -///! RISE: 8 (16) fast PWM cycles with increasing duty up to steady ON -///! ONE: steady 1 (ON), no change for the whole period -///! FALL: 8 (16) fast PWM cycles with decreasing duty down to steady OFF -///! @@TODO move it into progmem -static States stateTable[4*2] = { -// off on -States::ZERO, States::RISE, // ZERO -States::FALL, States::ONE, // RISE -States::FALL, States::ONE, // ONE -States::ZERO, States::RISE // FALL + ZERO_START = 0,///< entry point of the automaton - reads the soft_pwm_bed value for the next whole PWM cycle + ZERO, ///< steady 0 (OFF), no change for the whole period + ZERO_TO_RISE, ///< metastate allowing the timer change its state atomically without artefacts on the output pin + RISE, ///< 16 fast PWM cycles with increasing duty up to steady ON + RISE_TO_ONE, ///< metastate allowing the timer change its state atomically without artefacts on the output pin + ONE, ///< steady 1 (ON), no change for the whole period + ONE_TO_FALL, ///< metastate allowing the timer change its state atomically without artefacts on the output pin + FALL, ///< 16 fast PWM cycles with decreasing duty down to steady OFF + FALL_TO_ZERO ///< metastate allowing the timer change its state atomically without artefacts on the output pin }; ///! Inner states of the finite automaton -static States state = States::ZERO; +static States state = States::ZERO_START; -///! Inner and outer PWM counters -static uint8_t outer = 0; -static uint8_t inner = 0; +///! Fast PWM counter is used in the RISE and FALL states (62.5kHz) +static uint8_t slowCounter = 0; +///! Slow PWM counter is used in the ZERO and ONE states (62.5kHz/8 or 64) +static uint8_t fastCounter = 0; +///! PWM counter for the whole cycle - a cache for soft_pwm_bed static uint8_t pwm = 0; -///! the slow PWM duty for the next 30Hz cycle +///! The slow PWM duty for the next 30Hz cycle ///! Set in the whole firmware at various places extern unsigned char soft_pwm_bed; -/// Fine tuning of automaton cycles -#if 1 -static const uint8_t innerMax = 16; -static const uint8_t innerShift = 4; -#else -static const uint8_t innerMax = 8; -static const uint8_t innerShift = 5; -#endif +/// fastMax - how many fast PWM steps to do in RISE and FALL states +/// 16 is a good compromise between silenced bed ("smooth" edges) +/// and not burning the switching MOSFET +static const uint8_t fastMax = 16; + +/// Scaler 16->256 for fast PWM +static const uint8_t fastShift = 4; + +/// Increment slow PWM counter by slowInc every ZERO or ONE state +/// This allows for fine-tuning the basic PWM switching frequency +/// A possible further optimization - use a 64 prescaler (instead of 8) +/// increment slowCounter by 1 +/// but use less bits of soft PWM - something like soft_pwm_bed >> 2 +/// that may further reduce the CPU cycles required by the bed heating automaton +/// Due to the nature of bed heating the reduced PID precision may not be a major issue, however doing 8x less ISR(timer0_ovf) may significantly improve the performance +static const uint8_t slowInc = 1; ISR(TIMER0_OVF_vect) // timer compare interrupt service routine { - if( inner ){ - switch(state){ - case States::ZERO: - OCR0B = 255; - // Commenting the following code saves 6B, but it is left here for reference - // It is not necessary to set it all over again, because we can only get into the ZERO state from the FALL state (which sets this register) -// TCCR0A |= (1 << COM0B1) | (1 << COM0B0); - break; - case States::RISE: - OCR0B = (innerMax - inner) << innerShift; -// TCCR0A |= (1 << COM0B1); // this bit is always 1 - TCCR0A &= ~(1 << COM0B0); - break; - case States::ONE: - OCR0B = 255; - // again - may be skipped, because we get into the ONE state only from RISE (which sets this register) -// TCCR0A |= (1 << COM0B1); - TCCR0A &= ~(1 << COM0B0); - break; - case States::FALL: - OCR0B = (innerMax - inner) << innerShift; // this is the same as in RISE, because now we are setting the zero part of duty due to inverting mode - // must switch to inverting mode already here, because it takes a whole PWM cycle and it would make a "1" at the end of this pwm cycle - TCCR0A |= /*(1 << COM0B1) |*/ (1 << COM0B0); - break; + switch(state){ + case States::ZERO_START: + pwm = soft_pwm_bed << 1;// expecting soft_pwm_bed to be 7bit! + if( pwm != 0 ){ + state = States::ZERO; // do nothing, let it tick once again after the 30Hz period + } + break; + case States::ZERO: // end of state ZERO - we'll either stay in ZERO or change to RISE + // In any case update our cache of pwm value for the next whole cycle from soft_pwm_bed + slowCounter += slowInc; // this does software timer_clk/256 or less (depends on slowInc) + if( slowCounter > pwm ){ + return; + } // otherwise moving towards RISE + state = States::ZERO_TO_RISE; // and finalize the change in a transitional state RISE0 + break; + // even though it may look like the ZERO state may be glued together with the ZERO_TO_RISE, don't do it + // the timer must tick once more in order to get rid of occasional output pin toggles. + case States::ZERO_TO_RISE: // special state for handling transition between prescalers and switching inverted->non-inverted fast-PWM without toggling the output pin. + // It must be done in consequent steps, otherwise the pin will get flipped up and down during one PWM cycle. + // Also beware of the correct sequence of the following timer control registers initialization - it really matters! + state = States::RISE; // prepare for standard RISE cycles + fastCounter = fastMax - 1;// we'll do 16-1 cycles of RISE + TCNT0 = 255; // force overflow on the next clock cycle + TCCR0B = (1 << CS00); // change prescaler to 1, i.e. 62.5kHz + TCCR0A &= ~(1 << COM0B0); // Clear OC0B on Compare Match, set OC0B at BOTTOM (non-inverting mode) + break; + case States::RISE: + OCR0B = (fastMax - fastCounter) << fastShift; + if( fastCounter ){ + --fastCounter; + } else { // end of RISE cycles, changing into state ONE + state = States::RISE_TO_ONE; + OCR0B = 255; // full duty + TCNT0 = 254; // make the timer overflow in the next cycle + // @@TODO these constants are still subject to investigation + } + break; + case States::RISE_TO_ONE: + state = States::ONE; + OCR0B = 255; // full duty + TCNT0 = 255; // make the timer overflow in the next cycle + TCCR0B = (1 << CS01); // change prescaler to 8, i.e. 7.8kHz + break; + case States::ONE: // state ONE - we'll either stay in ONE or change to FALL + OCR0B = 255; + slowCounter += slowInc; // this does software timer_clk/256 or less + if( slowCounter < pwm ){ + return; + } + if( (soft_pwm_bed << 1) >= (255 - slowInc - 1) ){ //@@TODO simplify & explain + // if slowInc==2, soft_pwm == 251 will be the first to do short drops to zero. 252 will keep full heating + return; // want full duty for the next ONE cycle again - so keep on heating and just wait for the next timer ovf + } + // otherwise moving towards FALL + // @@TODO it looks like ONE_TO_FALL isn't necessary, there are no artefacts at all + state = States::ONE;//_TO_FALL; +// TCCR0B = (1 << CS00); // change prescaler to 1, i.e. 62.5kHz +// break; +// case States::ONE_TO_FALL: +// OCR0B = 255; // zero duty + state=States::FALL; + fastCounter = fastMax - 1;// we'll do 16-1 cycles of RISE + TCNT0 = 255; // force overflow on the next clock cycle + TCCR0B = (1 << CS00); // change prescaler to 1, i.e. 62.5kHz + // must switch to inverting mode already here, because it takes a whole PWM cycle and it would make a "1" at the end of this pwm cycle + // COM0B1 remains set both in inverting and non-inverting mode + TCCR0A |= (1 << COM0B0); // inverting mode + break; + case States::FALL: + OCR0B = (fastMax - fastCounter) << fastShift; // this is the same as in RISE, because now we are setting the zero part of duty due to inverting mode + //TCCR0A |= (1 << COM0B0); // already set in ONE_TO_FALL + if( fastCounter ){ + --fastCounter; + } else { // end of FALL cycles, changing into state ZERO + state = States::FALL_TO_ZERO; + TCNT0 = 128; //@@TODO again - need to wait long enough to propagate the timer state changes + OCR0B = 255; + } + break; + case States::FALL_TO_ZERO: + state = States::ZERO_START; // go to read new soft_pwm_bed value for the next cycle + TCNT0 = 128; + OCR0B = 255; + TCCR0B = (1 << CS01); // change prescaler to 8, i.e. 7.8kHz + break; } - --inner; - } else { - if( ! outer ){ // at the end of 30Hz PWM period - // synchro is not needed (almost), soft_pwm_bed is just 1 byte, 1-byte write instruction is atomic - pwm = soft_pwm_bed << 1; - } - if( pwm > outer || pwm >= 254 ){ - // soft_pwm_bed has a range of 0-127, that why a <<1 is done here. That also means that we may get only up to 254 which we want to be full-time 1 (ON) - state = stateTable[ uint8_t(state) * 2 + 1 ]; - } else { - // switch OFF - state = stateTable[ uint8_t(state) * 2 + 0 ]; - } - ++outer; - inner = innerMax; - } } diff --git a/Firmware/timer02.c b/Firmware/timer02.c index 6b6cbe2c..e2f696c9 100644 --- a/Firmware/timer02.c +++ b/Firmware/timer02.c @@ -26,7 +26,7 @@ void timer0_init(void) OCR0B = 255; // Set fast PWM mode and inverting mode. TCCR0A = (1 << WGM01) | (1 << WGM00) | (1 << COM0B1) | (1 << COM0B0); - TCCR0B = (1 << CS00); // no clock prescaling + TCCR0B = (1 << CS01); // CLK/8 prescaling TIMSK0 |= (1 << TOIE0); // enable timer overflow interrupt // Everything, that used to be on timer0 was moved to timer2 (delay, beeping, millis etc.) From 36a69281ee0debe814a71598126b003ce64159f5 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Thu, 15 Aug 2019 17:36:05 +0200 Subject: [PATCH 08/24] Remove unused functions forward declarations. --- Firmware/ultralcd.cpp | 7 ------- 1 file changed, 7 deletions(-) diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index ac8a302f..d8290a50 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -120,14 +120,7 @@ static void lcd_tune_menu(); //static void lcd_move_menu(); static void lcd_settings_menu(); static void lcd_calibration_menu(); -#ifdef LINEARITY_CORRECTION -static void lcd_settings_menu_back(); -#endif //LINEARITY_CORRECTION static void lcd_control_temperature_menu(); -static void lcd_control_temperature_preheat_pla_settings_menu(); -static void lcd_control_temperature_preheat_abs_settings_menu(); -static void lcd_control_motion_menu(); -static void lcd_control_volumetric_menu(); static void lcd_settings_linearity_correction_menu_save(); static void prusa_stat_printerstatus(int _status); static void prusa_stat_farm_number(); From eb68bb9b43d7e6ce582c399466ae20c25a28fa46 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Thu, 15 Aug 2019 17:46:29 +0200 Subject: [PATCH 09/24] Add ASA preheat. --- Firmware/ultralcd.cpp | 11 +++++++++++ Firmware/variants/1_75mm_MK2-RAMBo10a-E3Dv6full.h | 6 +++++- Firmware/variants/1_75mm_MK2-RAMBo13a-E3Dv6full.h | 4 ++++ Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h | 4 ++++ Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h | 4 ++++ Firmware/variants/1_75mm_MK25S-RAMBo10a-E3Dv6full.h | 4 ++++ Firmware/variants/1_75mm_MK25S-RAMBo13a-E3Dv6full.h | 4 ++++ Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h | 4 ++++ Firmware/variants/1_75mm_MK3S-EINSy10a-E3Dv6full.h | 4 ++++ 9 files changed, 44 insertions(+), 1 deletion(-) diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index d8290a50..33a4257e 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -1697,6 +1697,16 @@ void lcd_preheat_pla() if (wizard_active) lcd_wizard(WizState::Unload); } +void lcd_preheat_asa() +{ + setTargetHotend0(ASA_PREHEAT_HOTEND_TEMP); + if (!wizard_active) setTargetBed(ASA_PREHEAT_HPB_TEMP); + fanSpeed = ASA_PREHEAT_FAN_SPEED; + lcd_return_to_status(); + setWatch(); // heater sanity check timer + if (wizard_active) lcd_wizard(WizState::Unload); +} + void lcd_preheat_abs() { setTargetHotend0(ABS_PREHEAT_HOTEND_TEMP); @@ -2030,6 +2040,7 @@ static void lcd_preheat_menu() } else { MENU_ITEM_FUNCTION_P(PSTR("PLA - " STRINGIFY(PLA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PLA_PREHEAT_HPB_TEMP)), lcd_preheat_pla); MENU_ITEM_FUNCTION_P(PSTR("PET - " STRINGIFY(PET_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PET_PREHEAT_HPB_TEMP)), lcd_preheat_pet); + MENU_ITEM_FUNCTION_P(PSTR("ASA - " STRINGIFY(ASA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ASA_PREHEAT_HPB_TEMP)), lcd_preheat_pet); MENU_ITEM_FUNCTION_P(PSTR("ABS - " STRINGIFY(ABS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ABS_PREHEAT_HPB_TEMP)), lcd_preheat_abs); MENU_ITEM_FUNCTION_P(PSTR("HIPS - " STRINGIFY(HIPS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(HIPS_PREHEAT_HPB_TEMP)), lcd_preheat_hips); MENU_ITEM_FUNCTION_P(PSTR("PP - " STRINGIFY(PP_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PP_PREHEAT_HPB_TEMP)), lcd_preheat_pp); diff --git a/Firmware/variants/1_75mm_MK2-RAMBo10a-E3Dv6full.h b/Firmware/variants/1_75mm_MK2-RAMBo10a-E3Dv6full.h index 442e8b94..2539e82c 100644 --- a/Firmware/variants/1_75mm_MK2-RAMBo10a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK2-RAMBo10a-E3Dv6full.h @@ -324,7 +324,11 @@ PREHEAT SETTINGS #define PLA_PREHEAT_HOTEND_TEMP 215 #define PLA_PREHEAT_HPB_TEMP 55 -#define PLA_PREHEAT_FAN_SPEED 0 +#define PLA_PREHEAT_FAN_SPEED 0 + +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 diff --git a/Firmware/variants/1_75mm_MK2-RAMBo13a-E3Dv6full.h b/Firmware/variants/1_75mm_MK2-RAMBo13a-E3Dv6full.h index 44fee01e..fbbc332d 100644 --- a/Firmware/variants/1_75mm_MK2-RAMBo13a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK2-RAMBo13a-E3Dv6full.h @@ -325,6 +325,10 @@ PREHEAT SETTINGS #define PLA_PREHEAT_HPB_TEMP 55 #define PLA_PREHEAT_FAN_SPEED 0 +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 + #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 #define ABS_PREHEAT_FAN_SPEED 0 diff --git a/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h b/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h index a979503a..d0d0341c 100644 --- a/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h @@ -383,6 +383,10 @@ #define PLA_PREHEAT_HPB_TEMP 60 #define PLA_PREHEAT_FAN_SPEED 0 +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 + #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 #define ABS_PREHEAT_FAN_SPEED 0 diff --git a/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h b/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h index bb897fd7..c931b7db 100644 --- a/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h @@ -384,6 +384,10 @@ #define PLA_PREHEAT_HPB_TEMP 60 #define PLA_PREHEAT_FAN_SPEED 0 +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 + #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 #define ABS_PREHEAT_FAN_SPEED 0 diff --git a/Firmware/variants/1_75mm_MK25S-RAMBo10a-E3Dv6full.h b/Firmware/variants/1_75mm_MK25S-RAMBo10a-E3Dv6full.h index 8425dfd7..c5df948c 100644 --- a/Firmware/variants/1_75mm_MK25S-RAMBo10a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK25S-RAMBo10a-E3Dv6full.h @@ -383,6 +383,10 @@ #define PLA_PREHEAT_HPB_TEMP 60 #define PLA_PREHEAT_FAN_SPEED 0 +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 + #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 #define ABS_PREHEAT_FAN_SPEED 0 diff --git a/Firmware/variants/1_75mm_MK25S-RAMBo13a-E3Dv6full.h b/Firmware/variants/1_75mm_MK25S-RAMBo13a-E3Dv6full.h index 525c2206..cc2498d6 100644 --- a/Firmware/variants/1_75mm_MK25S-RAMBo13a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK25S-RAMBo13a-E3Dv6full.h @@ -384,6 +384,10 @@ #define PLA_PREHEAT_HPB_TEMP 60 #define PLA_PREHEAT_FAN_SPEED 0 +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 + #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 #define ABS_PREHEAT_FAN_SPEED 0 diff --git a/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h b/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h index b3828ce5..b2b26617 100644 --- a/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h @@ -493,6 +493,10 @@ #define PLA_PREHEAT_HPB_TEMP 60 #define PLA_PREHEAT_FAN_SPEED 0 +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 + #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 #define ABS_PREHEAT_FAN_SPEED 0 diff --git a/Firmware/variants/1_75mm_MK3S-EINSy10a-E3Dv6full.h b/Firmware/variants/1_75mm_MK3S-EINSy10a-E3Dv6full.h index 5f1009a5..5736b632 100644 --- a/Firmware/variants/1_75mm_MK3S-EINSy10a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK3S-EINSy10a-E3Dv6full.h @@ -495,6 +495,10 @@ #define PLA_PREHEAT_HPB_TEMP 60 #define PLA_PREHEAT_FAN_SPEED 0 +#define ASA_PREHEAT_HOTEND_TEMP 260 +#define ASA_PREHEAT_HPB_TEMP 105 +#define ASA_PREHEAT_FAN_SPEED 0 + #define ABS_PREHEAT_HOTEND_TEMP 255 #define ABS_PREHEAT_HPB_TEMP 100 #define ABS_PREHEAT_FAN_SPEED 0 From a6f955b62dabbbb2d83827ab8b28115ee2104aa9 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Thu, 15 Aug 2019 17:47:34 +0200 Subject: [PATCH 10/24] Use unused macros *_PREHEAT_FAN_SPEED. --- Firmware/ultralcd.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index 33a4257e..4b422a11 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -1691,7 +1691,7 @@ void lcd_preheat_pla() { setTargetHotend0(PLA_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(PLA_PREHEAT_HPB_TEMP); - fanSpeed = 0; + fanSpeed = PLA_PREHEAT_FAN_SPEED; lcd_return_to_status(); setWatch(); // heater sanity check timer if (wizard_active) lcd_wizard(WizState::Unload); @@ -1711,7 +1711,7 @@ void lcd_preheat_abs() { setTargetHotend0(ABS_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(ABS_PREHEAT_HPB_TEMP); - fanSpeed = 0; + fanSpeed = ABS_PREHEAT_FAN_SPEED; lcd_return_to_status(); setWatch(); // heater sanity check timer if (wizard_active) lcd_wizard(WizState::Unload); @@ -1721,7 +1721,7 @@ void lcd_preheat_pp() { setTargetHotend0(PP_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(PP_PREHEAT_HPB_TEMP); - fanSpeed = 0; + fanSpeed = PP_PREHEAT_FAN_SPEED; lcd_return_to_status(); setWatch(); // heater sanity check timer if (wizard_active) lcd_wizard(WizState::Unload); @@ -1731,7 +1731,7 @@ void lcd_preheat_pet() { setTargetHotend0(PET_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(PET_PREHEAT_HPB_TEMP); - fanSpeed = 0; + fanSpeed = PET_PREHEAT_FAN_SPEED; lcd_return_to_status(); setWatch(); // heater sanity check timer if (wizard_active) lcd_wizard(WizState::Unload); @@ -1741,7 +1741,7 @@ void lcd_preheat_hips() { setTargetHotend0(HIPS_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(HIPS_PREHEAT_HPB_TEMP); - fanSpeed = 0; + fanSpeed = HIPS_PREHEAT_FAN_SPEED; lcd_return_to_status(); setWatch(); // heater sanity check timer if (wizard_active) lcd_wizard(WizState::Unload); @@ -1751,7 +1751,7 @@ void lcd_preheat_flex() { setTargetHotend0(FLEX_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(FLEX_PREHEAT_HPB_TEMP); - fanSpeed = 0; + fanSpeed = FLEX_PREHEAT_FAN_SPEED; lcd_return_to_status(); setWatch(); // heater sanity check timer if (wizard_active) lcd_wizard(WizState::Unload); From 0b798767aff8e429ea10d2cb86cfa8a184e8b9e4 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Thu, 15 Aug 2019 17:54:23 +0200 Subject: [PATCH 11/24] Fix preheat ASA. --- Firmware/ultralcd.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index 4b422a11..2bf1d3b4 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -2040,7 +2040,7 @@ static void lcd_preheat_menu() } else { MENU_ITEM_FUNCTION_P(PSTR("PLA - " STRINGIFY(PLA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PLA_PREHEAT_HPB_TEMP)), lcd_preheat_pla); MENU_ITEM_FUNCTION_P(PSTR("PET - " STRINGIFY(PET_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PET_PREHEAT_HPB_TEMP)), lcd_preheat_pet); - MENU_ITEM_FUNCTION_P(PSTR("ASA - " STRINGIFY(ASA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ASA_PREHEAT_HPB_TEMP)), lcd_preheat_pet); + MENU_ITEM_FUNCTION_P(PSTR("ASA - " STRINGIFY(ASA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ASA_PREHEAT_HPB_TEMP)), lcd_preheat_asa); MENU_ITEM_FUNCTION_P(PSTR("ABS - " STRINGIFY(ABS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ABS_PREHEAT_HPB_TEMP)), lcd_preheat_abs); MENU_ITEM_FUNCTION_P(PSTR("HIPS - " STRINGIFY(HIPS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(HIPS_PREHEAT_HPB_TEMP)), lcd_preheat_hips); MENU_ITEM_FUNCTION_P(PSTR("PP - " STRINGIFY(PP_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PP_PREHEAT_HPB_TEMP)), lcd_preheat_pp); From b10bd8340a609e70537218c2346e43d84a9f5c6c Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Thu, 15 Aug 2019 17:57:30 +0200 Subject: [PATCH 12/24] Make local functions static. --- Firmware/ultralcd.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index 2bf1d3b4..de56ea02 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -1669,7 +1669,7 @@ static void lcd_move_menu_axis(); /* Menu implementation */ -void lcd_preheat_farm() +static void lcd_preheat_farm() { setTargetHotend0(FARM_PREHEAT_HOTEND_TEMP); setTargetBed(FARM_PREHEAT_HPB_TEMP); @@ -1678,7 +1678,7 @@ void lcd_preheat_farm() setWatch(); // heater sanity check timer } -void lcd_preheat_farm_nozzle() +static void lcd_preheat_farm_nozzle() { setTargetHotend0(FARM_PREHEAT_HOTEND_TEMP); setTargetBed(0); @@ -1687,7 +1687,7 @@ void lcd_preheat_farm_nozzle() setWatch(); // heater sanity check timer } -void lcd_preheat_pla() +static void lcd_preheat_pla() { setTargetHotend0(PLA_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(PLA_PREHEAT_HPB_TEMP); @@ -1697,7 +1697,7 @@ void lcd_preheat_pla() if (wizard_active) lcd_wizard(WizState::Unload); } -void lcd_preheat_asa() +static void lcd_preheat_asa() { setTargetHotend0(ASA_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(ASA_PREHEAT_HPB_TEMP); @@ -1707,7 +1707,7 @@ void lcd_preheat_asa() if (wizard_active) lcd_wizard(WizState::Unload); } -void lcd_preheat_abs() +static void lcd_preheat_abs() { setTargetHotend0(ABS_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(ABS_PREHEAT_HPB_TEMP); @@ -1717,7 +1717,7 @@ void lcd_preheat_abs() if (wizard_active) lcd_wizard(WizState::Unload); } -void lcd_preheat_pp() +static void lcd_preheat_pp() { setTargetHotend0(PP_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(PP_PREHEAT_HPB_TEMP); @@ -1727,7 +1727,7 @@ void lcd_preheat_pp() if (wizard_active) lcd_wizard(WizState::Unload); } -void lcd_preheat_pet() +static void lcd_preheat_pet() { setTargetHotend0(PET_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(PET_PREHEAT_HPB_TEMP); @@ -1737,7 +1737,7 @@ void lcd_preheat_pet() if (wizard_active) lcd_wizard(WizState::Unload); } -void lcd_preheat_hips() +static void lcd_preheat_hips() { setTargetHotend0(HIPS_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(HIPS_PREHEAT_HPB_TEMP); @@ -1747,7 +1747,7 @@ void lcd_preheat_hips() if (wizard_active) lcd_wizard(WizState::Unload); } -void lcd_preheat_flex() +static void lcd_preheat_flex() { setTargetHotend0(FLEX_PREHEAT_HOTEND_TEMP); if (!wizard_active) setTargetBed(FLEX_PREHEAT_HPB_TEMP); @@ -1758,7 +1758,7 @@ void lcd_preheat_flex() } -void lcd_cooldown() +static void lcd_cooldown() { setAllTargetHotends(0); setTargetBed(0); From 1036c4f7556d0d67ad644d590c7b7db53589898d Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Fri, 16 Aug 2019 19:00:45 +0200 Subject: [PATCH 13/24] Do not precede first layer calibration without filament if print is paused due to MMU load failed. --- Firmware/ultralcd.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index de56ea02..16830f87 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -1354,7 +1354,7 @@ void lcd_commands() if(lcd_commands_step>1) lcd_timeoutToStatus.start(); //if user dont confirm live adjust Z value by pressing the knob, we are saving last value by timeout to status screen - if (!blocks_queued() && cmd_buffer_empty()) + if (!blocks_queued() && cmd_buffer_empty() && !saved_printing) { switch(lcd_commands_step) { From e53734895f414330f81a62b2695c9f1a416af39f Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Fri, 16 Aug 2019 20:20:17 +0200 Subject: [PATCH 14/24] Make MMU load failed blocking to workaround lack of resume print menu item. The same workaround used as for USB print (Octoprint). --- Firmware/Marlin_main.cpp | 4 ++-- Firmware/mmu.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 483d3018..64f8ce74 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -7768,7 +7768,7 @@ Sigma_Exit: if (mmu_enabled) { st_synchronize(); - mmu_continue_loading(is_usb_printing); + mmu_continue_loading(is_usb_printing || (lcd_commands_type == LcdCommands::Layer1Cal)); mmu_extruder = tmp_extruder; //filament change is finished mmu_load_to_nozzle(); } @@ -7812,7 +7812,7 @@ Sigma_Exit: #endif //defined(MMU_HAS_CUTTER) && defined(MMU_ALWAYS_CUT) mmu_command(MmuCmd::T0 + tmp_extruder); manage_response(true, true, MMU_TCODE_MOVE); - mmu_continue_loading(is_usb_printing); + mmu_continue_loading(is_usb_printing || (lcd_commands_type == LcdCommands::Layer1Cal)); mmu_extruder = tmp_extruder; //filament change is finished diff --git a/Firmware/mmu.cpp b/Firmware/mmu.cpp index d6e533df..2c81a6e8 100755 --- a/Firmware/mmu.cpp +++ b/Firmware/mmu.cpp @@ -889,7 +889,7 @@ void mmu_M600_load_filament(bool automatic, float nozzle_temp) mmu_command(MmuCmd::T0 + tmp_extruder); manage_response(false, true, MMU_LOAD_MOVE); - mmu_continue_loading(is_usb_printing); + mmu_continue_loading(is_usb_printing || (lcd_commands_type == LcdCommands::Layer1Cal)); mmu_extruder = tmp_extruder; //filament change is finished mmu_load_to_nozzle(); From 170c1ea86648856e2a9f82b8f2669fc035a9267f Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Fri, 16 Aug 2019 20:47:55 +0200 Subject: [PATCH 15/24] Split first layer calibration load filament and intro line into separate steps. If load fails, pause print apparently flushes command buffer and intro line is not printed after issue is resolved. --- Firmware/first_lay_cal.cpp | 33 ++++++++++++++++++--------------- Firmware/first_lay_cal.h | 3 ++- Firmware/ultralcd.cpp | 18 +++++++++++------- 3 files changed, 31 insertions(+), 23 deletions(-) diff --git a/Firmware/first_lay_cal.cpp b/Firmware/first_lay_cal.cpp index bfec021f..3ab34c41 100644 --- a/Firmware/first_lay_cal.cpp +++ b/Firmware/first_lay_cal.cpp @@ -40,15 +40,26 @@ void lay1cal_preheat() } -//! @brief Print intro line +//! @brief Load filament //! @param cmd_buffer character buffer needed to format gcodes //! @param filament filament to use (applies for MMU only) -void lay1cal_intro_line(char *cmd_buffer, uint8_t filament) +void lay1cal_load_filament(char *cmd_buffer, uint8_t filament) { - static const char cmd_intro_mmu_0[] PROGMEM = "M83"; - static const char cmd_intro_mmu_1[] PROGMEM = "G1 Y-3.0 F1000.0"; - static const char cmd_intro_mmu_2[] PROGMEM = "G1 Z0.4 F1000.0"; - static const char cmd_intro_mmu_3[] PROGMEM = "G1 X55.0 E32.0 F1073.0"; // call T code before + if (mmu_enabled) + { + enquecommand_P(PSTR("M83")); + enquecommand_P(PSTR("G1 Y-3.0 F1000.0")); + enquecommand_P(PSTR("G1 Z0.4 F1000.0")); + sprintf_P(cmd_buffer, PSTR("T%d"), filament); + enquecommand(cmd_buffer); + } + +} + +//! @brief Print intro line +void lay1cal_intro_line() +{ + static const char cmd_intro_mmu_3[] PROGMEM = "G1 X55.0 E32.0 F1073.0"; static const char cmd_intro_mmu_4[] PROGMEM = "G1 X5.0 E32.0 F1800.0"; static const char cmd_intro_mmu_5[] PROGMEM = "G1 X55.0 E8.0 F2000.0"; static const char cmd_intro_mmu_6[] PROGMEM = "G1 Z0.3 F1000.0"; @@ -61,10 +72,7 @@ void lay1cal_intro_line(char *cmd_buffer, uint8_t filament) static const char * const intro_mmu_cmd[] PROGMEM = { - cmd_intro_mmu_0, - cmd_intro_mmu_1, - cmd_intro_mmu_2, - cmd_intro_mmu_3, // call T code before + cmd_intro_mmu_3, cmd_intro_mmu_4, cmd_intro_mmu_5, cmd_intro_mmu_6, @@ -80,11 +88,6 @@ void lay1cal_intro_line(char *cmd_buffer, uint8_t filament) { for (uint8_t i = 0; i < (sizeof(intro_mmu_cmd)/sizeof(intro_mmu_cmd[0])); ++i) { - if (3 == i) - { - sprintf_P(cmd_buffer, PSTR("T%d"), filament); - enquecommand(cmd_buffer); - } enquecommand_P(static_cast(pgm_read_ptr(&intro_mmu_cmd[i]))); } } diff --git a/Firmware/first_lay_cal.h b/Firmware/first_lay_cal.h index 1f338cc5..a52bef76 100644 --- a/Firmware/first_lay_cal.h +++ b/Firmware/first_lay_cal.h @@ -7,7 +7,8 @@ #include void lay1cal_preheat(); -void lay1cal_intro_line(char *cmd_buffer, uint8_t filament); +void lay1cal_load_filament(char *cmd_buffer, uint8_t filament); +void lay1cal_intro_line(); void lay1cal_before_meander(); void lay1cal_meander(char *cmd_buffer); void lay1cal_square(char *cmd_buffer, uint8_t i); diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index 16830f87..66bdc764 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -1359,37 +1359,41 @@ void lcd_commands() switch(lcd_commands_step) { case 0: - lcd_commands_step = 10; + lcd_commands_step = 11; break; case 20: filament = 0; - lcd_commands_step = 10; + lcd_commands_step = 11; break; case 21: filament = 1; - lcd_commands_step = 10; + lcd_commands_step = 11; break; case 22: filament = 2; - lcd_commands_step = 10; + lcd_commands_step = 11; break; case 23: filament = 3; - lcd_commands_step = 10; + lcd_commands_step = 11; break; case 24: filament = 4; + lcd_commands_step = 11; + break; + case 11: + lay1cal_preheat(); lcd_commands_step = 10; break; case 10: - lay1cal_preheat(); + lay1cal_load_filament(cmd1, filament); lcd_commands_step = 9; break; case 9: lcd_clear(); menu_depth = 0; menu_submenu(lcd_babystep_z); - lay1cal_intro_line(cmd1, filament); + lay1cal_intro_line(); lcd_commands_step = 8; break; case 8: From f0642f88f19798b899f47692bc2b008d99ce2190 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Mon, 19 Aug 2019 17:37:23 +0200 Subject: [PATCH 16/24] Fix power panic broken when PSU_Delta defined. Remove disable_z() call from uvlo_() and uvlo_tiny() power panic interrupt handlers. As historically this function was empty. And in case PSU_Delta macro defined it switches Z trinamic to silent mode, which could take some time and is not needed. Remove alignment to to full step from disable_force_z(), as it is not needed when switching to silent mode. --- Firmware/Marlin_main.cpp | 36 +++++++++--------------------------- 1 file changed, 9 insertions(+), 27 deletions(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 483d3018..faffd520 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -9607,7 +9607,6 @@ void uvlo_() st_synchronize(); disable_e0(); - disable_z(); // Move Z up to the next 0th full step. // Write the file position. eeprom_update_dword((uint32_t*)(EEPROM_FILE_POSITION), sd_position); @@ -9646,8 +9645,6 @@ void uvlo_() st_synchronize(); printf_P(_N("stps%d\n"), tmc2130_rd_MSCNT(Z_AXIS)); - - disable_z(); // Increment power failure counter eeprom_update_byte((uint8_t*)EEPROM_POWER_COUNT, eeprom_read_byte((uint8_t*)EEPROM_POWER_COUNT) + 1); @@ -9686,7 +9683,6 @@ tmc2130_set_current_r(Z_AXIS, 20); z_microsteps=tmc2130_rd_MSCNT(Z_TMC2130_CS); #endif //TMC2130 planner_abort_hard(); -disable_z(); //save current position only in case, where the printer is moving on Z axis, which is only when EEPROM_UVLO is 1 //EEPROM_UVLO is 1 after normal uvlo or after recover_print(), when the extruder is moving on Z axis after rehome @@ -10534,34 +10530,20 @@ if(!(bEnableForce_z||eeprom_read_byte((uint8_t*)EEPROM_SILENT))) void disable_force_z() { -uint16_t z_microsteps=0; + uint16_t z_microsteps=0; -if(!bEnableForce_z) - return; // motor already disabled (may be ;-p ) -bEnableForce_z=false; + if(!bEnableForce_z) return; // motor already disabled (may be ;-p ) -// alignment to full-step + bEnableForce_z=false; + + // switching to silent mode #ifdef TMC2130 -z_microsteps=tmc2130_rd_MSCNT(Z_TMC2130_CS); -#endif // TMC2130 -planner_abort_hard(); -sei(); -plan_buffer_line( - current_position[X_AXIS], - current_position[Y_AXIS], - current_position[Z_AXIS]+float((1024-z_microsteps+7)>>4)/cs.axis_steps_per_unit[Z_AXIS], - current_position[E_AXIS], - 40, active_extruder); -st_synchronize(); - -// switching to silent mode -#ifdef TMC2130 -tmc2130_mode=TMC2130_MODE_SILENT; -update_mode_profile(); -tmc2130_init(true); + tmc2130_mode=TMC2130_MODE_SILENT; + update_mode_profile(); + tmc2130_init(true); #endif // TMC2130 -axis_known_position[Z_AXIS]=false; + axis_known_position[Z_AXIS]=false; } From f204cdea81903e365d7c45333bbb4efa3ae6c63c Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Tue, 20 Aug 2019 17:22:27 +0200 Subject: [PATCH 17/24] Refactor Remove variable CrashDetectMenu. Read this state from EEPROM_CRASH_DET instead in bool lcd_crash_detect_enabled(). Rename crashdet_enable() to lcd_crash_detect_enable() and move it to ultralcd.cpp. Rename crashdet_disable() to lcd_crash_detect_disable() and move it to ultralcd.cpp. Rename lcd_crash_mode_set() to crash_mode_switch(). Remove forward function declarations from *.cpp file. Saves 34B of FLASH and 2B of RAM. --- Firmware/Marlin_main.cpp | 26 +++--------------- Firmware/ultralcd.cpp | 59 ++++++++++++++++++++++++++-------------- Firmware/ultralcd.h | 5 ++++ 3 files changed, 47 insertions(+), 43 deletions(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index f4f92fee..0083c9ee 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -524,24 +524,6 @@ bool fans_check_enabled = true; #ifdef TMC2130 -extern int8_t CrashDetectMenu; - -void crashdet_enable() -{ - tmc2130_sg_stop_on_crash = true; - eeprom_update_byte((uint8_t*)EEPROM_CRASH_DET, 0xFF); - CrashDetectMenu = 1; - -} - -void crashdet_disable() -{ - tmc2130_sg_stop_on_crash = false; - tmc2130_sg_crash = 0; - eeprom_update_byte((uint8_t*)EEPROM_CRASH_DET, 0x00); - CrashDetectMenu = 0; -} - void crashdet_stop_and_save_print() { stop_and_save_print_to_ram(10, -default_retraction); //XY - no change, Z 10mm up, E -1mm retract @@ -1262,15 +1244,15 @@ void setup() uint8_t silentMode = eeprom_read_byte((uint8_t*)EEPROM_SILENT); if (silentMode == 0xff) silentMode = 0; tmc2130_mode = TMC2130_MODE_NORMAL; - uint8_t crashdet = eeprom_read_byte((uint8_t*)EEPROM_CRASH_DET); - if (crashdet && !farm_mode) + + if (lcd_crash_detect_enabled() && !farm_mode) { - crashdet_enable(); + lcd_crash_detect_enable(); puts_P(_N("CrashDetect ENABLED!")); } else { - crashdet_disable(); + lcd_crash_detect_disable(); puts_P(_N("CrashDetect DISABLED")); } diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index 66bdc764..c20350aa 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -58,17 +58,9 @@ uint8_t SilentModeMenu_MMU = 1; //activate mmu unit stealth mode int8_t FSensorStateMenu = 1; -int8_t CrashDetectMenu = 1; - - extern bool fsensor_enable(); extern void fsensor_disable(); -#ifdef TMC2130 -extern void crashdet_enable(); -extern void crashdet_disable(); -#endif //TMC2130 - #ifdef SDCARD_SORT_ALPHA bool presort_flag = false; @@ -4448,24 +4440,25 @@ static void lcd_silent_mode_set() { #endif //TMC2130 st_current_init(); #ifdef TMC2130 - if (CrashDetectMenu && (SilentModeMenu != SILENT_MODE_NORMAL)) + if (lcd_crash_detect_enabled() && (SilentModeMenu != SILENT_MODE_NORMAL)) menu_submenu(lcd_crash_mode_info2); lcd_encoder_diff=0; // reset 'encoder buffer' #endif //TMC2130 } #ifdef TMC2130 -static void lcd_crash_mode_set() +static void crash_mode_switch() { - CrashDetectMenu = !CrashDetectMenu; //set also from crashdet_enable() and crashdet_disable() - if (CrashDetectMenu==0) { - crashdet_disable(); - }else{ - crashdet_enable(); + if (lcd_crash_detect_enabled()) + { + lcd_crash_detect_disable(); + } + else + { + lcd_crash_detect_enable(); } if (IS_SD_PRINTING || is_usb_printing || (lcd_commands_type == LcdCommands::Layer1Cal)) menu_goto(lcd_tune_menu, 9, true, true); else menu_goto(lcd_settings_menu, 9, true, true); - } #endif //TMC2130 @@ -5179,11 +5172,11 @@ do\ else MENU_ITEM_FUNCTION_P(_T(MSG_STEALTH_MODE_ON), lcd_silent_mode_set);\ if (SilentModeMenu == SILENT_MODE_NORMAL)\ {\ - if (CrashDetectMenu == 0)\ + if (lcd_crash_detect_enabled())\ {\ - MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_OFF), lcd_crash_mode_set);\ + MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_ON), crash_mode_switch);\ }\ - else MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_ON), lcd_crash_mode_set);\ + else MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_OFF), crash_mode_switch);\ }\ else MENU_ITEM_SUBMENU_P(_T(MSG_CRASHDETECT_NA), lcd_crash_mode_info);\ }\ @@ -6903,8 +6896,8 @@ static void lcd_tune_menu() if (SilentModeMenu == SILENT_MODE_NORMAL) { - if (CrashDetectMenu == 0) MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_OFF), lcd_crash_mode_set); - else MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_ON), lcd_crash_mode_set); + if (lcd_crash_detect_enabled()) MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_ON), crash_mode_switch); + else MENU_ITEM_FUNCTION_P(_T(MSG_CRASHDETECT_OFF), crash_mode_switch); } else MENU_ITEM_SUBMENU_P(_T(MSG_CRASHDETECT_NA), lcd_crash_mode_info); } @@ -8645,3 +8638,27 @@ void menu_lcd_lcdupdate_func(void) lcd_send_status(); if (lcd_commands_type == LcdCommands::Layer1Cal) lcd_commands(); } + +#ifdef TMC2130 +//! @brief Is crash detection enabled? +//! +//! @retval true crash detection enabled +//! @retval false crash detection disabled +bool lcd_crash_detect_enabled() +{ + return eeprom_read_byte((uint8_t*)EEPROM_CRASH_DET); +} + +void lcd_crash_detect_enable() +{ + tmc2130_sg_stop_on_crash = true; + eeprom_update_byte((uint8_t*)EEPROM_CRASH_DET, 0xFF); +} + +void lcd_crash_detect_disable() +{ + tmc2130_sg_stop_on_crash = false; + tmc2130_sg_crash = 0; + eeprom_update_byte((uint8_t*)EEPROM_CRASH_DET, 0x00); +} +#endif diff --git a/Firmware/ultralcd.h b/Firmware/ultralcd.h index 2c57c944..f414a1cc 100755 --- a/Firmware/ultralcd.h +++ b/Firmware/ultralcd.h @@ -53,6 +53,11 @@ void lcd_menu_statistics(); void lcd_menu_extruder_info(); // NOT static due to using inside "Marlin_main" module ("manage_inactivity()") void lcd_menu_show_sensors_state(); // NOT static due to using inside "Marlin_main" module ("manage_inactivity()") +#ifdef TMC2130 +bool lcd_crash_detect_enabled(); +void lcd_crash_detect_enable(); +void lcd_crash_detect_disable(); +#endif extern const char* lcd_display_message_fullscreen_P(const char *msg, uint8_t &nlines); extern const char* lcd_display_message_fullscreen_P(const char *msg); From 3ed6d0637c748c3190b686de213de30843952d19 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Tue, 20 Aug 2019 17:34:42 +0200 Subject: [PATCH 18/24] Re-enable tmc2130_sg_stop_on_crash only if crash detection enabled from menu. This fixes bug, that disabling crash detection from menu doesn't work during recovery from crash detection. --- Firmware/Marlin_main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 0083c9ee..a8c67969 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -613,7 +613,7 @@ void crashdet_detected(uint8_t mask) void crashdet_recover() { crashdet_restore_print_and_continue(); - tmc2130_sg_stop_on_crash = true; + if (lcd_crash_detect_enabled()) tmc2130_sg_stop_on_crash = true; } void crashdet_cancel() From a7c2aec04c226297461866b1452166cdf007d5c6 Mon Sep 17 00:00:00 2001 From: DRracer Date: Wed, 21 Aug 2019 09:59:51 +0200 Subject: [PATCH 19/24] Code size reduced by almost 5KB --- Firmware/Marlin_main.cpp | 187 +++++++++++++++--------------- Firmware/mesh_bed_calibration.cpp | 4 +- Firmware/mmu.cpp | 64 +++++----- Firmware/planner.cpp | 6 +- Firmware/planner.h | 9 +- Firmware/ultralcd.cpp | 54 ++++----- 6 files changed, 163 insertions(+), 161 deletions(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index f4f92fee..d4c2fdb1 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -2025,14 +2025,14 @@ static void do_blocking_move_to(float x, float y, float z) { feedrate = homing_feedrate[Z_AXIS]; current_position[Z_AXIS] = z; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate/60, active_extruder); + plan_buffer_line_curposXYZE(feedrate/60, active_extruder); st_synchronize(); feedrate = XY_TRAVEL_SPEED; current_position[X_AXIS] = x; current_position[Y_AXIS] = y; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate/60, active_extruder); + plan_buffer_line_curposXYZE(feedrate/60, active_extruder); st_synchronize(); feedrate = oldFeedRate; @@ -2362,77 +2362,77 @@ void ramming() { max_feedrate[E_AXIS] = 50; //current_position[E_AXIS] -= 8; - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2100 / 60, active_extruder); + //plan_buffer_line_curposXYZE(2100 / 60, active_extruder); //current_position[E_AXIS] += 8; - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2100 / 60, active_extruder); + //plan_buffer_line_curposXYZE(2100 / 60, active_extruder); current_position[E_AXIS] += 5.4; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2800 / 60, active_extruder); + plan_buffer_line_curposXYZE(2800 / 60, active_extruder); current_position[E_AXIS] += 3.2; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[E_AXIS] += 3; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3400 / 60, active_extruder); + plan_buffer_line_curposXYZE(3400 / 60, active_extruder); st_synchronize(); max_feedrate[E_AXIS] = 80; current_position[E_AXIS] -= 82; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 9500 / 60, active_extruder); + plan_buffer_line_curposXYZE(9500 / 60, active_extruder); max_feedrate[E_AXIS] = 50;//tmp[E_AXIS]; current_position[E_AXIS] -= 20; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 1200 / 60, active_extruder); + plan_buffer_line_curposXYZE(1200 / 60, active_extruder); current_position[E_AXIS] += 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400 / 60, active_extruder); + plan_buffer_line_curposXYZE(400 / 60, active_extruder); current_position[E_AXIS] += 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); current_position[E_AXIS] -= 10; st_synchronize(); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); current_position[E_AXIS] += 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); current_position[E_AXIS] -= 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 800 / 60, active_extruder); + plan_buffer_line_curposXYZE(800 / 60, active_extruder); current_position[E_AXIS] += 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 800 / 60, active_extruder); + plan_buffer_line_curposXYZE(800 / 60, active_extruder); current_position[E_AXIS] -= 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 800 / 60, active_extruder); + plan_buffer_line_curposXYZE(800 / 60, active_extruder); st_synchronize(); } else { //ABS max_feedrate[E_AXIS] = 50; //current_position[E_AXIS] -= 8; - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2100 / 60, active_extruder); + //plan_buffer_line_curposXYZE(2100 / 60, active_extruder); //current_position[E_AXIS] += 8; - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2100 / 60, active_extruder); + //plan_buffer_line_curposXYZE(2100 / 60, active_extruder); current_position[E_AXIS] += 3.1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2000 / 60, active_extruder); + plan_buffer_line_curposXYZE(2000 / 60, active_extruder); current_position[E_AXIS] += 3.1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2500 / 60, active_extruder); + plan_buffer_line_curposXYZE(2500 / 60, active_extruder); current_position[E_AXIS] += 4; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); //current_position[X_AXIS] += 23; //delay - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600/60, active_extruder); //delay + //plan_buffer_line_curposXYZE(600/60, active_extruder); //delay //current_position[X_AXIS] -= 23; //delay - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600/60, active_extruder); //delay + //plan_buffer_line_curposXYZE(600/60, active_extruder); //delay _delay(4700); max_feedrate[E_AXIS] = 80; current_position[E_AXIS] -= 92; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 9900 / 60, active_extruder); + plan_buffer_line_curposXYZE(9900 / 60, active_extruder); max_feedrate[E_AXIS] = 50;//tmp[E_AXIS]; current_position[E_AXIS] -= 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 800 / 60, active_extruder); + plan_buffer_line_curposXYZE(800 / 60, active_extruder); current_position[E_AXIS] += 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400 / 60, active_extruder); + plan_buffer_line_curposXYZE(400 / 60, active_extruder); current_position[E_AXIS] -= 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); st_synchronize(); current_position[E_AXIS] += 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); current_position[E_AXIS] -= 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); current_position[E_AXIS] += 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); current_position[E_AXIS] -= 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); + plan_buffer_line_curposXYZE(600 / 60, active_extruder); st_synchronize(); } @@ -2491,7 +2491,7 @@ static void gcode_G28(bool home_x_axis, long home_x_value, bool home_y_axis, lon if (home_all_axes) { current_position[Z_AXIS] += MESH_HOME_Z_SEARCH; feedrate = homing_feedrate[Z_AXIS]; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate / 60, active_extruder); + plan_buffer_line_curposXYZE(feedrate / 60, active_extruder); st_synchronize(); } #ifdef ENABLE_AUTO_BED_LEVELING @@ -2809,7 +2809,7 @@ bool gcode_M45(bool onlyZ, int8_t verbosity_level) enable_endstops(false); current_position[X_AXIS] += 5; current_position[Y_AXIS] += 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 40, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 40, active_extruder); st_synchronize(); // Let the user move the Z axes up to the end stoppers. @@ -2859,7 +2859,7 @@ bool gcode_M45(bool onlyZ, int8_t verbosity_level) bool endstops_enabled = enable_endstops(false); current_position[Z_AXIS] -= 1; //move 1mm down with disabled endstop - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 40, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 40, active_extruder); st_synchronize(); // Move the print head close to the bed. @@ -2870,7 +2870,7 @@ bool gcode_M45(bool onlyZ, int8_t verbosity_level) tmc2130_home_enter(Z_AXIS_MASK); #endif //TMC2130 - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 40, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 40, active_extruder); st_synchronize(); #ifdef TMC2130 @@ -2910,7 +2910,7 @@ bool gcode_M45(bool onlyZ, int8_t verbosity_level) clean_up_after_endstop_move(l_feedmultiply); // Print head up. current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 40, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 40, active_extruder); st_synchronize(); //#ifndef NEW_XYZCAL if (result >= 0) @@ -2930,7 +2930,7 @@ bool gcode_M45(bool onlyZ, int8_t verbosity_level) clean_up_after_endstop_move(l_feedmultiply); // Print head up. current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 40, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 40, active_extruder); st_synchronize(); // if (result >= 0) babystep_apply(); #endif //HEATBED_V2 @@ -3040,21 +3040,18 @@ static void gcode_M600(bool automatic, float x_position, float y_position, float //Retract E current_position[E_AXIS] += e_shift; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], FILAMENTCHANGE_RFEED, active_extruder); + plan_buffer_line_curposXYZE(FILAMENTCHANGE_RFEED, active_extruder); st_synchronize(); //Lift Z current_position[Z_AXIS] += z_shift; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], FILAMENTCHANGE_ZFEED, active_extruder); + plan_buffer_line_curposXYZE(FILAMENTCHANGE_ZFEED, active_extruder); st_synchronize(); //Move XY to side current_position[X_AXIS] = x_position; current_position[Y_AXIS] = y_position; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], FILAMENTCHANGE_XYFEED, active_extruder); + plan_buffer_line_curposXYZE(FILAMENTCHANGE_XYFEED, active_extruder); st_synchronize(); //Beep, manage nozzle heater and wait for user to start unload filament @@ -3079,8 +3076,7 @@ static void gcode_M600(bool automatic, float x_position, float y_position, float lcd_set_cursor(0, 2); lcd_puts_P(_T(MSG_PLEASE_WAIT)); current_position[X_AXIS] -= 100; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], FILAMENTCHANGE_XYFEED, active_extruder); + plan_buffer_line_curposXYZE(FILAMENTCHANGE_XYFEED, active_extruder); st_synchronize(); lcd_show_fullscreen_message_and_wait_P(_i("Please open idler and remove filament manually."));////MSG_CHECK_IDLER c=20 r=4 } @@ -3117,8 +3113,7 @@ static void gcode_M600(bool automatic, float x_position, float y_position, float if (!automatic) { current_position[E_AXIS] += FILAMENTCHANGE_RECFEED; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], FILAMENTCHANGE_EXFEED, active_extruder); + plan_buffer_line_curposXYZE(FILAMENTCHANGE_EXFEED, active_extruder); } //Move XY back @@ -3185,12 +3180,12 @@ void gcode_M701() lcd_setstatuspgm(_T(MSG_LOADING_FILAMENT)); current_position[E_AXIS] += 40; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400 / 60, active_extruder); //fast sequence + plan_buffer_line_curposXYZE(400 / 60, active_extruder); //fast sequence st_synchronize(); marlin_rise_z(); current_position[E_AXIS] += 30; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400 / 60, active_extruder); //fast sequence + plan_buffer_line_curposXYZE(400 / 60, active_extruder); //fast sequence load_filament_final_feed(); //slow sequence st_synchronize(); @@ -4389,15 +4384,15 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) if (result) { current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[Z_AXIS] = 50; current_position[Y_AXIS] = 180; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); lcd_show_fullscreen_message_and_wait_P(_T(MSG_REMOVE_STEEL_SHEET)); current_position[Y_AXIS] = pgm_read_float(bed_ref_points_4 + 1); current_position[X_AXIS] = pgm_read_float(bed_ref_points_4); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); gcode_G28(false, false, true); @@ -4405,7 +4400,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) if ((current_temperature_pinda > 35) && (farm_mode == false)) { //waiting for PIDNA probe to cool down in case that we are not in farm mode current_position[Z_AXIS] = 100; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); if (lcd_wait_for_pinda(35) == false) { //waiting for PINDA probe to cool, if this takes more then time expected, temp. cal. fails lcd_temp_cal_show_result(false); break; @@ -4429,12 +4424,12 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) custom_message_state = 1; lcd_setstatuspgm(_T(MSG_TEMP_CALIBRATION)); current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[X_AXIS] = PINDA_PREHEAT_X; current_position[Y_AXIS] = PINDA_PREHEAT_Y; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[Z_AXIS] = PINDA_PREHEAT_Z; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); while (current_temperature_pinda < start_temp) @@ -4446,10 +4441,10 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[X_AXIS] = pgm_read_float(bed_ref_points_4); current_position[Y_AXIS] = pgm_read_float(bed_ref_points_4 + 1); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); bool find_z_result = find_bed_induction_sensor_point_z(-1.f); @@ -4477,12 +4472,12 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) setTargetBed(50 + 10 * (temp - 30) / 5); // setTargetHotend(255, 0); current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[X_AXIS] = PINDA_PREHEAT_X; current_position[Y_AXIS] = PINDA_PREHEAT_Y; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[Z_AXIS] = PINDA_PREHEAT_Z; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); while (current_temperature_pinda < temp) { @@ -4490,10 +4485,10 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) serialecho_temperatures(); } current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[X_AXIS] = pgm_read_float(bed_ref_points_4); current_position[Y_AXIS] = pgm_read_float(bed_ref_points_4 + 1); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); find_z_result = find_bed_induction_sensor_point_z(-1.f); if (find_z_result == false) { @@ -4533,7 +4528,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) current_position[X_AXIS] = PINDA_PREHEAT_X; current_position[Y_AXIS] = PINDA_PREHEAT_Y; current_position[Z_AXIS] = PINDA_PREHEAT_Z; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); while (abs(degBed() - PINDA_MIN_T) > 1) { @@ -4549,11 +4544,11 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) eeprom_update_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, 0); //invalidate temp. calibration in case that in will be aborted during the calibration process current_position[Z_AXIS] = 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[X_AXIS] = BED_X0; current_position[Y_AXIS] = BED_Y0; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); find_bed_induction_sensor_point_z(-1.f); @@ -4570,7 +4565,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) current_position[X_AXIS] = PINDA_PREHEAT_X; current_position[Y_AXIS] = PINDA_PREHEAT_Y; current_position[Z_AXIS] = PINDA_PREHEAT_Z; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); while (degBed() < t_c) { delay_keep_alive(1000); @@ -4581,10 +4576,10 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) serialecho_temperatures(); } current_position[Z_AXIS] = 5; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[X_AXIS] = BED_X0; current_position[Y_AXIS] = BED_Y0; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); find_bed_induction_sensor_point_z(-1.f); z_shift = (int)((current_position[Z_AXIS] - zero_z)*cs.axis_steps_per_unit[Z_AXIS]); @@ -4725,7 +4720,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) // Cycle through all points and probe them // First move up. During this first movement, the babystepping will be reverted. current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 60, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 60, active_extruder); // The move to the first calibration point. current_position[X_AXIS] = BED_X0; current_position[Y_AXIS] = BED_Y0; @@ -4740,7 +4735,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) world2machine_clamp(current_position[X_AXIS], current_position[Y_AXIS]); #endif //SUPPORT_VERBOSITY - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[X_AXIS] / 30, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[X_AXIS] / 30, active_extruder); // Wait until the move is finished. st_synchronize(); @@ -4792,7 +4787,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) if((ix == 0) && (iy == 0)) current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; else current_position[Z_AXIS] += 2.f / nMeasPoints; //use relative movement from Z coordinate where PINDa triggered on previous point. This makes calibration faster. float init_z_bckp = current_position[Z_AXIS]; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(Z_LIFT_FEEDRATE, active_extruder); st_synchronize(); // Move to XY position of the sensor point. @@ -4813,7 +4808,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) #endif // SUPPORT_VERBOSITY //printf_P(PSTR("after clamping: [%f;%f]\n"), current_position[X_AXIS], current_position[Y_AXIS]); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], XY_AXIS_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(XY_AXIS_FEEDRATE, active_extruder); st_synchronize(); // Go down until endstop is hit @@ -4825,7 +4820,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) if (init_z_bckp - current_position[Z_AXIS] < 0.1f) { //broken cable or initial Z coordinate too low. Go to MESH_HOME_Z_SEARCH and repeat last step (z-probe) again to distinguish between these two cases. //printf_P(PSTR("Another attempt! Current Z position: %f\n"), current_position[Z_AXIS]); current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(Z_LIFT_FEEDRATE, active_extruder); st_synchronize(); if (!find_bed_induction_sensor_point_z((has_z && mesh_point > 0) ? z0 - Z_CALIBRATION_THRESHOLD : -10.f, nProbeRetry)) { //if we have data from z calibration max allowed difference is 1mm for each point, if we dont have data max difference is 10mm from initial point @@ -4880,7 +4875,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) MYSERIAL.print(current_position[Z_AXIS], 5); } #endif // SUPPORT_VERBOSITY - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(Z_LIFT_FEEDRATE, active_extruder); st_synchronize(); if (mesh_point != nMeasPoints * nMeasPoints) { Sound_MakeSound(e_SOUND_TYPE_StandardAlert); @@ -4897,14 +4892,14 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) // ~ Z-homing (can not be used "G28", because X & Y-homing would have been done before (Z-homing)) bState=enable_z_endstop(false); current_position[Z_AXIS] -= 1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 40, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 40, active_extruder); st_synchronize(); enable_z_endstop(true); #ifdef TMC2130 tmc2130_home_enter(Z_AXIS_MASK); #endif // TMC2130 current_position[Z_AXIS] = MESH_HOME_Z_SEARCH; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 40, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 40, active_extruder); st_synchronize(); #ifdef TMC2130 tmc2130_home_exit(); @@ -5037,7 +5032,7 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) //unretract (after PINDA preheat retraction) if (degHotend(active_extruder) > EXTRUDE_MINTEMP && temp_cal_active == true && calibration_status_pinda() == true && target_temperature_bed >= 50) { current_position[E_AXIS] += default_retraction; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400, active_extruder); + plan_buffer_line_curposXYZE(400, active_extruder); } KEEPALIVE_STATE(NOT_BUSY); // Restore custom message state @@ -9022,7 +9017,7 @@ void bed_check(float x_dimension, float y_dimension, int x_points_num, int y_poi card.openFile(filename_wldsd, false); /*destination[Z_AXIS] = mesh_home_z_search; - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); + //plan_buffer_line_curposXYZE(Z_LIFT_FEEDRATE, active_extruder); plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); for(int8_t i=0; i < NUM_AXIS; i++) { @@ -9056,7 +9051,7 @@ void bed_check(float x_dimension, float y_dimension, int x_points_num, int y_poi if (iy & 1) ix = (x_points_num - 1) - ix; // Zig zag float z0 = 0.f; /*destination[Z_AXIS] = mesh_home_z_search; - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); + //plan_buffer_line_curposXYZE(Z_LIFT_FEEDRATE, active_extruder); plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); for(int8_t i=0; i < NUM_AXIS; i++) { @@ -9220,7 +9215,7 @@ void bed_analysis(float x_dimension, float y_dimension, int x_points_num, int y_ card.openFile(filename_wldsd, false); current_position[Z_AXIS] = mesh_home_z_search; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 60, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 60, active_extruder); int XY_AXIS_FEEDRATE = homing_feedrate[X_AXIS] / 20; int Z_LIFT_FEEDRATE = homing_feedrate[Z_AXIS] / 40; @@ -9245,14 +9240,14 @@ void bed_analysis(float x_dimension, float y_dimension, int x_points_num, int y_ if (iy & 1) ix = (x_points_num - 1) - ix; // Zig zag float z0 = 0.f; current_position[Z_AXIS] = mesh_home_z_search; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], Z_LIFT_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(Z_LIFT_FEEDRATE, active_extruder); st_synchronize(); current_position[X_AXIS] = 13.f + ix * (x_dimension / (x_points_num - 1)) - bed_zero_ref_x + shift_x; current_position[Y_AXIS] = 6.4f + iy * (y_dimension / (y_points_num - 1)) - bed_zero_ref_y + shift_y; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], XY_AXIS_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(XY_AXIS_FEEDRATE, active_extruder); st_synchronize(); if (!find_bed_induction_sensor_point_z(-10.f)) { //if we have data from z calibration max allowed difference is 1mm for each point, if we dont have data max difference is 10mm from initial point @@ -9366,12 +9361,12 @@ void temp_compensation_start() { if (degHotend(active_extruder) > EXTRUDE_MINTEMP) { current_position[E_AXIS] -= default_retraction; } - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400, active_extruder); + plan_buffer_line_curposXYZE(400, active_extruder); current_position[X_AXIS] = PINDA_PREHEAT_X; current_position[Y_AXIS] = PINDA_PREHEAT_Y; current_position[Z_AXIS] = PINDA_PREHEAT_Z; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); st_synchronize(); while (fabs(degBed() - target_temperature_bed) > 1) delay_keep_alive(1000); @@ -9492,17 +9487,17 @@ void long_pause() //long pause print //retract current_position[E_AXIS] -= default_retraction; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400, active_extruder); + plan_buffer_line_curposXYZE(400, active_extruder); //lift z current_position[Z_AXIS] += Z_PAUSE_LIFT; if (current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 15, active_extruder); + plan_buffer_line_curposXYZE(15, active_extruder); //Move XY to side current_position[X_AXIS] = X_PAUSE_POS; current_position[Y_AXIS] = Y_PAUSE_POS; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 50, active_extruder); + plan_buffer_line_curposXYZE(50, active_extruder); // Turn off the print fan fanSpeed = 0; @@ -9654,7 +9649,7 @@ void uvlo_() #if 0 // Move the print head to the side of the print until all the power stored in the power supply capacitors is depleted. current_position[X_AXIS] = (current_position[X_AXIS] < 0.5f * (X_MIN_POS + X_MAX_POS)) ? X_MIN_POS : X_MAX_POS; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 500, active_extruder); + plan_buffer_line_curposXYZE(500, active_extruder); st_synchronize(); #endif wdt_enable(WDTO_500MS); @@ -10290,7 +10285,7 @@ static void print_time_remaining_init() void load_filament_final_feed() { current_position[E_AXIS]+= FILAMENTCHANGE_FINALFEED; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], FILAMENTCHANGE_EFEED_FINAL, active_extruder); + plan_buffer_line_curposXYZE(FILAMENTCHANGE_EFEED_FINAL, active_extruder); } //! @brief Wait for user to check the state @@ -10420,22 +10415,22 @@ void M600_load_filament_movements() do { current_position[E_AXIS] += 0.002; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 500, active_extruder); + plan_buffer_line_curposXYZE(500, active_extruder); delay_keep_alive(2); } while (!lcd_clicked()); st_synchronize(); current_position[E_AXIS] += bowden_length[mmu_extruder]; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000, active_extruder); + plan_buffer_line_curposXYZE(3000, active_extruder); current_position[E_AXIS] += FIL_LOAD_LENGTH - 60; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 1400, active_extruder); + plan_buffer_line_curposXYZE(1400, active_extruder); current_position[E_AXIS] += 40; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 400, active_extruder); + plan_buffer_line_curposXYZE(400, active_extruder); current_position[E_AXIS] += 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 50, active_extruder); + plan_buffer_line_curposXYZE(50, active_extruder); #else current_position[E_AXIS]+= FILAMENTCHANGE_FIRSTFEED ; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], FILAMENTCHANGE_EFEED_FIRST, active_extruder); + plan_buffer_line_curposXYZE(FILAMENTCHANGE_EFEED_FIRST, active_extruder); #endif load_filament_final_feed(); lcd_loading_filament(); diff --git a/Firmware/mesh_bed_calibration.cpp b/Firmware/mesh_bed_calibration.cpp index 1edac56b..6466edc4 100644 --- a/Firmware/mesh_bed_calibration.cpp +++ b/Firmware/mesh_bed_calibration.cpp @@ -919,7 +919,7 @@ static inline void go_xy(float x, float y, float fr) static inline void go_to_current(float fr) { - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], fr, active_extruder); + plan_buffer_line_curposXYZE(fr, active_extruder); st_synchronize(); } @@ -2769,7 +2769,7 @@ bool sample_z() { //make space current_position[Z_AXIS] += 150; go_to_current(homing_feedrate[Z_AXIS] / 60); - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate, active_extruder);); + //plan_buffer_line_curposXYZE(feedrate, active_extruder);); lcd_show_fullscreen_message_and_wait_P(_T(MSG_PLACE_STEEL_SHEET)); diff --git a/Firmware/mmu.cpp b/Firmware/mmu.cpp index 2c81a6e8..e7a59e75 100755 --- a/Firmware/mmu.cpp +++ b/Firmware/mmu.cpp @@ -537,7 +537,7 @@ void mmu_command(MmuCmd cmd) void mmu_load_step(bool synchronize) { current_position[E_AXIS] = current_position[E_AXIS] + MMU_LOAD_FEEDRATE * 0.1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], MMU_LOAD_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(MMU_LOAD_FEEDRATE, active_extruder); if (synchronize) st_synchronize(); } @@ -602,7 +602,7 @@ bool mmu_get_response(uint8_t move) { printf_P(PSTR("Unload 1\n")); current_position[E_AXIS] = current_position[E_AXIS] - MMU_LOAD_FEEDRATE * MMU_LOAD_TIME_MS*0.001; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], MMU_LOAD_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(MMU_LOAD_FEEDRATE, active_extruder); st_synchronize(); } } @@ -620,7 +620,7 @@ bool mmu_get_response(uint8_t move) { printf_P(PSTR("Unload 2\n")); current_position[E_AXIS] = current_position[E_AXIS] - MMU_LOAD_FEEDRATE * MMU_LOAD_TIME_MS*0.001; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], MMU_LOAD_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(MMU_LOAD_FEEDRATE, active_extruder); st_synchronize(); } } @@ -698,13 +698,13 @@ void manage_response(bool move_axes, bool turn_off_nozzle, uint8_t move) //lift z current_position[Z_AXIS] += Z_PAUSE_LIFT; if (current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 15, active_extruder); + plan_buffer_line_curposXYZE(15, active_extruder); st_synchronize(); //Move XY to side current_position[X_AXIS] = X_PAUSE_POS; current_position[Y_AXIS] = Y_PAUSE_POS; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 50, active_extruder); + plan_buffer_line_curposXYZE(50, active_extruder); st_synchronize(); } if (turn_off_nozzle) { @@ -762,10 +762,10 @@ void manage_response(bool move_axes, bool turn_off_nozzle, uint8_t move) lcd_display_message_fullscreen_P(_i("MMU OK. Resuming position...")); current_position[X_AXIS] = x_position_bckp; current_position[Y_AXIS] = y_position_bckp; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 50, active_extruder); + plan_buffer_line_curposXYZE(50, active_extruder); st_synchronize(); current_position[Z_AXIS] = z_position_bckp; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 15, active_extruder); + plan_buffer_line_curposXYZE(15, active_extruder); st_synchronize(); } else { @@ -804,19 +804,19 @@ void mmu_load_to_nozzle() current_position[E_AXIS] += 7.2f; } float feedrate = 562; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate / 60, active_extruder); + plan_buffer_line_curposXYZE(feedrate / 60, active_extruder); st_synchronize(); current_position[E_AXIS] += 14.4f; feedrate = 871; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate / 60, active_extruder); + plan_buffer_line_curposXYZE(feedrate / 60, active_extruder); st_synchronize(); current_position[E_AXIS] += 36.0f; feedrate = 1393; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate / 60, active_extruder); + plan_buffer_line_curposXYZE(feedrate / 60, active_extruder); st_synchronize(); current_position[E_AXIS] += 14.4f; feedrate = 871; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate / 60, active_extruder); + plan_buffer_line_curposXYZE(feedrate / 60, active_extruder); st_synchronize(); if (!saved_e_relative_mode) axis_relative_modes[E_AXIS] = false; } @@ -903,7 +903,7 @@ void extr_mov(float shift, float feed_rate) { //move extruder no matter what the current heater temperature is set_extrude_min_temp(.0); current_position[E_AXIS] += shift; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feed_rate, active_extruder); + plan_buffer_line_curposXYZE(feed_rate, active_extruder); set_extrude_min_temp(EXTRUDE_MINTEMP); } #endif //SNMM @@ -1069,8 +1069,7 @@ void mmu_filament_ramming() for(uint8_t i = 0; i < (sizeof(ramming_sequence)/sizeof(E_step));++i) { current_position[E_AXIS] += pgm_read_float(&(ramming_sequence[i].extrude)); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], pgm_read_float(&(ramming_sequence[i].feed_rate)), active_extruder); + plan_buffer_line_curposXYZE(pgm_read_float(&(ramming_sequence[i].feed_rate)), active_extruder); st_synchronize(); } } @@ -1140,39 +1139,39 @@ void extr_unload() lcd_set_cursor(0, 2); lcd_puts_P(_T(MSG_PLEASE_WAIT)); if (current_position[Z_AXIS] < 15) { current_position[Z_AXIS] += 15; //lifting in Z direction to make space for extrusion - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 25, active_extruder); + plan_buffer_line_curposXYZE(25, active_extruder); } current_position[E_AXIS] += 10; //extrusion - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 10, active_extruder); + plan_buffer_line_curposXYZE(10, active_extruder); st_current_set(2, E_MOTOR_HIGH_CURRENT); if (current_temperature[0] < 230) { //PLA & all other filaments current_position[E_AXIS] += 5.4; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2800 / 60, active_extruder); + plan_buffer_line_curposXYZE(2800 / 60, active_extruder); current_position[E_AXIS] += 3.2; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); current_position[E_AXIS] += 3; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3400 / 60, active_extruder); + plan_buffer_line_curposXYZE(3400 / 60, active_extruder); } else { //ABS current_position[E_AXIS] += 3.1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2000 / 60, active_extruder); + plan_buffer_line_curposXYZE(2000 / 60, active_extruder); current_position[E_AXIS] += 3.1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 2500 / 60, active_extruder); + plan_buffer_line_curposXYZE(2500 / 60, active_extruder); current_position[E_AXIS] += 4; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 3000 / 60, active_extruder); + plan_buffer_line_curposXYZE(3000 / 60, active_extruder); /*current_position[X_AXIS] += 23; //delay - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); //delay + plan_buffer_line_curposXYZE(600 / 60, active_extruder); //delay current_position[X_AXIS] -= 23; //delay - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 600 / 60, active_extruder); //delay*/ + plan_buffer_line_curposXYZE(600 / 60, active_extruder); //delay*/ delay_keep_alive(4700); } max_feedrate[E_AXIS] = 80; current_position[E_AXIS] -= (bowden_length[mmu_extruder] + 60 + FIL_LOAD_LENGTH) / 2; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 500, active_extruder); + plan_buffer_line_curposXYZE(500, active_extruder); current_position[E_AXIS] -= (bowden_length[mmu_extruder] + 60 + FIL_LOAD_LENGTH) / 2; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 500, active_extruder); + plan_buffer_line_curposXYZE(500, active_extruder); st_synchronize(); //st_current_init(); if (SilentMode != SILENT_MODE_OFF) st_current_set(2, tmp_motor[2]); //set back to normal operation currents @@ -1465,11 +1464,9 @@ bFilamentAction=false; // NOT in "mmu_fil_eject_menu( static bool can_load() { current_position[E_AXIS] += 60; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], MMU_LOAD_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(MMU_LOAD_FEEDRATE, active_extruder); current_position[E_AXIS] -= 52; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], MMU_LOAD_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(MMU_LOAD_FEEDRATE, active_extruder); st_synchronize(); uint_least8_t filament_detected_count = 0; @@ -1479,8 +1476,7 @@ static bool can_load() for(uint_least8_t i = 0; i < steps; ++i) { current_position[E_AXIS] -= e_increment; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], MMU_LOAD_FEEDRATE, active_extruder); + plan_buffer_line_curposXYZE(MMU_LOAD_FEEDRATE, active_extruder); st_synchronize(); if(0 == PIN_GET(IR_SENSOR_PIN)) { @@ -1601,13 +1597,13 @@ void mmu_continue_loading(bool blocking) //lift z current_position[Z_AXIS] += Z_PAUSE_LIFT; if (current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 15, active_extruder); + plan_buffer_line_curposXYZE(15, active_extruder); st_synchronize(); //Move XY to side current_position[X_AXIS] = X_PAUSE_POS; current_position[Y_AXIS] = Y_PAUSE_POS; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 50, active_extruder); + plan_buffer_line_curposXYZE(50, active_extruder); st_synchronize(); mmu_command(MmuCmd::U0); diff --git a/Firmware/planner.cpp b/Firmware/planner.cpp index 4a8d6659..752d0725 100644 --- a/Firmware/planner.cpp +++ b/Firmware/planner.cpp @@ -651,11 +651,15 @@ void planner_abort_hard() waiting_inside_plan_buffer_line_print_aborted = true; } +void plan_buffer_line_curposXYZE(float feed_rate, uint8_t extruder) { + plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feed_rate, extruder ); +} + float junction_deviation = 0.1; // Add a new linear movement to the buffer. steps_x, _y and _z is the absolute position in // mm. Microseconds specify how many microseconds the move should take to perform. To aid acceleration // calculation the caller must also provide the physical length of the line in millimeters. -void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, const uint8_t &extruder) +void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, uint8_t extruder) { // Calculate the buffer head after we push this byte int next_buffer_head = next_block_index(block_buffer_head); diff --git a/Firmware/planner.h b/Firmware/planner.h index b6a9f836..7904c45a 100644 --- a/Firmware/planner.h +++ b/Firmware/planner.h @@ -140,7 +140,14 @@ void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate // Get the position applying the bed level matrix if enabled vector_3 plan_get_position(); #else -void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, const uint8_t &extruder); + +/// Extracting common call of +/// plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], ... +/// saves almost 5KB. +/// The performance penalty is negligible, since these planned lines are usually maintenance moves with the extruder. +void plan_buffer_line_curposXYZE(float feed_rate, uint8_t extruder); + +void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate, uint8_t extruder); //void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate, const uint8_t &extruder); #endif // ENABLE_AUTO_BED_LEVELING diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index 66bdc764..1e0aa9cc 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -2904,7 +2904,7 @@ static void _lcd_move(const char *name, int axis, int min, int max) if (max_software_endstops && current_position[axis] > max) current_position[axis] = max; lcd_encoder = 0; world2machine_clamp(current_position[X_AXIS], current_position[Y_AXIS]); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[axis] / 60, active_extruder); lcd_draw_update = 1; } } @@ -2929,7 +2929,7 @@ static void lcd_move_e() { current_position[E_AXIS] += float((int)lcd_encoder) * move_menu_scale; lcd_encoder = 0; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[E_AXIS] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[E_AXIS] / 60, active_extruder); lcd_draw_update = 1; } } @@ -3428,7 +3428,7 @@ bool lcd_calibrate_z_end_stop_manual(bool only_z) // Only move up, whatever direction the user rotates the encoder. current_position[Z_AXIS] += fabs(lcd_encoder); lcd_encoder = 0; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[Z_AXIS] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[Z_AXIS] / 60, active_extruder); } } if (lcd_clicked()) { @@ -4621,7 +4621,7 @@ void lcd_calibrate_pinda() { lcd_set_cursor(0, 1); lcd_puts_P(_T(MSG_PLEASE_WAIT)); current_position[E_AXIS] += e_shift_calibration; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate, active_extruder); + plan_buffer_line_curposXYZE(feedrate, active_extruder); st_synchronize(); lcd_display_message_fullscreen_P(msg_e_cal_knob); @@ -4644,7 +4644,7 @@ void lcd_calibrate_pinda() { if (!planner_queue_full()) { current_position[E_AXIS] += float(abs((int)lcd_encoder)) * 0.01; //0.05 lcd_encoder = 0; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate, active_extruder); + plan_buffer_line_curposXYZE(feedrate, active_extruder); } } @@ -4764,7 +4764,7 @@ void lcd_language() static void wait_preheat() { current_position[Z_AXIS] = 100; //move in z axis to make space for loading filament - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], homing_feedrate[Z_AXIS] / 60, active_extruder); + plan_buffer_line_curposXYZE(homing_feedrate[Z_AXIS] / 60, active_extruder); delay_keep_alive(2000); lcd_display_message_fullscreen_P(_T(MSG_WIZARD_HEATING)); lcd_set_custom_characters(); @@ -6218,13 +6218,13 @@ void unload_filament() // extr_unload2(); current_position[E_AXIS] -= 45; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 5200 / 60, active_extruder); + plan_buffer_line_curposXYZE(5200 / 60, active_extruder); st_synchronize(); current_position[E_AXIS] -= 15; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 1000 / 60, active_extruder); + plan_buffer_line_curposXYZE(1000 / 60, active_extruder); st_synchronize(); current_position[E_AXIS] -= 20; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 1000 / 60, active_extruder); + plan_buffer_line_curposXYZE(1000 / 60, active_extruder); st_synchronize(); lcd_display_message_fullscreen_P(_T(MSG_PULL_OUT_FILAMENT)); @@ -7308,7 +7308,7 @@ bool lcd_selftest() //homeaxis(X_AXIS); //homeaxis(Y_AXIS); current_position[Z_AXIS] = current_position[Z_AXIS] + 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); _progress = lcd_selftest_screen(TestScreen::AxisZ, _progress, 3, true, 1500); _result = lcd_selfcheck_axis(2, Z_MAX_POS); @@ -7322,7 +7322,7 @@ bool lcd_selftest() if (_result) { current_position[Z_AXIS] = current_position[Z_AXIS] + 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); _progress = lcd_selftest_screen(TestScreen::Home, 0, 2, true, 0); bool bres = tmc2130_home_calibrate(X_AXIS); @@ -7406,7 +7406,7 @@ bool lcd_selftest() static void reset_crash_det(unsigned char axis) { current_position[axis] += 10; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); if (eeprom_read_byte((uint8_t*)EEPROM_CRASH_DET)) tmc2130_sg_stop_on_crash = true; } @@ -7430,7 +7430,7 @@ static bool lcd_selfcheck_axis_sg(unsigned char axis) { if (axis == X_AXIS) { //there is collision between cables and PSU cover in X axis if Z coordinate is too low current_position[Z_AXIS] += 17; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); tmc2130_home_enter(Z_AXIS_MASK); st_synchronize(); tmc2130_home_exit(); @@ -7439,7 +7439,7 @@ static bool lcd_selfcheck_axis_sg(unsigned char axis) { // first axis length measurement begin current_position[axis] -= (axis_length + margin); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); @@ -7449,11 +7449,11 @@ static bool lcd_selfcheck_axis_sg(unsigned char axis) { current_position_init = st_get_position_mm(axis); current_position[axis] += 2 * margin; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); current_position[axis] += axis_length; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); @@ -7469,11 +7469,11 @@ static bool lcd_selfcheck_axis_sg(unsigned char axis) { current_position[axis] -= margin; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); current_position[axis] -= (axis_length + margin); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); @@ -7542,13 +7542,13 @@ static bool lcd_selfcheck_axis(int _axis, int _travel) if (_axis == X_AXIS) { current_position[Z_AXIS] += 17; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); } do { current_position[_axis] = current_position[_axis] - 1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); #ifdef TMC2130 if ((READ(Z_MIN_PIN) ^ (bool)Z_MIN_ENDSTOP_INVERTING)) @@ -7602,7 +7602,7 @@ static bool lcd_selfcheck_axis(int _axis, int _travel) //current_position[_axis] = current_position[_axis] + 15; - //plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + //plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); if (!_stepresult) { @@ -7650,17 +7650,17 @@ static bool lcd_selfcheck_pulleys(int axis) current_position_init = current_position[axis]; current_position[axis] += 2; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); for (i = 0; i < 5; i++) { refresh_cmd_timeout(); current_position[axis] = current_position[axis] + move; st_current_set(0, 850); //set motor current higher - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], 200, active_extruder); + plan_buffer_line_curposXYZE(200, active_extruder); st_synchronize(); if (SilentModeMenu != SILENT_MODE_OFF) st_current_set(0, tmp_motor[0]); //set back to normal operation currents else st_current_set(0, tmp_motor_loud[0]); //set motor current back current_position[axis] = current_position[axis] - move; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], 50, active_extruder); + plan_buffer_line_curposXYZE(50, active_extruder); st_synchronize(); if (((READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING) == 1) || ((READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING) == 1)) { @@ -7677,7 +7677,7 @@ static bool lcd_selfcheck_pulleys(int axis) endstop_triggered = true; if (current_position_init - 1 <= current_position[axis] && current_position_init + 1 >= current_position[axis]) { current_position[axis] += (axis == X_AXIS) ? 13 : 9; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); return(true); } @@ -7688,7 +7688,7 @@ static bool lcd_selfcheck_pulleys(int axis) } else { current_position[axis] -= 1; - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[3], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); st_synchronize(); if (_millis() > timeout_counter) { lcd_selftest_error(TestError::Pulley, (axis == 0) ? "X" : "Y", ""); @@ -7712,7 +7712,7 @@ static bool lcd_selfcheck_endstops() if ((READ(Y_MIN_PIN) ^ Y_MIN_ENDSTOP_INVERTING) == 1) current_position[1] += 10; if ((READ(Z_MIN_PIN) ^ Z_MIN_ENDSTOP_INVERTING) == 1) current_position[2] += 10; } - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[0] / 60, active_extruder); + plan_buffer_line_curposXYZE(manual_feedrate[0] / 60, active_extruder); _delay(500); if (((READ(X_MIN_PIN) ^ X_MIN_ENDSTOP_INVERTING) == 1) || From 3eb36ca194edd7e4a020869663cb534c6ba53ec1 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Fri, 23 Aug 2019 16:48:30 +0200 Subject: [PATCH 20/24] Fix cmdqueue_dump_to_serial. Header was historically made bigger to contain size of the command on SD card, but those debug functions wasn't updated. --- Firmware/cmdqueue.cpp | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/Firmware/cmdqueue.cpp b/Firmware/cmdqueue.cpp index 37b6388d..74a8b90a 100755 --- a/Firmware/cmdqueue.cpp +++ b/Firmware/cmdqueue.cpp @@ -224,9 +224,13 @@ void cmdqueue_dump_to_serial_single_line(int nr, const char *p) SERIAL_ECHOPGM("Entry nr: "); SERIAL_ECHO(nr); SERIAL_ECHOPGM(", type: "); - SERIAL_ECHO(int(*p)); + int type = *p; + SERIAL_ECHO(type); + SERIAL_ECHOPGM(", size: "); + unsigned int size = *(unsigned int*)(p + 1); + SERIAL_ECHO(size); SERIAL_ECHOPGM(", cmd: "); - SERIAL_ECHO(p+1); + SERIAL_ECHO(p + CMDHDRSIZE); SERIAL_ECHOLNPGM(""); } @@ -247,7 +251,7 @@ void cmdqueue_dump_to_serial() for (const char *p = cmdbuffer + bufindr; p < cmdbuffer + bufindw; ++ nr) { cmdqueue_dump_to_serial_single_line(nr, p); // Skip the command. - for (++p; *p != 0; ++ p); + for (p += CMDHDRSIZE; *p != 0; ++ p); // Skip the gaps. for (++p; p < cmdbuffer + bufindw && *p == 0; ++ p); } @@ -255,14 +259,14 @@ void cmdqueue_dump_to_serial() for (const char *p = cmdbuffer + bufindr; p < cmdbuffer + sizeof(cmdbuffer); ++ nr) { cmdqueue_dump_to_serial_single_line(nr, p); // Skip the command. - for (++p; *p != 0; ++ p); + for (p += CMDHDRSIZE; *p != 0; ++ p); // Skip the gaps. for (++p; p < cmdbuffer + sizeof(cmdbuffer) && *p == 0; ++ p); } for (const char *p = cmdbuffer; p < cmdbuffer + bufindw; ++ nr) { cmdqueue_dump_to_serial_single_line(nr, p); // Skip the command. - for (++p; *p != 0; ++ p); + for (p += CMDHDRSIZE; *p != 0; ++ p); // Skip the gaps. for (++p; p < cmdbuffer + bufindw && *p == 0; ++ p); } From 52cb37770b7c36982b7c05f8297fe774a7be70e6 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Fri, 23 Aug 2019 19:27:58 +0200 Subject: [PATCH 21/24] Fix repeated power panic restarted print from beginning or jumped at most 65536 B back in file printed from SD card. As sdpos_atomic was not updated after printer power up and first power panic recovery, it was equal 0. When the first command from SD card was queued its size on SD card was computed as current SD index position minus sdpos_atomic. This was equal to offset from beginning of the file limited to 16 bit storage type. When next power outage occurred earlier then this command was finished and wiped out of queue, this command size (extraordinarily big) was subtracted from sdpos_atomic and saved to EEPROM. This led to up to 65536 B jump back in file printed after next power panic recovery. --- Firmware/Marlin_main.cpp | 6 ++++-- Firmware/cmdqueue.h | 2 ++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 10c5437e..79cdba1a 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -5343,7 +5343,9 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) // ---------------------------------- case 26: if(card.cardOK && code_seen('S')) { - card.setIndex(code_value_long()); + long index = code_value_long(); + card.setIndex(index); + sdpos_atomic = index; } break; @@ -9497,7 +9499,7 @@ void serialecho_temperatures() { SERIAL_PROTOCOL_F(degBed(), 1); SERIAL_PROTOCOLLN(""); } -extern uint32_t sdpos_atomic; + #ifdef UVLO_SUPPORT void uvlo_() diff --git a/Firmware/cmdqueue.h b/Firmware/cmdqueue.h index 6c81db29..13185f17 100644 --- a/Firmware/cmdqueue.h +++ b/Firmware/cmdqueue.h @@ -45,6 +45,8 @@ extern bool cmdbuffer_front_already_processed; // Debugging information will be sent to serial line. //#define CMDBUFFER_DEBUG +extern uint32_t sdpos_atomic; + extern int serial_count; extern boolean comment_mode; extern char *strchr_pointer; From c27fcf9cffafb9837bcfc0b39bc189e4b8c72849 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Mon, 26 Aug 2019 17:03:18 +0200 Subject: [PATCH 22/24] Increase version to 3.8.0-RC2 and build number to 2639. --- Firmware/Configuration.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Firmware/Configuration.h b/Firmware/Configuration.h index 870eee89..ebda4960 100644 --- a/Firmware/Configuration.h +++ b/Firmware/Configuration.h @@ -16,8 +16,8 @@ extern uint16_t nPrinterType; extern PGM_P sPrinterName; // Firmware version -#define FW_VERSION "3.8.0" -#define FW_COMMIT_NR 2608 +#define FW_VERSION "3.8.0-RC2" +#define FW_COMMIT_NR 2639 // FW_VERSION_UNKNOWN means this is an unofficial build. // The firmware should only be checked into github with this symbol. #define FW_DEV_VERSION FW_VERSION_UNKNOWN From 159a1a70d8d168d98269fd5c21bef14d0275b577 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Mon, 26 Aug 2019 17:19:57 +0200 Subject: [PATCH 23/24] Update documentation. --- Firmware/Marlin_main.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 79cdba1a..5279776d 100755 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -5339,12 +5339,17 @@ if(eSoundMode!=e_SOUND_MODE_SILENT) card.pauseSDPrint(); break; - //! ### M26 - Set SD index + //! ### M26 S\ - Set SD index + //! Set position in SD card file to index in bytes. + //! This command is expected to be called after M23 and before M24. + //! Otherwise effect of this command is undefined. // ---------------------------------- case 26: if(card.cardOK && code_seen('S')) { long index = code_value_long(); card.setIndex(index); + // We don't disable interrupt during update of sdpos_atomic + // as we expect, that SD card print is not active in this moment sdpos_atomic = index; } break; From bf2097342dfe4ef8902a67805f92e644e4cb4e75 Mon Sep 17 00:00:00 2001 From: Marek Bel Date: Tue, 27 Aug 2019 17:01:41 +0200 Subject: [PATCH 24/24] Add ASA preheat into mFilamentMenu(); --- Firmware/ultralcd.cpp | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index e601fd75..43ab4042 100755 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -2486,6 +2486,12 @@ bFilamentPreheatState=false; mFilamentItem(PET_PREHEAT_HOTEND_TEMP,PET_PREHEAT_HPB_TEMP); } +static void mFilamentItem_ASA() +{ + bFilamentPreheatState=false; + mFilamentItem(ASA_PREHEAT_HOTEND_TEMP,ASA_PREHEAT_HPB_TEMP); +} + static void mFilamentItem_ABS() { bFilamentPreheatState=false; @@ -2520,15 +2526,16 @@ if(eFilamentAction==FilamentAction::AutoLoad) void mFilamentMenu() { -MENU_BEGIN(); -MENU_ITEM_FUNCTION_P(_T(MSG_MAIN),mFilamentBack); -MENU_ITEM_SUBMENU_P(PSTR("PLA - " STRINGIFY(PLA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PLA_PREHEAT_HPB_TEMP)),mFilamentItem_PLA); -MENU_ITEM_SUBMENU_P(PSTR("PET - " STRINGIFY(PET_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PET_PREHEAT_HPB_TEMP)),mFilamentItem_PET); -MENU_ITEM_SUBMENU_P(PSTR("ABS - " STRINGIFY(ABS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ABS_PREHEAT_HPB_TEMP)),mFilamentItem_ABS); -MENU_ITEM_SUBMENU_P(PSTR("HIPS - " STRINGIFY(HIPS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(HIPS_PREHEAT_HPB_TEMP)),mFilamentItem_HIPS); -MENU_ITEM_SUBMENU_P(PSTR("PP - " STRINGIFY(PP_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PP_PREHEAT_HPB_TEMP)),mFilamentItem_PP); -MENU_ITEM_SUBMENU_P(PSTR("FLEX - " STRINGIFY(FLEX_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(FLEX_PREHEAT_HPB_TEMP)),mFilamentItem_FLEX); -MENU_END(); + MENU_BEGIN(); + MENU_ITEM_FUNCTION_P(_T(MSG_MAIN),mFilamentBack); + MENU_ITEM_SUBMENU_P(PSTR("PLA - " STRINGIFY(PLA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PLA_PREHEAT_HPB_TEMP)),mFilamentItem_PLA); + MENU_ITEM_SUBMENU_P(PSTR("PET - " STRINGIFY(PET_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PET_PREHEAT_HPB_TEMP)),mFilamentItem_PET); + MENU_ITEM_SUBMENU_P(PSTR("ASA - " STRINGIFY(ASA_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ASA_PREHEAT_HPB_TEMP)),mFilamentItem_ASA); + MENU_ITEM_SUBMENU_P(PSTR("ABS - " STRINGIFY(ABS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(ABS_PREHEAT_HPB_TEMP)),mFilamentItem_ABS); + MENU_ITEM_SUBMENU_P(PSTR("HIPS - " STRINGIFY(HIPS_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(HIPS_PREHEAT_HPB_TEMP)),mFilamentItem_HIPS); + MENU_ITEM_SUBMENU_P(PSTR("PP - " STRINGIFY(PP_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(PP_PREHEAT_HPB_TEMP)),mFilamentItem_PP); + MENU_ITEM_SUBMENU_P(PSTR("FLEX - " STRINGIFY(FLEX_PREHEAT_HOTEND_TEMP) "/" STRINGIFY(FLEX_PREHEAT_HPB_TEMP)),mFilamentItem_FLEX); + MENU_END(); } void mFilamentItemForce()