123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822 |
- /**
- * Marlin 3D Printer Firmware
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
- /**************
- * ui_api.cpp *
- **************/
-
- /****************************************************************************
- * Written By Marcio Teixeira 2018 - Aleph Objects, Inc. *
- * *
- * This program is free software: you can redistribute it and/or modify *
- * it under the terms of the GNU General Public License as published by *
- * the Free Software Foundation, either version 3 of the License, or *
- * (at your option) any later version. *
- * *
- * This program is distributed in the hope that it will be useful, *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
- * GNU General Public License for more details. *
- * *
- * To view a copy of the GNU General Public License, go to the following *
- * location: <http://www.gnu.org/licenses/>. *
- ****************************************************************************/
-
- #include "../../inc/MarlinConfigPre.h"
-
- #if ENABLED(EXTENSIBLE_UI)
-
- #include "../ultralcd.h"
- #include "../../gcode/queue.h"
- #include "../../module/motion.h"
- #include "../../module/planner.h"
- #include "../../module/probe.h"
- #include "../../module/temperature.h"
- #include "../../module/printcounter.h"
- #include "../../libs/duration_t.h"
- #include "../../HAL/shared/Delay.h"
-
- #if ENABLED(PRINTCOUNTER)
- #include "../../core/utility.h"
- #endif
-
- #if DO_SWITCH_EXTRUDER || ENABLED(SWITCHING_NOZZLE) || ENABLED(PARKING_EXTRUDER)
- #include "../../module/tool_change.h"
- #endif
-
- #if ENABLED(EMERGENCY_PARSER)
- #include "../../feature/emergency_parser.h"
- #endif
-
- #if ENABLED(SDSUPPORT)
- #include "../../sd/cardreader.h"
- #define IFSD(A,B) (A)
- #else
- #define IFSD(A,B) (B)
- #endif
-
- #if HAS_TRINAMIC && HAS_LCD_MENU
- #include "../../feature/tmc_util.h"
- #endif
-
- #include "ui_api.h"
-
- #if ENABLED(BACKLASH_GCODE)
- extern float backlash_distance_mm[XYZ], backlash_correction;
- #ifdef BACKLASH_SMOOTHING_MM
- extern float backlash_smoothing_mm;
- #endif
- #endif
-
- #if HAS_FILAMENT_SENSOR
- #include "../../feature/runout.h"
- #endif
-
- inline float clamp(const float value, const float minimum, const float maximum) {
- return MAX(MIN(value, maximum), minimum);
- }
-
- static struct {
- uint8_t printer_killed : 1;
- uint8_t manual_motion : 1;
- } flags;
-
- namespace ExtUI {
-
- #ifdef __SAM3X8E__
- /**
- * Implement a special millis() to allow time measurement
- * within an ISR (such as when the printer is killed).
- *
- * To keep proper time, must be called at least every 1s.
- */
- uint32_t safe_millis() {
- // Not killed? Just call millis()
- if (!flags.printer_killed) return millis();
-
- static uint32_t currTimeHI = 0; /* Current time */
-
- // Machine was killed, reinit SysTick so we are able to compute time without ISRs
- if (currTimeHI == 0) {
- // Get the last time the Arduino time computed (from CMSIS) and convert it to SysTick
- currTimeHI = (uint32_t)((GetTickCount() * (uint64_t)(F_CPU / 8000)) >> 24);
-
- // Reinit the SysTick timer to maximize its period
- SysTick->LOAD = SysTick_LOAD_RELOAD_Msk; // get the full range for the systick timer
- SysTick->VAL = 0; // Load the SysTick Counter Value
- SysTick->CTRL = // MCLK/8 as source
- // No interrupts
- SysTick_CTRL_ENABLE_Msk; // Enable SysTick Timer
- }
-
- // Check if there was a timer overflow from the last read
- if (SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk) {
- // There was. This means (SysTick_LOAD_RELOAD_Msk * 1000 * 8)/F_CPU ms has elapsed
- currTimeHI++;
- }
-
- // Calculate current time in milliseconds
- uint32_t currTimeLO = SysTick_LOAD_RELOAD_Msk - SysTick->VAL; // (in MCLK/8)
- uint64_t currTime = ((uint64_t)currTimeLO) | (((uint64_t)currTimeHI) << 24);
-
- // The ms count is
- return (uint32_t)(currTime / (F_CPU / 8000));
- }
- #endif // __SAM3X8E__
-
- void delay_us(unsigned long us) {
- DELAY_US(us);
- }
-
- void delay_ms(unsigned long ms) {
- if (flags.printer_killed)
- DELAY_US(ms * 1000);
- else
- safe_delay(ms);
- }
-
- void yield() {
- if (!flags.printer_killed)
- thermalManager.manage_heater();
- }
-
- float getActualTemp_celsius(const heater_t heater) {
- return heater == BED ?
- #if HAS_HEATED_BED
- thermalManager.degBed()
- #else
- 0
- #endif
- : thermalManager.degHotend(heater - H0);
- }
-
- float getActualTemp_celsius(const extruder_t extruder) {
- return thermalManager.degHotend(extruder - E0);
- }
-
- float getTargetTemp_celsius(const heater_t heater) {
- return heater == BED ?
- #if HAS_HEATED_BED
- thermalManager.degTargetBed()
- #else
- 0
- #endif
- : thermalManager.degTargetHotend(heater - H0);
- }
-
- float getTargetTemp_celsius(const extruder_t extruder) {
- return thermalManager.degTargetHotend(extruder - E0);
- }
-
- float getTargetFan_percent(const fan_t fan) {
- return thermalManager.fanPercent(thermalManager.fan_speed[fan - FAN0]);
- }
-
- float getActualFan_percent(const fan_t fan) {
- return thermalManager.fanPercent((thermalManager.fan_speed[fan - FAN0] * uint16_t(thermalManager.fan_speed_scaler[fan - FAN0])) >> 7);
- }
-
- float getAxisPosition_mm(const axis_t axis) {
- return flags.manual_motion ? destination[axis] : current_position[axis];
- }
-
- float getAxisPosition_mm(const extruder_t extruder) {
- return flags.manual_motion ? destination[E_AXIS] : current_position[E_AXIS];
- }
-
- void setAxisPosition_mm(const float position, const axis_t axis) {
- // Start with no limits to movement
- float min = current_position[axis] - 1000,
- max = current_position[axis] + 1000;
-
- // Limit to software endstops, if enabled
- #if HAS_SOFTWARE_ENDSTOPS
- if (soft_endstops_enabled) switch (axis) {
- case X_AXIS:
- #if ENABLED(MIN_SOFTWARE_ENDSTOP_X)
- min = soft_endstop_min[X_AXIS];
- #endif
- #if ENABLED(MAX_SOFTWARE_ENDSTOP_X)
- max = soft_endstop_max[X_AXIS];
- #endif
- break;
- case Y_AXIS:
- #if ENABLED(MIN_SOFTWARE_ENDSTOP_Y)
- min = soft_endstop_min[Y_AXIS];
- #endif
- #if ENABLED(MAX_SOFTWARE_ENDSTOP_Y)
- max = soft_endstop_max[Y_AXIS];
- #endif
- break;
- case Z_AXIS:
- #if ENABLED(MIN_SOFTWARE_ENDSTOP_Z)
- min = soft_endstop_min[Z_AXIS];
- #endif
- #if ENABLED(MAX_SOFTWARE_ENDSTOP_Z)
- max = soft_endstop_max[Z_AXIS];
- #endif
- default: break;
- }
- #endif // HAS_SOFTWARE_ENDSTOPS
-
- // Delta limits XY based on the current offset from center
- // This assumes the center is 0,0
- #if ENABLED(DELTA)
- if (axis != Z_AXIS) {
- max = SQRT(sq((float)(DELTA_PRINTABLE_RADIUS)) - sq(current_position[Y_AXIS - axis])); // (Y_AXIS - axis) == the other axis
- min = -max;
- }
- #endif
-
- if (!flags.manual_motion)
- set_destination_from_current();
- destination[axis] = clamp(position, min, max);
- flags.manual_motion = true;
- }
-
- void setAxisPosition_mm(const float position, const extruder_t extruder) {
- setActiveTool(extruder, true);
-
- if (!flags.manual_motion)
- set_destination_from_current();
- destination[E_AXIS] = position;
- flags.manual_motion = true;
- }
-
- void _processManualMoveToDestination() {
- // Lower max_response_lag makes controls more responsive, but makes CPU work harder
- constexpr float max_response_lag = 0.1; // seconds
- constexpr uint8_t segments_to_buffer = 4; // keep planner filled with this many segments
-
- if (flags.manual_motion && planner.movesplanned() < segments_to_buffer) {
- float saved_destination[XYZ];
- COPY(saved_destination, destination);
- // Compute direction vector from current_position towards destination.
- destination[X_AXIS] -= current_position[X_AXIS];
- destination[Y_AXIS] -= current_position[Y_AXIS];
- destination[Z_AXIS] -= current_position[Z_AXIS];
- const float inv_length = RSQRT(sq(destination[X_AXIS]) + sq(destination[Y_AXIS]) + sq(destination[Z_AXIS]));
- // Find move segment length so that all segments can execute in less time than max_response_lag
- const float scale = inv_length * feedrate_mm_s * max_response_lag / segments_to_buffer;
- if (scale < 1) {
- // Move a small bit towards the destination.
- destination[X_AXIS] = scale * destination[X_AXIS] + current_position[X_AXIS];
- destination[Y_AXIS] = scale * destination[Y_AXIS] + current_position[Y_AXIS];
- destination[Z_AXIS] = scale * destination[Z_AXIS] + current_position[Z_AXIS];
- prepare_move_to_destination();
- COPY(destination, saved_destination);
- }
- else {
- // We are close enough to finish off the move.
- COPY(destination, saved_destination);
- prepare_move_to_destination();
- flags.manual_motion = false;
- }
- }
- }
-
- void setActiveTool(const extruder_t extruder, bool no_move) {
- #if EXTRUDERS > 1
- const uint8_t e = extruder - E0;
- #if DO_SWITCH_EXTRUDER || ENABLED(SWITCHING_NOZZLE) || ENABLED(PARKING_EXTRUDER)
- if (e != active_extruder)
- tool_change(e, 0, no_move);
- #endif
- active_extruder = e;
- #endif
- }
-
- extruder_t getActiveTool() {
- switch (active_extruder) {
- case 5: return E5;
- case 4: return E4;
- case 3: return E3;
- case 2: return E2;
- case 1: return E1;
- default: return E0;
- }
- }
-
- bool isMoving() { return planner.has_blocks_queued(); }
-
- bool canMove(const axis_t axis) {
- switch (axis) {
- #if IS_KINEMATIC || ENABLED(NO_MOTION_BEFORE_HOMING)
- case X: return TEST(axis_homed, X_AXIS);
- case Y: return TEST(axis_homed, Y_AXIS);
- case Z: return TEST(axis_homed, Z_AXIS);
- #else
- case X: case Y: case Z: return true;
- #endif
- default: return false;
- }
- }
-
- bool canMove(const extruder_t extruder) {
- return !thermalManager.tooColdToExtrude(extruder - E0);
- }
-
- float getAxisSteps_per_mm(const axis_t axis) {
- return planner.settings.axis_steps_per_mm[axis];
- }
-
- float getAxisSteps_per_mm(const extruder_t extruder) {
- return planner.settings.axis_steps_per_mm[E_AXIS_N(extruder - E0)];
- }
-
- void setAxisSteps_per_mm(const float value, const axis_t axis) {
- planner.settings.axis_steps_per_mm[axis] = value;
- }
-
- void setAxisSteps_per_mm(const float value, const extruder_t extruder) {
- planner.settings.axis_steps_per_mm[E_AXIS_N(axis - E0)] = value;
- }
-
- float getAxisMaxFeedrate_mm_s(const axis_t axis) {
- return planner.settings.max_feedrate_mm_s[axis];
- }
-
- float getAxisMaxFeedrate_mm_s(const extruder_t extruder) {
- return planner.settings.max_feedrate_mm_s[E_AXIS_N(axis - E0)];
- }
-
- void setAxisMaxFeedrate_mm_s(const float value, const axis_t axis) {
- planner.settings.max_feedrate_mm_s[axis] = value;
- }
-
- void setAxisMaxFeedrate_mm_s(const float value, const extruder_t extruder) {
- planner.settings.max_feedrate_mm_s[E_AXIS_N(axis - E0)] = value;
- }
-
- float getAxisMaxAcceleration_mm_s2(const axis_t axis) {
- return planner.settings.max_acceleration_mm_per_s2[axis];
- }
-
- float getAxisMaxAcceleration_mm_s2(const extruder_t extruder) {
- return planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(extruder - E0)];
- }
-
- void setAxisMaxAcceleration_mm_s2(const float value, const axis_t axis) {
- planner.settings.max_acceleration_mm_per_s2[axis] = value;
- }
-
- void setAxisMaxAcceleration_mm_s2(const float value, const extruder_t extruder) {
- planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(extruder - E0)] = value;
- }
-
- #if HAS_FILAMENT_SENSOR
- bool getFilamentRunoutEnabled() { return runout.enabled; }
- void setFilamentRunoutEnabled(const bool value) { runout.enabled = value; }
-
- #if FILAMENT_RUNOUT_DISTANCE_MM > 0
- float getFilamentRunoutDistance_mm() {
- return RunoutResponseDelayed::runout_distance_mm;
- }
-
- void setFilamentRunoutDistance_mm(const float value) {
- RunoutResponseDelayed::runout_distance_mm = clamp(value, 0, 999);
- }
- #endif
- #endif
-
- #if ENABLED(LIN_ADVANCE)
- float getLinearAdvance_mm_mm_s(const extruder_t extruder) {
- return (extruder < EXTRUDERS) ? planner.extruder_advance_K[extruder - E0] : 0;
- }
-
- void setLinearAdvance_mm_mm_s(const float value, const extruder_t extruder) {
- if (extruder < EXTRUDERS)
- planner.extruder_advance_K[extruder - E0] = clamp(value, 0, 999);
- }
- #endif
-
- #if ENABLED(JUNCTION_DEVIATION)
-
- float getJunctionDeviation_mm() {
- return planner.junction_deviation_mm;
- }
-
- void setJunctionDeviation_mm(const float value) {
- planner.junction_deviation_mm = clamp(value, 0.01, 0.3);
- planner.recalculate_max_e_jerk();
- }
-
- #else
-
- float getAxisMaxJerk_mm_s(const axis_t axis) {
- return planner.max_jerk[axis];
- }
-
- float getAxisMaxJerk_mm_s(const extruder_t extruder) {
- return planner.max_jerk[E_AXIS];
- }
-
- void setAxisMaxJerk_mm_s(const float value, const axis_t axis) {
- planner.max_jerk[axis] = value;
- }
-
- void setAxisMaxJerk_mm_s(const float value, const extruder_t extruder) {
- planner.max_jerk[E_AXIS] = value;
- }
- #endif
-
- float getFeedrate_mm_s() { return feedrate_mm_s; }
- float getMinFeedrate_mm_s() { return planner.settings.min_feedrate_mm_s; }
- float getMinTravelFeedrate_mm_s() { return planner.settings.min_travel_feedrate_mm_s; }
- float getPrintingAcceleration_mm_s2() { return planner.settings.acceleration; }
- float getRetractAcceleration_mm_s2() { return planner.settings.retract_acceleration; }
- float getTravelAcceleration_mm_s2() { return planner.settings.travel_acceleration; }
- void setFeedrate_mm_s(const float fr) { feedrate_mm_s = fr; }
- void setMinFeedrate_mm_s(const float fr) { planner.settings.min_feedrate_mm_s = fr; }
- void setMinTravelFeedrate_mm_s(const float fr) { planner.settings.min_travel_feedrate_mm_s = fr; }
- void setPrintingAcceleration_mm_s2(const float acc) { planner.settings.acceleration = acc; }
- void setRetractAcceleration_mm_s2(const float acc) { planner.settings.retract_acceleration = acc; }
- void setTravelAcceleration_mm_s2(const float acc) { planner.settings.travel_acceleration = acc; }
-
- #if ENABLED(BABYSTEPPING)
- bool babystepAxis_steps(const int16_t steps, const axis_t axis) {
- switch (axis) {
- #if ENABLED(BABYSTEP_XY)
- case X: thermalManager.babystep_axis(X_AXIS, steps); break;
- case Y: thermalManager.babystep_axis(Y_AXIS, steps); break;
- #endif
- case Z: thermalManager.babystep_axis(Z_AXIS, steps); break;
- default: return false;
- };
- return true;
- }
-
- /**
- * This function adjusts an axis during a print.
- *
- * When linked_nozzles is false, each nozzle in a multi-nozzle
- * printer can be babystepped independently of the others. This
- * lets the user to fine tune the Z-offset and Nozzle Offsets
- * while observing the first layer of a print, regardless of
- * what nozzle is printing.
- */
- void smartAdjustAxis_steps(const int16_t steps, const axis_t axis, bool linked_nozzles) {
- const float mm = steps * planner.steps_to_mm[axis];
-
- if (!babystepAxis_steps(steps, axis)) return;
-
- #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
- // Make it so babystepping in Z adjusts the Z probe offset.
- if (axis == Z
- #if EXTRUDERS > 1
- && (linked_nozzles || active_extruder == 0)
- #endif
- ) zprobe_zoffset += mm;
- #endif
-
- #if EXTRUDERS > 1
- /**
- * When linked_nozzles is false, as an axis is babystepped
- * adjust the hotend offsets so that the other nozzles are
- * unaffected by the babystepping of the active nozzle.
- */
- if (!linked_nozzles) {
- HOTEND_LOOP()
- if (e != active_extruder)
- hotend_offset[axis][e] += mm;
-
- normalizeNozzleOffset(X);
- normalizeNozzleOffset(Y);
- normalizeNozzleOffset(Z);
- }
- #else
- UNUSED(linked_nozzles);
- #endif
- }
-
- /**
- * Converts a mm displacement to a number of whole number of
- * steps that is at least mm long.
- */
- int16_t mmToWholeSteps(const float mm, const axis_t axis) {
- const float steps = mm / planner.steps_to_mm[axis];
- return steps > 0 ? ceil(steps) : floor(steps);
- }
- #endif
-
- #if HAS_BED_PROBE
- float getZOffset_mm() {
- return zprobe_zoffset;
- }
-
- void setZOffset_mm(const float value) {
- if (WITHIN(value, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) {
- zprobe_zoffset = value;
- }
- }
- #endif // HAS_BED_PROBE
-
- #if HAS_HOTEND_OFFSET
-
- float getNozzleOffset_mm(const axis_t axis, const extruder_t extruder) {
- if (extruder - E0 >= HOTENDS) return 0;
- return hotend_offset[axis][extruder - E0];
- }
-
- void setNozzleOffset_mm(const float value, const axis_t axis, const extruder_t extruder) {
- if (extruder - E0 >= HOTENDS) return;
- hotend_offset[axis][extruder - E0] = value;
- }
-
- /**
- * The UI should call this if needs to guarantee the first
- * nozzle offset is zero (such as when it doesn't allow the
- * user to edit the offset the first nozzle).
- */
- void normalizeNozzleOffset(const axis_t axis) {
- const float offs = hotend_offset[axis][0];
- HOTEND_LOOP() hotend_offset[axis][e] -= offs;
- }
-
- #endif // HAS_HOTEND_OFFSET
-
- #if ENABLED(BACKLASH_GCODE)
- float getAxisBacklash_mm(const axis_t axis) { return backlash_distance_mm[axis]; }
- void setAxisBacklash_mm(const float value, const axis_t axis)
- { backlash_distance_mm[axis] = clamp(value,0,5); }
-
- float getBacklashCorrection_percent() { return backlash_correction * 100; }
- void setBacklashCorrection_percent(const float value) { backlash_correction = clamp(value, 0, 100) / 100.0f; }
-
- #ifdef BACKLASH_SMOOTHING_MM
- float getBacklashSmoothing_mm() { return backlash_smoothing_mm; }
- void setBacklashSmoothing_mm(const float value) { backlash_smoothing_mm = clamp(value, 0, 999); }
- #endif
- #endif
-
- uint8_t getProgress_percent() {
- return ui.get_progress();
- }
-
- uint32_t getProgress_seconds_elapsed() {
- const duration_t elapsed = print_job_timer.duration();
- return elapsed.value;
- }
-
- #if HAS_LEVELING
- bool getLevelingActive() { return planner.leveling_active; }
- void setLevelingActive(const bool state) { set_bed_leveling_enabled(state) }
- #if HAS_MESH
- bool getMeshValid() { return leveling_is_valid(); }
- bed_mesh_t getMeshArray() { return Z_VALUES; }
- void setMeshPoint(const uint8_t xpos, const uint8_t ypos, const float zoff) {
- if (WITHIN(xpos, 0, GRID_MAX_POINTS_X) && WITHIN(ypos, 0, GRID_MAX_POINTS_Y)) {
- Z_VALUES(xpos, ypos) = zoff;
- #if ENABLED(ABL_BILINEAR_SUBDIVISION)
- bed_level_virt_interpolate();
- #endif
- }
- }
- #endif
- #endif
-
- #if ENABLED(HOST_PROMPT_SUPPORT)
- void setHostResponse(const uint8_t response) { host_response_handler(response); }
- #endif
-
- #if ENABLED(PRINTCOUNTER)
- char* getTotalPrints_str(char buffer[21]) { strcpy(buffer,i16tostr3left(print_job_timer.getStats().totalPrints)); return buffer; }
- char* getFinishedPrints_str(char buffer[21]) { strcpy(buffer,i16tostr3left(print_job_timer.getStats().finishedPrints)); return buffer; }
- char* getTotalPrintTime_str(char buffer[21]) { duration_t(print_job_timer.getStats().printTime).toString(buffer); return buffer; }
- char* getLongestPrint_str(char buffer[21]) { duration_t(print_job_timer.getStats().printTime).toString(buffer); return buffer; }
- char* getFilamentUsed_str(char buffer[21]) {
- printStatistics stats = print_job_timer.getStats();
- sprintf_P(buffer, PSTR("%ld.%im"), long(stats.filamentUsed / 1000), int16_t(stats.filamentUsed / 100) % 10);
- return buffer;
- }
- #endif
-
- float getFeedrate_percent() { return feedrate_percentage; }
-
- void enqueueCommands_P(PGM_P const gcode) {
- enqueue_and_echo_commands_P(gcode);
- }
-
- bool isAxisPositionKnown(const axis_t axis) {
- return TEST(axis_known_position, axis);
- }
-
- PGM_P getFirmwareName_str() {
- static const char firmware_name[] PROGMEM = "Marlin " SHORT_BUILD_VERSION;
- return firmware_name;
- }
-
- void setTargetTemp_celsius(float value, const heater_t heater) {
- constexpr int16_t heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP);
- const int16_t e = heater - H0;
- #if HAS_HEATED_BED
- if (heater == BED)
- thermalManager.setTargetBed(clamp(value, 0, BED_MAXTEMP - 10));
- else
- #endif
- thermalManager.setTargetHotend(clamp(value, 0, heater_maxtemp[e] - 15), e);
- }
-
- void setTargetTemp_celsius(float value, const extruder_t extruder) {
- constexpr int16_t heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP);
- const int16_t e = extruder - E0;
- thermalManager.setTargetHotend(clamp(value, 0, heater_maxtemp[e] - 15), e);
- }
-
- void setTargetFan_percent(const float value, const fan_t fan) {
- if (fan < FAN_COUNT)
- thermalManager.set_fan_speed(fan - FAN0, map(clamp(value, 0, 100), 0, 100, 0, 255));
- }
-
- void setFeedrate_percent(const float value) {
- feedrate_percentage = clamp(value, 10, 500);
- }
-
- void setUserConfirmed(void) {
- #if HAS_RESUME_CONTINUE
- wait_for_user = false;
- #endif
- }
-
- void printFile(const char *filename) {
- IFSD(card.openAndPrintFile(filename), NOOP);
- }
-
- bool isPrintingFromMediaPaused() {
- return IFSD(isPrintingFromMedia() && !IS_SD_PRINTING(), false);
- }
-
- bool isPrintingFromMedia() {
- return IFSD(card.isFileOpen(), false);
- }
-
- bool isPrinting() {
- return (planner.movesplanned() || isPrintingFromMedia() || IFSD(IS_SD_PRINTING(), false));
- }
-
- bool isMediaInserted() {
- return IFSD(IS_SD_INSERTED() && card.isDetected(), false);
- }
-
- void pausePrint() {
- #if ENABLED(SDSUPPORT)
- card.pauseSDPrint();
- print_job_timer.pause();
- #if ENABLED(PARK_HEAD_ON_PAUSE)
- enqueue_and_echo_commands_P(PSTR("M125"));
- #endif
- ui.set_status_P(PSTR(MSG_PRINT_PAUSED));
- #endif
- }
-
- void resumePrint() {
- #if ENABLED(SDSUPPORT)
- ui.set_status_P(PSTR(MSG_FILAMENT_CHANGE_RESUME_1));
- #if ENABLED(PARK_HEAD_ON_PAUSE)
- wait_for_heatup = wait_for_user = false;
- enqueue_and_echo_commands_P(PSTR("M24"));
- #else
- card.startFileprint();
- print_job_timer.start();
- #endif
- #endif
- }
-
- void stopPrint() {
- #if ENABLED(SDSUPPORT)
- wait_for_heatup = wait_for_user = false;
- card.flag.abort_sd_printing = true;
- ui.set_status_P(PSTR(MSG_PRINT_ABORTED));
- #endif
- }
-
- FileList::FileList() { refresh(); }
-
- void FileList::refresh() { num_files = 0xFFFF; }
-
- bool FileList::seek(const uint16_t pos, const bool skip_range_check) {
- #if ENABLED(SDSUPPORT)
- if (!skip_range_check && (pos + 1) > count()) return false;
- const uint16_t nr =
- #if ENABLED(SDCARD_RATHERRECENTFIRST) && DISABLED(SDCARD_SORT_ALPHA)
- count() - 1 -
- #endif
- pos;
-
- card.getfilename_sorted(nr);
- return card.filename[0] != '\0';
- #else
- return false;
- #endif
- }
-
- const char* FileList::filename() {
- return IFSD(card.longFilename[0] ? card.longFilename : card.filename, "");
- }
-
- const char* FileList::shortFilename() {
- return IFSD(card.filename, "");
- }
-
- const char* FileList::longFilename() {
- return IFSD(card.longFilename, "");
- }
-
- bool FileList::isDir() {
- return IFSD(card.flag.filenameIsDir, false);
- }
-
- uint16_t FileList::count() {
- return IFSD((num_files = (num_files == 0xFFFF ? card.get_num_Files() : num_files)), 0);
- }
-
- bool FileList::isAtRootDir() {
- #if ENABLED(SDSUPPORT)
- card.getWorkDirName();
- return card.filename[0] == '/';
- #else
- return true;
- #endif
- }
-
- void FileList::upDir() {
- #if ENABLED(SDSUPPORT)
- card.updir();
- num_files = 0xFFFF;
- #endif
- }
-
- void FileList::changeDir(const char * const dirname) {
- #if ENABLED(SDSUPPORT)
- card.chdir(dirname);
- num_files = 0xFFFF;
- #endif
- }
-
- } // namespace ExtUI
-
- // At the moment, we piggy-back off the ultralcd calls, but this could be cleaned up in the future
-
- void MarlinUI::init() {
- #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
- SET_INPUT_PULLUP(SD_DETECT_PIN);
- #endif
-
- #if HAS_TRINAMIC && HAS_LCD_MENU
- init_tmc_section();
- #endif
-
- ExtUI::onStartup();
- }
-
- void MarlinUI::update() {
- #if ENABLED(SDSUPPORT)
- static bool last_sd_status;
- const bool sd_status = IS_SD_INSERTED();
- if (sd_status != last_sd_status) {
- last_sd_status = sd_status;
- if (sd_status) {
- card.initsd();
- if (card.isDetected())
- ExtUI::onMediaInserted();
- else
- ExtUI::onMediaError();
- }
- else {
- const bool ok = card.isDetected();
- card.release();
- if (ok) ExtUI::onMediaRemoved();
- }
- }
- #endif // SDSUPPORT
- ExtUI::_processManualMoveToDestination();
- ExtUI::onIdle();
- }
-
- void MarlinUI::kill_screen(PGM_P const msg) {
- if (!flags.printer_killed) {
- flags.printer_killed = true;
- ExtUI::onPrinterKilled(msg);
- }
- }
-
- #endif // EXTENSIBLE_UI
|