Marlin_Firmware/Marlin/src/lcd/extui/ui_api.h

391 lines
14 KiB
C
Raw Normal View History

/**
* Marlin 3D Printer Firmware
2020-02-03 08:00:57 -06:00
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
2019-06-27 23:57:50 -05:00
* 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
2020-07-22 22:20:14 -05:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
2019-07-04 22:44:12 -05:00
#pragma once
2018-10-08 15:44:05 -05:00
/************
* ui_api.h *
************/
/****************************************************************************
* 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 *
2020-11-06 19:09:29 -06:00
* location: <https://www.gnu.org/licenses/>. *
2018-10-08 15:44:05 -05:00
****************************************************************************/
#include "../../inc/MarlinConfig.h"
namespace ExtUI {
// The ExtUI implementation can store up to this many bytes
// in the EEPROM when the methods onStoreSettings and
// onLoadSettings are called.
static constexpr size_t eeprom_data_size = 48;
2018-10-08 15:44:05 -05:00
enum axis_t : uint8_t { X, Y, Z, X2, Y2, Z2, Z3, Z4 };
2020-02-04 12:37:20 -06:00
enum extruder_t : uint8_t { E0, E1, E2, E3, E4, E5, E6, E7 };
2019-06-07 07:08:41 -05:00
enum heater_t : uint8_t { H0, H1, H2, H3, H4, H5, BED, CHAMBER };
enum fan_t : uint8_t { FAN0, FAN1, FAN2, FAN3, FAN4, FAN5, FAN6, FAN7 };
2020-01-03 21:00:44 -06:00
enum result_t : uint8_t { PID_BAD_EXTRUDER_NUM, PID_TEMP_TOO_HIGH, PID_TUNING_TIMEOUT, PID_DONE };
2018-10-08 15:44:05 -05:00
constexpr uint8_t extruderCount = EXTRUDERS;
constexpr uint8_t hotendCount = HOTENDS;
2018-10-08 15:44:05 -05:00
constexpr uint8_t fanCount = FAN_COUNT;
2019-05-17 20:37:23 -05:00
#if HAS_MESH
typedef float bed_mesh_t[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
2019-05-17 20:37:23 -05:00
#endif
2018-10-08 15:44:05 -05:00
bool isMoving();
bool isAxisPositionKnown(const axis_t);
bool isAxisPositionKnown(const extruder_t);
2019-04-26 02:32:01 -05:00
bool isPositionKnown(); // Axis position guaranteed, steppers active since homing
bool isMachineHomed(); // Axis position most likely correct, steppers may have deactivated
bool canMove(const axis_t);
bool canMove(const extruder_t);
2019-06-27 14:11:02 -05:00
void injectCommands_P(PGM_P const);
void injectCommands(char * const);
2019-04-26 02:32:01 -05:00
bool commandsInQueue();
bool isHeaterIdle(const heater_t);
bool isHeaterIdle(const extruder_t);
void enableHeater(const heater_t);
void enableHeater(const extruder_t);
#if ENABLED(JOYSTICK)
2019-09-29 04:25:39 -05:00
void jog(const xyz_float_t &dir);
void _joystick_update(xyz_float_t &norm_jog);
#endif
/**
* Getters and setters
* Should be used by the EXTENSIBLE_UI to query or change Marlin's state.
*/
PGM_P getFirmwareName_str();
2019-03-23 23:09:18 -05:00
#if HAS_SOFTWARE_ENDSTOPS
bool getSoftEndstopState();
void setSoftEndstopState(const bool);
#endif
2020-03-02 12:03:43 -06:00
#if HAS_TRINAMIC_CONFIG
2019-03-23 23:09:18 -05:00
float getAxisCurrent_mA(const axis_t);
float getAxisCurrent_mA(const extruder_t);
void setAxisCurrent_mA(const float, const axis_t);
void setAxisCurrent_mA(const float, const extruder_t);
int getTMCBumpSensitivity(const axis_t);
2019-03-23 23:09:18 -05:00
void setTMCBumpSensitivity(const float, const axis_t);
#endif
float getActualTemp_celsius(const heater_t);
float getActualTemp_celsius(const extruder_t);
float getTargetTemp_celsius(const heater_t);
float getTargetTemp_celsius(const extruder_t);
float getTargetFan_percent(const fan_t);
float getActualFan_percent(const fan_t);
float getAxisPosition_mm(const axis_t);
float getAxisPosition_mm(const extruder_t);
float getAxisSteps_per_mm(const axis_t);
float getAxisSteps_per_mm(const extruder_t);
2019-09-26 01:28:09 -05:00
feedRate_t getAxisMaxFeedrate_mm_s(const axis_t);
feedRate_t getAxisMaxFeedrate_mm_s(const extruder_t);
float getAxisMaxAcceleration_mm_s2(const axis_t);
float getAxisMaxAcceleration_mm_s2(const extruder_t);
2019-09-26 01:28:09 -05:00
feedRate_t getMinFeedrate_mm_s();
feedRate_t getMinTravelFeedrate_mm_s();
float getPrintingAcceleration_mm_s2();
float getRetractAcceleration_mm_s2();
float getTravelAcceleration_mm_s2();
float getFeedrate_percent();
2019-11-30 07:23:53 -06:00
int16_t getFlowPercentage(const extruder_t);
2018-10-08 15:44:05 -05:00
uint8_t getProgress_percent();
uint32_t getProgress_seconds_elapsed();
2019-04-03 20:21:06 -05:00
#if HAS_LEVELING
bool getLevelingActive();
void setLevelingActive(const bool);
2019-05-17 20:37:23 -05:00
bool getMeshValid();
#if HAS_MESH
bed_mesh_t& getMeshArray();
2019-09-29 04:25:39 -05:00
float getMeshPoint(const xy_uint8_t &pos);
void setMeshPoint(const xy_uint8_t &pos, const float zval);
2020-11-05 16:45:22 -06:00
void onMeshLevelingStart();
2019-11-20 04:57:04 -06:00
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval);
inline void onMeshUpdate(const xy_int8_t &pos, const float zval) { onMeshUpdate(pos.x, pos.y, zval); }
2020-04-06 15:39:34 -05:00
typedef enum : unsigned char {
MESH_START, // Prior to start of probe
MESH_FINISH, // Following probe of all points
PROBE_START, // Beginning probe of grid location
PROBE_FINISH // Finished probe of grid location
} probe_state_t;
2020-04-02 14:24:55 -05:00
void onMeshUpdate(const int8_t xpos, const int8_t ypos, probe_state_t state);
inline void onMeshUpdate(const xy_int8_t &pos, probe_state_t state) { onMeshUpdate(pos.x, pos.y, state); }
#endif
#endif
#if ENABLED(HOST_PROMPT_SUPPORT)
void setHostResponse(const uint8_t);
#endif
2018-10-08 15:44:05 -05:00
#if ENABLED(PRINTCOUNTER)
char* getTotalPrints_str(char buffer[21]);
char* getFinishedPrints_str(char buffer[21]);
char* getTotalPrintTime_str(char buffer[21]);
char* getLongestPrint_str(char buffer[21]);
char* getFilamentUsed_str(char buffer[21]);
#endif
void setTargetTemp_celsius(const float, const heater_t);
void setTargetTemp_celsius(const float, const extruder_t);
void setTargetFan_percent(const float, const fan_t);
void setAxisPosition_mm(const float, const axis_t, const feedRate_t=0);
void setAxisPosition_mm(const float, const extruder_t, const feedRate_t=0);
void setAxisSteps_per_mm(const float, const axis_t);
void setAxisSteps_per_mm(const float, const extruder_t);
2019-09-26 01:28:09 -05:00
void setAxisMaxFeedrate_mm_s(const feedRate_t, const axis_t);
void setAxisMaxFeedrate_mm_s(const feedRate_t, const extruder_t);
void setAxisMaxAcceleration_mm_s2(const float, const axis_t);
void setAxisMaxAcceleration_mm_s2(const float, const extruder_t);
2019-09-26 01:28:09 -05:00
void setFeedrate_mm_s(const feedRate_t);
void setMinFeedrate_mm_s(const feedRate_t);
void setMinTravelFeedrate_mm_s(const feedRate_t);
void setPrintingAcceleration_mm_s2(const float);
void setRetractAcceleration_mm_s2(const float);
void setTravelAcceleration_mm_s2(const float);
void setFeedrate_percent(const float);
2019-11-30 07:23:53 -06:00
void setFlow_percent(const int16_t, const extruder_t);
2019-09-16 20:31:08 -05:00
void setUserConfirmed();
2018-10-08 15:44:05 -05:00
#if ENABLED(LIN_ADVANCE)
float getLinearAdvance_mm_mm_s(const extruder_t);
void setLinearAdvance_mm_mm_s(const float, const extruder_t);
2018-10-08 15:44:05 -05:00
#endif
2020-04-23 20:49:11 -05:00
#if HAS_JUNCTION_DEVIATION
2018-10-08 15:44:05 -05:00
float getJunctionDeviation_mm();
void setJunctionDeviation_mm(const float);
2018-10-08 15:44:05 -05:00
#else
float getAxisMaxJerk_mm_s(const axis_t);
float getAxisMaxJerk_mm_s(const extruder_t);
void setAxisMaxJerk_mm_s(const float, const axis_t);
void setAxisMaxJerk_mm_s(const float, const extruder_t);
2018-10-08 15:44:05 -05:00
#endif
extruder_t getActiveTool();
void setActiveTool(const extruder_t, bool no_move);
#if ENABLED(BABYSTEPPING)
int16_t mmToWholeSteps(const float mm, const axis_t axis);
bool babystepAxis_steps(const int16_t steps, const axis_t axis);
void smartAdjustAxis_steps(const int16_t steps, const axis_t axis, bool linked_nozzles);
#endif
2018-10-08 15:44:05 -05:00
2019-03-11 20:48:49 -05:00
#if HAS_HOTEND_OFFSET
float getNozzleOffset_mm(const axis_t, const extruder_t);
void setNozzleOffset_mm(const float, const axis_t, const extruder_t);
void normalizeNozzleOffset(const axis_t axis);
2018-10-08 15:44:05 -05:00
#endif
float getZOffset_mm();
void setZOffset_mm(const float);
2018-10-08 15:44:05 -05:00
#if HAS_BED_PROBE
float getProbeOffset_mm(const axis_t);
void setProbeOffset_mm(const float, const axis_t);
#endif
2018-10-08 15:44:05 -05:00
#if ENABLED(BACKLASH_GCODE)
float getAxisBacklash_mm(const axis_t);
void setAxisBacklash_mm(const float, const axis_t);
2018-10-08 15:44:05 -05:00
float getBacklashCorrection_percent();
void setBacklashCorrection_percent(const float);
2018-10-08 15:44:05 -05:00
#ifdef BACKLASH_SMOOTHING_MM
float getBacklashSmoothing_mm();
void setBacklashSmoothing_mm(const float);
2018-10-08 15:44:05 -05:00
#endif
#endif
2019-02-12 20:08:34 -06:00
#if HAS_FILAMENT_SENSOR
bool getFilamentRunoutEnabled();
void setFilamentRunoutEnabled(const bool);
bool getFilamentRunoutState();
void setFilamentRunoutState(const bool);
2020-05-05 23:18:23 -05:00
#if HAS_FILAMENT_RUNOUT_DISTANCE
float getFilamentRunoutDistance_mm();
void setFilamentRunoutDistance_mm(const float);
#endif
#endif
#if ENABLED(CASE_LIGHT_ENABLE)
bool getCaseLightState();
void setCaseLightState(const bool);
#if DISABLED(CASE_LIGHT_NO_BRIGHTNESS)
float getCaseLightBrightness_percent();
void setCaseLightBrightness_percent(const float);
#endif
#endif
#if ENABLED(PIDTEMP)
float getPIDValues_Kp(const extruder_t);
float getPIDValues_Ki(const extruder_t);
float getPIDValues_Kd(const extruder_t);
void setPIDValues(const float, const float, const float, extruder_t);
void startPIDTune(const float, extruder_t);
#endif
2020-02-24 05:29:13 -06:00
#if ENABLED(PIDTEMPBED)
float getBedPIDValues_Kp();
float getBedPIDValues_Ki();
float getBedPIDValues_Kd();
void setBedPIDValues(const float, const float, const float);
void startBedPIDTune(const float);
#endif
/**
* Delay and timing routines
* Should be used by the EXTENSIBLE_UI to safely pause or measure time
* safe_millis must be called at least every 1 sec to guarantee time
* yield should be called within lengthy loops
*/
#ifdef __SAM3X8E__
uint32_t safe_millis();
#else
FORCE_INLINE uint32_t safe_millis() { return millis(); } // TODO: Implement for AVR
#endif
void delay_us(unsigned long us);
2018-10-08 15:44:05 -05:00
void delay_ms(unsigned long ms);
void yield();
2018-10-08 15:44:05 -05:00
/**
* Media access routines
*
* Should be used by the EXTENSIBLE_UI to operate on files
*/
bool isMediaInserted();
bool isPrintingFromMediaPaused();
2018-10-08 15:44:05 -05:00
bool isPrintingFromMedia();
bool isPrinting();
bool isPrintingPaused();
void printFile(const char *filename);
2018-10-08 15:44:05 -05:00
void stopPrint();
void pausePrint();
void resumePrint();
class FileList {
private:
uint16_t num_files;
public:
FileList();
void refresh();
bool seek(const uint16_t, const bool skip_range_check = false);
2018-10-08 15:44:05 -05:00
const char *longFilename();
const char *shortFilename();
const char *filename();
bool isDir();
2018-10-08 15:44:05 -05:00
void changeDir(const char * const dirname);
void upDir();
bool isAtRootDir();
uint16_t count();
2018-10-08 15:44:05 -05:00
};
/**
* Event callback routines
*
* Should be declared by EXTENSIBLE_UI and will be called by Marlin
*/
2018-10-08 15:44:05 -05:00
void onStartup();
void onIdle();
2018-10-08 15:44:05 -05:00
void onMediaInserted();
void onMediaError();
void onMediaRemoved();
void onPlayTone(const uint16_t frequency, const uint16_t duration);
2019-10-09 19:46:10 -05:00
void onPrinterKilled(PGM_P const error, PGM_P const component);
2018-10-08 15:44:05 -05:00
void onPrintTimerStarted();
void onPrintTimerPaused();
void onPrintTimerStopped();
2020-11-05 16:45:22 -06:00
void onPrintFinished();
void onFilamentRunout(const extruder_t extruder);
void onUserConfirmRequired(const char * const msg);
2019-10-09 19:46:10 -05:00
void onUserConfirmRequired_P(PGM_P const pstr);
void onStatusChanged(const char * const msg);
2020-04-16 00:33:31 -05:00
void onStatusChanged_P(PGM_P const pstr);
2020-11-05 16:45:22 -06:00
void onHomingStart();
void onHomingComplete();
void onSteppersDisabled();
void onSteppersEnabled();
2018-10-08 15:44:05 -05:00
void onFactoryReset();
void onStoreSettings(char *);
void onLoadSettings(const char *);
void onConfigurationStoreWritten(bool success);
void onConfigurationStoreRead(bool success);
2020-01-03 21:00:44 -06:00
#if ENABLED(POWER_LOSS_RECOVERY)
void onPowerLossResume();
2020-01-03 21:00:44 -06:00
#endif
#if HAS_PID_HEATING
void onPidTuning(const result_t rst);
2020-01-03 21:00:44 -06:00
#endif
2018-10-08 15:44:05 -05:00
};
/**
* Helper macros to increment or decrement a value. For example:
*
* UI_INCREMENT_BY(TargetTemp_celsius, 10, E0)
*
* Expands to:
*
* setTargetTemp_celsius(getTargetTemp_celsius(E0) + 10, E0);
*
* Or, in the case where a constant increment is desired:
*
* constexpr float increment = 10;
*
* UI_INCREMENT(TargetTemp_celsius, E0)
*/
#define UI_INCREMENT_BY(method, inc, ...) ExtUI::set ## method(ExtUI::get ## method (__VA_ARGS__) + inc, ##__VA_ARGS__)
#define UI_DECREMENT_BY(method, inc, ...) ExtUI::set ## method(ExtUI::get ## method (__VA_ARGS__) - inc, ##__VA_ARGS__)
#define UI_INCREMENT(method, ...) UI_INCREMENT_BY(method, increment, ##__VA_ARGS__)
#define UI_DECREMENT(method, ...) UI_DECREMENT_BY(method, increment, ##__VA_ARGS__)