From e8701195e66f2d27ffe17fb514eae8173795aaf7 Mon Sep 17 00:00:00 2001
From: Georgiy Bondarenko <69736697+nehilo@users.noreply.github.com>
Date: Thu, 4 Mar 2021 22:54:23 +0500
Subject: Initial commit
---
Marlin/src/lcd/extui/ui_api.cpp | 1074 +++++++++++++++++++++++++++++++++++++++
1 file changed, 1074 insertions(+)
create mode 100644 Marlin/src/lcd/extui/ui_api.cpp
(limited to 'Marlin/src/lcd/extui/ui_api.cpp')
diff --git a/Marlin/src/lcd/extui/ui_api.cpp b/Marlin/src/lcd/extui/ui_api.cpp
new file mode 100644
index 0000000..d1ffb4c
--- /dev/null
+++ b/Marlin/src/lcd/extui/ui_api.cpp
@@ -0,0 +1,1074 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 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 .
+ *
+ */
+
+/**************
+ * 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: . *
+ ****************************************************************************/
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if ENABLED(EXTENSIBLE_UI)
+
+#include "../marlinui.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"
+#include "../../sd/cardreader.h"
+
+#if ENABLED(PRINTCOUNTER)
+ #include "../../core/utility.h"
+ #include "../../libs/numtostr.h"
+#endif
+
+#if HAS_MULTI_EXTRUDER
+ #include "../../module/tool_change.h"
+#endif
+
+#if ENABLED(EMERGENCY_PARSER)
+ #include "../../feature/e_parser.h"
+#endif
+
+#if HAS_TRINAMIC_CONFIG
+ #include "../../feature/tmc_util.h"
+ #include "../../module/stepper/indirection.h"
+#endif
+
+#include "ui_api.h"
+
+#if ENABLED(BACKLASH_GCODE)
+ #include "../../feature/backlash.h"
+#endif
+
+#if HAS_LEVELING
+ #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+#if HAS_FILAMENT_SENSOR
+ #include "../../feature/runout.h"
+#endif
+
+#if ENABLED(CASE_LIGHT_ENABLE)
+ #include "../../feature/caselight.h"
+#endif
+
+#if ENABLED(BABYSTEPPING)
+ #include "../../feature/babystep.h"
+#endif
+
+#if ENABLED(HOST_PROMPT_SUPPORT)
+ #include "../../feature/host_actions.h"
+#endif
+
+namespace ExtUI {
+ static struct {
+ uint8_t printer_killed : 1;
+ TERN_(JOYSTICK, uint8_t jogging : 1);
+ TERN_(SDSUPPORT, uint8_t was_sd_printing : 1);
+ } flags;
+
+ #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(uint32_t us) { DELAY_US(us); }
+
+ void delay_ms(uint32_t ms) {
+ if (flags.printer_killed)
+ DELAY_US(ms * 1000);
+ else
+ safe_delay(ms);
+ }
+
+ void yield() {
+ if (!flags.printer_killed) thermalManager.manage_heater();
+ }
+
+ void enableHeater(const extruder_t extruder) {
+ #if HAS_HOTEND && HEATER_IDLE_HANDLER
+ thermalManager.reset_hotend_idle_timer(extruder - E0);
+ #else
+ UNUSED(extruder);
+ #endif
+ }
+
+ void enableHeater(const heater_t heater) {
+ #if HEATER_IDLE_HANDLER
+ switch (heater) {
+ #if HAS_HEATED_BED
+ case BED: thermalManager.reset_bed_idle_timer(); return;
+ #endif
+ TERN_(HAS_HEATED_CHAMBER, case CHAMBER: return); // Chamber has no idle timer
+ default:
+ TERN_(HAS_HOTEND, thermalManager.reset_hotend_idle_timer(heater - H0));
+ break;
+ }
+ #else
+ UNUSED(heater);
+ #endif
+ }
+
+ #if ENABLED(JOYSTICK)
+ /**
+ * Jogs in the direction given by the vector (dx, dy, dz).
+ * The values range from -1 to 1 mapping to the maximum
+ * feedrate for an axis.
+ *
+ * The axis will continue to jog until this function is
+ * called with all zeros.
+ */
+ void jog(const xyz_float_t &dir) {
+ // The "destination" variable is used as a scratchpad in
+ // Marlin by GCODE routines, but should remain untouched
+ // during manual jogging, allowing us to reuse the space
+ // for our direction vector.
+ destination = dir;
+ flags.jogging = !NEAR_ZERO(dir.x) || !NEAR_ZERO(dir.y) || !NEAR_ZERO(dir.z);
+ }
+
+ // Called by the polling routine in "joystick.cpp"
+ void _joystick_update(xyz_float_t &norm_jog) {
+ if (flags.jogging) {
+ #define OUT_OF_RANGE(VALUE) (VALUE < -1.0f || VALUE > 1.0f)
+
+ if (OUT_OF_RANGE(destination.x) || OUT_OF_RANGE(destination.y) || OUT_OF_RANGE(destination.z)) {
+ // If destination on any axis is out of range, it
+ // probably means the UI forgot to stop jogging and
+ // ran GCODE that wrote a position to destination.
+ // To prevent a disaster, stop jogging.
+ flags.jogging = false;
+ return;
+ }
+ norm_jog = destination;
+ }
+ }
+ #endif
+
+ bool isHeaterIdle(const extruder_t extruder) {
+ #if HAS_HOTEND && HEATER_IDLE_HANDLER
+ return thermalManager.heater_idle[extruder - E0].timed_out;
+ #else
+ UNUSED(extruder);
+ return false;
+ #endif
+ }
+
+ bool isHeaterIdle(const heater_t heater) {
+ #if HEATER_IDLE_HANDLER
+ switch (heater) {
+ TERN_(HAS_HEATED_BED, case BED: return thermalManager.heater_idle[thermalManager.IDLE_INDEX_BED].timed_out);
+ TERN_(HAS_HEATED_CHAMBER, case CHAMBER: return false); // Chamber has no idle timer
+ default:
+ return TERN0(HAS_HOTEND, thermalManager.heater_idle[heater - H0].timed_out);
+ }
+ #else
+ UNUSED(heater);
+ return false;
+ #endif
+ }
+
+ #ifdef TOUCH_UI_LCD_TEMP_SCALING
+ #define GET_TEMP_ADJUSTMENT(A) (float(A) / (TOUCH_UI_LCD_TEMP_SCALING))
+ #else
+ #define GET_TEMP_ADJUSTMENT(A) A
+ #endif
+
+ float getActualTemp_celsius(const heater_t heater) {
+ switch (heater) {
+ TERN_(HAS_HEATED_BED, case BED: return GET_TEMP_ADJUSTMENT(thermalManager.degBed()));
+ TERN_(HAS_HEATED_CHAMBER, case CHAMBER: return GET_TEMP_ADJUSTMENT(thermalManager.degChamber()));
+ default: return GET_TEMP_ADJUSTMENT(thermalManager.degHotend(heater - H0));
+ }
+ }
+
+ float getActualTemp_celsius(const extruder_t extruder) {
+ return GET_TEMP_ADJUSTMENT(thermalManager.degHotend(extruder - E0));
+ }
+
+ float getTargetTemp_celsius(const heater_t heater) {
+ switch (heater) {
+ TERN_(HAS_HEATED_BED, case BED: return GET_TEMP_ADJUSTMENT(thermalManager.degTargetBed()));
+ TERN_(HAS_HEATED_CHAMBER, case CHAMBER: return GET_TEMP_ADJUSTMENT(thermalManager.degTargetChamber()));
+ default: return GET_TEMP_ADJUSTMENT(thermalManager.degTargetHotend(heater - H0));
+ }
+ }
+
+ float getTargetTemp_celsius(const extruder_t extruder) {
+ return GET_TEMP_ADJUSTMENT(thermalManager.degTargetHotend(extruder - E0));
+ }
+
+ float getTargetFan_percent(const fan_t fan) {
+ #if HAS_FAN
+ return thermalManager.fanPercent(thermalManager.fan_speed[fan - FAN0]);
+ #else
+ UNUSED(fan);
+ return 0;
+ #endif
+ }
+
+ float getActualFan_percent(const fan_t fan) {
+ #if HAS_FAN
+ return thermalManager.fanPercent(thermalManager.scaledFanSpeed(fan - FAN0));
+ #else
+ UNUSED(fan);
+ return 0;
+ #endif
+ }
+
+ float getAxisPosition_mm(const axis_t axis) {
+ return TERN_(JOYSTICK, flags.jogging ? destination[axis] :) current_position[axis];
+ }
+
+ float getAxisPosition_mm(const extruder_t extruder) {
+ const extruder_t old_tool = getActiveTool();
+ setActiveTool(extruder, true);
+ const float epos = TERN_(JOYSTICK, flags.jogging ? destination.e :) current_position.e;
+ setActiveTool(old_tool, true);
+ return epos;
+ }
+
+ void setAxisPosition_mm(const float position, const axis_t axis, const feedRate_t feedrate/*=0*/) {
+ // Get motion limit from software endstops, if any
+ float min, max;
+ soft_endstop.get_manual_axis_limits((AxisEnum)axis, min, max);
+
+ // Delta limits XY based on the current offset from center
+ // This assumes the center is 0,0
+ #if ENABLED(DELTA)
+ if (axis != Z) {
+ max = SQRT(sq(float(DELTA_PRINTABLE_RADIUS)) - sq(current_position[Y - axis])); // (Y - axis) == the other axis
+ min = -max;
+ }
+ #endif
+
+ current_position[axis] = constrain(position, min, max);
+ line_to_current_position(feedrate ?: manual_feedrate_mm_s[axis]);
+ }
+
+ void setAxisPosition_mm(const float position, const extruder_t extruder, const feedRate_t feedrate/*=0*/) {
+ setActiveTool(extruder, true);
+
+ current_position.e = position;
+ line_to_current_position(feedrate ?: manual_feedrate_mm_s.e);
+ }
+
+ void setActiveTool(const extruder_t extruder, bool no_move) {
+ #if HAS_MULTI_EXTRUDER
+ const uint8_t e = extruder - E0;
+ if (e != active_extruder) tool_change(e, no_move);
+ active_extruder = e;
+ #else
+ UNUSED(extruder);
+ UNUSED(no_move);
+ #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 axis_should_home(X_AXIS);
+ case Y: return axis_should_home(Y_AXIS);
+ case Z: return axis_should_home(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);
+ }
+
+ #if HAS_SOFTWARE_ENDSTOPS
+ bool getSoftEndstopState() { return soft_endstop._enabled; }
+ void setSoftEndstopState(const bool value) { soft_endstop._enabled = value; }
+ #endif
+
+ #if HAS_TRINAMIC_CONFIG
+ float getAxisCurrent_mA(const axis_t axis) {
+ switch (axis) {
+ #if AXIS_IS_TMC(X)
+ case X: return stepperX.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(X2)
+ case X2: return stepperX2.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(Y)
+ case Y: return stepperY.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(Y2)
+ case Y2: return stepperY2.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(Z)
+ case Z: return stepperZ.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(Z2)
+ case Z2: return stepperZ2.getMilliamps();
+ #endif
+ default: return NAN;
+ };
+ }
+
+ float getAxisCurrent_mA(const extruder_t extruder) {
+ switch (extruder) {
+ #if AXIS_IS_TMC(E0)
+ case E0: return stepperE0.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(E1)
+ case E1: return stepperE1.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(E2)
+ case E2: return stepperE2.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(E3)
+ case E3: return stepperE3.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(E4)
+ case E4: return stepperE4.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(E5)
+ case E5: return stepperE5.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(E6)
+ case E6: return stepperE6.getMilliamps();
+ #endif
+ #if AXIS_IS_TMC(E7)
+ case E7: return stepperE7.getMilliamps();
+ #endif
+ default: return NAN;
+ };
+ }
+
+ void setAxisCurrent_mA(const float mA, const axis_t axis) {
+ switch (axis) {
+ #if AXIS_IS_TMC(X)
+ case X: stepperX.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(X2)
+ case X2: stepperX2.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(Y)
+ case Y: stepperY.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(Y2)
+ case Y2: stepperY2.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(Z)
+ case Z: stepperZ.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(Z2)
+ case Z2: stepperZ2.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ default: break;
+ };
+ }
+
+ void setAxisCurrent_mA(const float mA, const extruder_t extruder) {
+ switch (extruder) {
+ #if AXIS_IS_TMC(E0)
+ case E0: stepperE0.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(E1)
+ case E1: stepperE1.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(E2)
+ case E2: stepperE2.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(E3)
+ case E3: stepperE3.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(E4)
+ case E4: stepperE4.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(E5)
+ case E5: stepperE5.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(E6)
+ case E6: stepperE6.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ #if AXIS_IS_TMC(E7)
+ case E7: stepperE7.rms_current(constrain(mA, 400, 1500)); break;
+ #endif
+ default: break;
+ };
+ }
+
+ int getTMCBumpSensitivity(const axis_t axis) {
+ switch (axis) {
+ TERN_(X_SENSORLESS, case X: return stepperX.homing_threshold());
+ TERN_(X2_SENSORLESS, case X2: return stepperX2.homing_threshold());
+ TERN_(Y_SENSORLESS, case Y: return stepperY.homing_threshold());
+ TERN_(Y2_SENSORLESS, case Y2: return stepperY2.homing_threshold());
+ TERN_(Z_SENSORLESS, case Z: return stepperZ.homing_threshold());
+ TERN_(Z2_SENSORLESS, case Z2: return stepperZ2.homing_threshold());
+ TERN_(Z3_SENSORLESS, case Z3: return stepperZ3.homing_threshold());
+ TERN_(Z4_SENSORLESS, case Z4: return stepperZ4.homing_threshold());
+ default: return 0;
+ }
+ }
+
+ void setTMCBumpSensitivity(const float value, const axis_t axis) {
+ switch (axis) {
+ #if X_SENSORLESS || Y_SENSORLESS || Z_SENSORLESS
+ #if X_SENSORLESS
+ case X: stepperX.homing_threshold(value); break;
+ #endif
+ #if X2_SENSORLESS
+ case X2: stepperX2.homing_threshold(value); break;
+ #endif
+ #if Y_SENSORLESS
+ case Y: stepperY.homing_threshold(value); break;
+ #endif
+ #if Y2_SENSORLESS
+ case Y2: stepperY2.homing_threshold(value); break;
+ #endif
+ #if Z_SENSORLESS
+ case Z: stepperZ.homing_threshold(value); break;
+ #endif
+ #if Z2_SENSORLESS
+ case Z2: stepperZ2.homing_threshold(value); break;
+ #endif
+ #if Z3_SENSORLESS
+ case Z3: stepperZ3.homing_threshold(value); break;
+ #endif
+ #if Z4_SENSORLESS
+ case Z4: stepperZ4.homing_threshold(value); break;
+ #endif
+ #else
+ UNUSED(value);
+ #endif
+ default: break;
+ }
+ }
+ #endif
+
+ float getAxisSteps_per_mm(const axis_t axis) {
+ return planner.settings.axis_steps_per_mm[axis];
+ }
+
+ float getAxisSteps_per_mm(const extruder_t extruder) {
+ UNUSED_E(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;
+ planner.refresh_positioning();
+ }
+
+ void setAxisSteps_per_mm(const float value, const extruder_t extruder) {
+ UNUSED_E(extruder);
+ planner.settings.axis_steps_per_mm[E_AXIS_N(extruder - E0)] = value;
+ planner.refresh_positioning();
+ }
+
+ feedRate_t getAxisMaxFeedrate_mm_s(const axis_t axis) {
+ return planner.settings.max_feedrate_mm_s[axis];
+ }
+
+ feedRate_t getAxisMaxFeedrate_mm_s(const extruder_t extruder) {
+ UNUSED_E(extruder);
+ return planner.settings.max_feedrate_mm_s[E_AXIS_N(extruder - E0)];
+ }
+
+ void setAxisMaxFeedrate_mm_s(const feedRate_t value, const axis_t axis) {
+ planner.set_max_feedrate(axis, value);
+ }
+
+ void setAxisMaxFeedrate_mm_s(const feedRate_t value, const extruder_t extruder) {
+ UNUSED_E(extruder);
+ planner.set_max_feedrate(E_AXIS_N(extruder - 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) {
+ UNUSED_E(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.set_max_acceleration(axis, value);
+ planner.reset_acceleration_rates();
+ }
+
+ void setAxisMaxAcceleration_mm_s2(const float value, const extruder_t extruder) {
+ UNUSED_E(extruder);
+ planner.set_max_acceleration(E_AXIS_N(extruder - E0), value);
+ planner.reset_acceleration_rates();
+ }
+
+ #if HAS_FILAMENT_SENSOR
+ bool getFilamentRunoutEnabled() { return runout.enabled; }
+ void setFilamentRunoutEnabled(const bool value) { runout.enabled = value; }
+ bool getFilamentRunoutState() { return runout.filament_ran_out; }
+ void setFilamentRunoutState(const bool value) { runout.filament_ran_out = value; }
+
+ #if HAS_FILAMENT_RUNOUT_DISTANCE
+ float getFilamentRunoutDistance_mm() { return runout.runout_distance(); }
+ void setFilamentRunoutDistance_mm(const float value) { runout.set_runout_distance(constrain(value, 0, 999)); }
+ #endif
+ #endif
+
+ #if ENABLED(CASE_LIGHT_ENABLE)
+ bool getCaseLightState() { return caselight.on; }
+ void setCaseLightState(const bool value) {
+ caselight.on = value;
+ caselight.update_enabled();
+ }
+
+ #if CASELIGHT_USES_BRIGHTNESS
+ float getCaseLightBrightness_percent() { return ui8_to_percent(caselight.brightness); }
+ void setCaseLightBrightness_percent(const float value) {
+ caselight.brightness = map(constrain(value, 0, 100), 0, 100, 0, 255);
+ caselight.update_brightness();
+ }
+ #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] = constrain(value, 0, 10);
+ }
+ #endif
+
+ #if HAS_JUNCTION_DEVIATION
+
+ float getJunctionDeviation_mm() {
+ return planner.junction_deviation_mm;
+ }
+
+ void setJunctionDeviation_mm(const float value) {
+ planner.junction_deviation_mm = constrain(value, 0.001, 0.3);
+ TERN_(LIN_ADVANCE, 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) {
+ return planner.max_jerk.e;
+ }
+
+ void setAxisMaxJerk_mm_s(const float value, const axis_t axis) {
+ planner.set_max_jerk((AxisEnum)axis, value);
+ }
+
+ void setAxisMaxJerk_mm_s(const float value, const extruder_t) {
+ planner.set_max_jerk(E_AXIS, value);
+ }
+ #endif
+
+ feedRate_t getFeedrate_mm_s() { return feedrate_mm_s; }
+ int16_t getFlowPercentage(const extruder_t extr) { return planner.flow_percentage[extr]; }
+ feedRate_t getMinFeedrate_mm_s() { return planner.settings.min_feedrate_mm_s; }
+ feedRate_t 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 feedRate_t fr) { feedrate_mm_s = fr; }
+ void setFlow_percent(const int16_t flow, const extruder_t extr) { planner.set_flow(extr, flow); }
+ void setMinFeedrate_mm_s(const feedRate_t fr) { planner.settings.min_feedrate_mm_s = fr; }
+ void setMinTravelFeedrate_mm_s(const feedRate_t 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: babystep.add_steps(X_AXIS, steps); break;
+ case Y: babystep.add_steps(Y_AXIS, steps); break;
+ #endif
+ case Z: babystep.add_steps(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];
+ UNUSED(mm);
+
+ 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 && TERN1(HAS_MULTI_EXTRUDER, (linked_nozzles || active_extruder == 0)))
+ probe.offset.z += mm;
+ #endif
+
+ #if HAS_MULTI_EXTRUDER && HAS_HOTEND_OFFSET
+ /**
+ * 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[e][axis] += 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
+
+ float getZOffset_mm() {
+ return (0.0f
+ #if HAS_BED_PROBE
+ + probe.offset.z
+ #elif ENABLED(BABYSTEP_DISPLAY_TOTAL)
+ + planner.steps_to_mm[Z_AXIS] * babystep.axis_total[BS_AXIS_IND(Z_AXIS)]
+ #endif
+ );
+ }
+
+ void setZOffset_mm(const float value) {
+ #if HAS_BED_PROBE
+ if (WITHIN(value, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX))
+ probe.offset.z = value;
+ #elif ENABLED(BABYSTEP_DISPLAY_TOTAL)
+ babystep.add_mm(Z_AXIS, value - getZOffset_mm());
+ #else
+ UNUSED(value);
+ #endif
+ }
+
+ #if HAS_HOTEND_OFFSET
+
+ float getNozzleOffset_mm(const axis_t axis, const extruder_t extruder) {
+ if (extruder - E0 >= HOTENDS) return 0;
+ return hotend_offset[extruder - E0][axis];
+ }
+
+ void setNozzleOffset_mm(const float value, const axis_t axis, const extruder_t extruder) {
+ if (extruder - E0 >= HOTENDS) return;
+ hotend_offset[extruder - E0][axis] = 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[0][axis];
+ HOTEND_LOOP() hotend_offset[e][axis] -= offs;
+ }
+
+ #endif // HAS_HOTEND_OFFSET
+
+ #if HAS_BED_PROBE
+ float getProbeOffset_mm(const axis_t axis) {
+ return probe.offset.pos[axis];
+ }
+ void setProbeOffset_mm(const float val, const axis_t axis) {
+ probe.offset.pos[axis] = val;
+ }
+ #endif
+
+ #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] = constrain(value,0,5); }
+
+ float getBacklashCorrection_percent() { return ui8_to_percent(backlash.correction); }
+ void setBacklashCorrection_percent(const float value) { backlash.correction = map(constrain(value, 0, 100), 0, 100, 0, 255); }
+
+ #ifdef BACKLASH_SMOOTHING_MM
+ float getBacklashSmoothing_mm() { return backlash.smoothing_mm; }
+ void setBacklashSmoothing_mm(const float value) { backlash.smoothing_mm = constrain(value, 0, 999); }
+ #endif
+ #endif
+
+ 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); }
+ bool getMeshValid() { return leveling_is_valid(); }
+ #if HAS_MESH
+ bed_mesh_t& getMeshArray() { return Z_VALUES_ARR; }
+ float getMeshPoint(const xy_uint8_t &pos) { return Z_VALUES(pos.x, pos.y); }
+ void setMeshPoint(const xy_uint8_t &pos, const float zoff) {
+ if (WITHIN(pos.x, 0, GRID_MAX_POINTS_X) && WITHIN(pos.y, 0, GRID_MAX_POINTS_Y)) {
+ Z_VALUES(pos.x, pos.y) = zoff;
+ TERN_(ABL_BILINEAR_SUBDIVISION, bed_level_virt_interpolate());
+ }
+ }
+ #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]) { return duration_t(print_job_timer.getStats().printTime).toString(buffer); }
+ char* getLongestPrint_str(char buffer[21]) { return duration_t(print_job_timer.getStats().longestPrint).toString(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; }
+
+ #if ENABLED(PIDTEMP)
+ float getPIDValues_Kp(const extruder_t tool) { return PID_PARAM(Kp, tool); }
+ float getPIDValues_Ki(const extruder_t tool) { return unscalePID_i(PID_PARAM(Ki, tool)); }
+ float getPIDValues_Kd(const extruder_t tool) { return unscalePID_d(PID_PARAM(Kd, tool)); }
+
+ void setPIDValues(const float p, const float i, const float d, extruder_t tool) {
+ thermalManager.temp_hotend[tool].pid.Kp = p;
+ thermalManager.temp_hotend[tool].pid.Ki = scalePID_i(i);
+ thermalManager.temp_hotend[tool].pid.Kd = scalePID_d(d);
+ thermalManager.updatePID();
+ }
+
+ void startPIDTune(const float temp, extruder_t tool) {
+ thermalManager.PID_autotune(temp, (heater_id_t)tool, 8, true);
+ }
+ #endif
+
+ #if ENABLED(PIDTEMPBED)
+ float getBedPIDValues_Kp() { return thermalManager.temp_bed.pid.Kp; }
+ float getBedPIDValues_Ki() { return unscalePID_i(thermalManager.temp_bed.pid.Ki); }
+ float getBedPIDValues_Kd() { return unscalePID_d(thermalManager.temp_bed.pid.Kd); }
+
+ void setBedPIDValues(const float p, const float i, const float d) {
+ thermalManager.temp_bed.pid.Kp = p;
+ thermalManager.temp_bed.pid.Ki = scalePID_i(i);
+ thermalManager.temp_bed.pid.Kd = scalePID_d(d);
+ thermalManager.updatePID();
+ }
+
+ void startBedPIDTune(const float temp) {
+ thermalManager.PID_autotune(temp, H_BED, 4, true);
+ }
+ #endif
+
+ void injectCommands_P(PGM_P const gcode) { queue.inject_P(gcode); }
+ void injectCommands(char * const gcode) { queue.inject(gcode); }
+
+ bool commandsInQueue() { return (planner.movesplanned() || queue.has_commands_queued()); }
+
+ bool isAxisPositionKnown(const axis_t axis) { return axis_is_trusted((AxisEnum)axis); }
+ bool isAxisPositionKnown(const extruder_t) { return axis_is_trusted(E_AXIS); }
+ bool isPositionKnown() { return all_axes_trusted(); }
+ bool isMachineHomed() { return all_axes_homed(); }
+
+ PGM_P getFirmwareName_str() {
+ static PGMSTR(firmware_name, "Marlin " SHORT_BUILD_VERSION);
+ return firmware_name;
+ }
+
+ void setTargetTemp_celsius(float value, const heater_t heater) {
+ #ifdef TOUCH_UI_LCD_TEMP_SCALING
+ value *= TOUCH_UI_LCD_TEMP_SCALING;
+ #endif
+ enableHeater(heater);
+ #if HAS_HEATED_CHAMBER
+ if (heater == CHAMBER)
+ thermalManager.setTargetChamber(LROUND(constrain(value, 0, CHAMBER_MAXTEMP - 10)));
+ else
+ #endif
+ #if HAS_HEATED_BED
+ if (heater == BED)
+ thermalManager.setTargetBed(LROUND(constrain(value, 0, BED_MAX_TARGET)));
+ else
+ #endif
+ {
+ #if HAS_HOTEND
+ const int16_t e = heater - H0;
+ thermalManager.setTargetHotend(LROUND(constrain(value, 0, thermalManager.heater_maxtemp[e] - HOTEND_OVERSHOOT)), e);
+ #endif
+ }
+ }
+
+ void setTargetTemp_celsius(float value, const extruder_t extruder) {
+ #ifdef TOUCH_UI_LCD_TEMP_SCALING
+ value *= TOUCH_UI_LCD_TEMP_SCALING;
+ #endif
+ #if HAS_HOTEND
+ const int16_t e = extruder - E0;
+ enableHeater(extruder);
+ thermalManager.setTargetHotend(LROUND(constrain(value, 0, thermalManager.heater_maxtemp[e] - HOTEND_OVERSHOOT)), e);
+ #endif
+ }
+
+ void setTargetFan_percent(const float value, const fan_t fan) {
+ #if HAS_FAN
+ if (fan < FAN_COUNT)
+ thermalManager.set_fan_speed(fan - FAN0, map(constrain(value, 0, 100), 0, 100, 0, 255));
+ #else
+ UNUSED(value);
+ UNUSED(fan);
+ #endif
+ }
+
+ void setFeedrate_percent(const float value) {
+ feedrate_percentage = constrain(value, 10, 500);
+ }
+
+ bool awaitingUserConfirm() {
+ return wait_for_user;
+ }
+
+ void setUserConfirmed() {
+ TERN_(HAS_RESUME_CONTINUE, wait_for_user = false);
+ }
+
+ void printFile(const char *filename) {
+ UNUSED(filename);
+ IFSD(card.openAndPrintFile(filename), NOOP);
+ }
+
+ bool isPrintingFromMediaPaused() {
+ return IFSD(isPrintingFromMedia() && !IS_SD_PRINTING(), false);
+ }
+
+ bool isPrintingFromMedia() {
+ #if ENABLED(SDSUPPORT)
+ // Account for when IS_SD_PRINTING() reports the end of the
+ // print when there is still SD card data in the planner.
+ flags.was_sd_printing = card.isFileOpen() || (flags.was_sd_printing && commandsInQueue());
+ return flags.was_sd_printing;
+ #else
+ return false;
+ #endif
+ }
+
+ bool isPrinting() {
+ return (commandsInQueue() || isPrintingFromMedia() || IFSD(IS_SD_PRINTING(), false)) || print_job_timer.isRunning() || print_job_timer.isPaused();
+ }
+
+ bool isPrintingPaused() {
+ return isPrinting() && (isPrintingFromMediaPaused() || print_job_timer.isPaused());
+ }
+
+ bool isMediaInserted() {
+ return IFSD(IS_SD_INSERTED() && card.isMounted(), false);
+ }
+
+ void pausePrint() { ui.pause_print(); }
+ void resumePrint() { ui.resume_print(); }
+ void stopPrint() { ui.abort_print(); }
+
+ void onUserConfirmRequired_P(PGM_P const pstr) {
+ char msg[strlen_P(pstr) + 1];
+ strcpy_P(msg, pstr);
+ onUserConfirmRequired(msg);
+ }
+
+ void onStatusChanged_P(PGM_P const pstr) {
+ char msg[strlen_P(pstr) + 1];
+ strcpy_P(msg, pstr);
+ onStatusChanged(msg);
+ }
+
+ 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;
+ card.getfilename_sorted(SD_ORDER(pos, count()));
+ return card.filename[0] != '\0';
+ #else
+ UNUSED(pos);
+ UNUSED(skip_range_check);
+ return false;
+ #endif
+ }
+
+ const char* FileList::filename() {
+ return IFSD(card.longest_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() {
+ return IFSD(card.flag.workDirIsRoot, true);
+ }
+
+ void FileList::upDir() {
+ #if ENABLED(SDSUPPORT)
+ card.cdup();
+ num_files = 0xFFFF;
+ #endif
+ }
+
+ void FileList::changeDir(const char * const dirname) {
+ #if ENABLED(SDSUPPORT)
+ card.cd(dirname);
+ num_files = 0xFFFF;
+ #else
+ UNUSED(dirname);
+ #endif
+ }
+
+} // namespace ExtUI
+
+// At the moment we hook into MarlinUI methods, but this could be cleaned up in the future
+
+void MarlinUI::init() { ExtUI::onStartup(); }
+
+void MarlinUI::update() { ExtUI::onIdle(); }
+
+void MarlinUI::kill_screen(PGM_P const error, PGM_P const component) {
+ using namespace ExtUI;
+ if (!flags.printer_killed) {
+ flags.printer_killed = true;
+ onPrinterKilled(error, component);
+ }
+}
+
+#endif // EXTENSIBLE_UI
--
cgit v1.2.3