Marcio Teixeira
6 years ago
committed by
Scott Lahteine
Scott Lahteine
88 changed files with 1571 additions and 25 deletions
@ -0,0 +1,50 @@ |
|||
/*************
|
|||
* dummy.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 "../ui_api.h" |
|||
|
|||
// To implement a new UI, complete the functions below and
|
|||
// read or update Marlin's state using the methods in the
|
|||
// UI methods in "../ui_api.h"
|
|||
|
|||
namespace UI { |
|||
void onStartup() {} |
|||
void onUpdate() {} |
|||
void onPrinterKilled(const char* lcd_msg) {} |
|||
void onMediaInserted(); |
|||
void onMediaError(); |
|||
void onMediaRemoved(); |
|||
void onPlayTone(const uint16_t frequency, const uint16_t duration) {} |
|||
void onPrintTimerStarted() {} |
|||
void onPrintTimerPaused() {} |
|||
void onPrintTimerStopped() {} |
|||
void onFilamentRunout() {} |
|||
void onStatusChanged(const char* lcd_msg) {} |
|||
void onStatusChanged(progmem_str lcd_msg) {} |
|||
void onFactoryReset() {} |
|||
void onStoreSettings() {} |
|||
} |
|||
|
|||
#endif // EXTENSIBLE_UI
|
|||
@ -0,0 +1,590 @@ |
|||
/**************
|
|||
* 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 "../../Marlin.h" |
|||
|
|||
#if ENABLED(EXTENSIBLE_UI) |
|||
|
|||
#include "../../gcode/queue.h" |
|||
#include "../../module/motion.h" |
|||
#include "../../module/planner.h" |
|||
#include "../../module/probe.h" |
|||
#include "../../module/printcounter.h" |
|||
#include "../../module/temperature.h" |
|||
#include "../../sd/cardreader.h" |
|||
#include "../../libs/duration_t.h" |
|||
|
|||
#if DO_SWITCH_EXTRUDER || ENABLED(SWITCHING_NOZZLE) || ENABLED(PARKING_EXTRUDER) |
|||
#include "../../module/tool_change.h" |
|||
#endif |
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
#include "../../feature/emergency_parser.h" |
|||
|
|||
bool abort_sd_printing; // =false
|
|||
#else |
|||
constexpr bool abort_sd_printing = false; |
|||
#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 |
|||
|
|||
inline float clamp(const float value, const float minimum, const float maximum) { |
|||
return MAX(MIN(value, maximum), minimum); |
|||
} |
|||
|
|||
namespace UI { |
|||
|
|||
void delay_ms(unsigned long ms) { |
|||
safe_delay(ms); |
|||
} |
|||
|
|||
void yield() { |
|||
thermalManager.manage_heater(); |
|||
} |
|||
|
|||
float getActualTemp_celsius(const uint8_t extruder) { |
|||
return extruder ? |
|||
thermalManager.degHotend(extruder - 1) : |
|||
#if HAS_HEATED_BED |
|||
thermalManager.degBed() |
|||
#else |
|||
0 |
|||
#endif |
|||
; |
|||
} |
|||
|
|||
float getTargetTemp_celsius(const uint8_t extruder) { |
|||
return extruder ? |
|||
thermalManager.degTargetHotend(extruder - 1) : |
|||
#if HAS_HEATED_BED |
|||
thermalManager.degTargetBed() |
|||
#else |
|||
0 |
|||
#endif |
|||
; |
|||
} |
|||
|
|||
float getFan_percent(const uint8_t fan) { return ((float(fan_speed[fan]) + 1) * 100) / 256; } |
|||
|
|||
float getAxisPosition_mm(const axis_t axis) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
return current_position[axis]; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
return current_position[E_AXIS]; |
|||
default: return 0; |
|||
} |
|||
} |
|||
|
|||
void setAxisPosition_mm(const axis_t axis, float position, float _feedrate_mm_s) { |
|||
#if EXTRUDERS > 1 |
|||
const int8_t old_extruder = active_extruder; |
|||
#endif |
|||
switch (axis) { |
|||
case X: case Y: case Z: break; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
active_extruder = axis - E0; |
|||
break; |
|||
default: return; |
|||
} |
|||
set_destination_from_current(); |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
destination[Z_AXIS] = position; |
|||
break; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
destination[E_AXIS] = position; |
|||
break; |
|||
} |
|||
|
|||
const float old_feedrate = feedrate_mm_s; |
|||
feedrate_mm_s = _feedrate_mm_s; |
|||
prepare_move_to_destination(); |
|||
feedrate_mm_s = old_feedrate; |
|||
#if EXTRUDERS > 1 |
|||
active_extruder = old_extruder; |
|||
#endif |
|||
} |
|||
|
|||
void setActiveTool(uint8_t extruder, bool no_move) { |
|||
extruder--; // Make zero based
|
|||
#if DO_SWITCH_EXTRUDER || ENABLED(SWITCHING_NOZZLE) || ENABLED(PARKING_EXTRUDER) |
|||
if (extruder != active_extruder) |
|||
tool_change(extruder, 0, no_move); |
|||
#endif |
|||
active_extruder = extruder; |
|||
} |
|||
|
|||
uint8_t getActiveTool() { return active_extruder + 1; } |
|||
|
|||
bool isMoving() { return planner.has_blocks_queued(); } |
|||
|
|||
float getAxisSteps_per_mm(const axis_t axis) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
return planner.axis_steps_per_mm[axis]; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
return planner.axis_steps_per_mm[E_AXIS_N(axis - E0)]; |
|||
default: return 0; |
|||
} |
|||
} |
|||
|
|||
void setAxisSteps_per_mm(const axis_t axis, const float steps_per_mm) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
planner.axis_steps_per_mm[axis] = steps_per_mm; |
|||
break; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
planner.axis_steps_per_mm[E_AXIS_N(axis - E0)] = steps_per_mm; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
float getAxisMaxFeedrate_mm_s(const axis_t axis) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
return planner.max_feedrate_mm_s[axis]; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
return planner.max_feedrate_mm_s[E_AXIS_N(axis - E0)]; |
|||
default: return 0; |
|||
} |
|||
} |
|||
|
|||
void setAxisMaxFeedrate_mm_s(const axis_t axis, const float max_feedrate_mm_s) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
planner.max_feedrate_mm_s[axis] = max_feedrate_mm_s; |
|||
break; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
planner.max_feedrate_mm_s[E_AXIS_N(axis - E0)] = max_feedrate_mm_s; |
|||
break; |
|||
default: return; |
|||
} |
|||
} |
|||
|
|||
float getAxisMaxAcceleration_mm_s2(const axis_t axis) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
return planner.max_acceleration_mm_per_s2[axis]; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
return planner.max_acceleration_mm_per_s2[E_AXIS_N(axis - E0)]; |
|||
default: return 0; |
|||
} |
|||
} |
|||
|
|||
void setAxisMaxAcceleration_mm_s2(const axis_t axis, const float max_acceleration_mm_per_s2) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
planner.max_acceleration_mm_per_s2[axis] = max_acceleration_mm_per_s2; |
|||
break; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
planner.max_acceleration_mm_per_s2[E_AXIS_N(axis - E0)] = max_acceleration_mm_per_s2; |
|||
break; |
|||
default: return; |
|||
} |
|||
} |
|||
|
|||
#if ENABLED(LIN_ADVANCE) |
|||
float getLinearAdvance_mm_mm_s(const uint8_t extruder) { |
|||
return (extruder < EXTRUDERS) ? planner.extruder_advance_K[extruder] : 0; |
|||
} |
|||
|
|||
void setLinearAdvance_mm_mm_s(const uint8_t extruder, const float k) { |
|||
if (extruder < EXTRUDERS) |
|||
planner.extruder_advance_K[extruder] = clamp(k, 0, 999); |
|||
} |
|||
#endif |
|||
|
|||
#if ENABLED(JUNCTION_DEVIATION) |
|||
float getJunctionDeviation_mm() { |
|||
return planner.junction_deviation_mm; |
|||
} |
|||
|
|||
void setJunctionDeviation_mm(const float junc_dev) { |
|||
planner.junction_deviation_mm = clamp(junc_dev, 0.01, 0.3); |
|||
planner.recalculate_max_e_jerk(); |
|||
} |
|||
#else |
|||
float getAxisMaxJerk_mm_s(const axis_t axis) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
return planner.max_jerk[axis]; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
return planner.max_jerk[E_AXIS]; |
|||
default: return 0; |
|||
} |
|||
} |
|||
|
|||
void setAxisMaxJerk_mm_s(const axis_t axis, const float max_jerk) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
planner.max_jerk[axis] = max_jerk; |
|||
break; |
|||
case E0: case E1: case E2: case E3: case E4: case E5: |
|||
planner.max_jerk[E_AXIS] = max_jerk; |
|||
break; |
|||
default: return; |
|||
} |
|||
} |
|||
#endif |
|||
|
|||
float getMinFeedrate_mm_s() { return planner.min_feedrate_mm_s; } |
|||
float getMinTravelFeedrate_mm_s() { return planner.min_travel_feedrate_mm_s; } |
|||
float getPrintingAcceleration_mm_s2() { return planner.acceleration; } |
|||
float getRetractAcceleration_mm_s2() { return planner.retract_acceleration; } |
|||
float getTravelAcceleration_mm_s2() { return planner.travel_acceleration; } |
|||
void setMinFeedrate_mm_s(const float fr) { planner.min_feedrate_mm_s = fr; } |
|||
void setMinTravelFeedrate_mm_s(const float fr) { planner.min_travel_feedrate_mm_s = fr; } |
|||
void setPrintingAcceleration_mm_per_s2(const float acc) { planner.acceleration = acc; } |
|||
void setRetractAcceleration_mm_s2(const float acc) { planner.retract_acceleration = acc; } |
|||
void setTravelAcceleration_mm_s2(const float acc) { planner.travel_acceleration = acc; } |
|||
|
|||
#if ENABLED(BABYSTEP_ZPROBE_OFFSET) |
|||
float getZOffset_mm() { |
|||
#if ENABLED(BABYSTEP_HOTEND_Z_OFFSET) |
|||
if (active_extruder != 0) |
|||
return hotend_offset[Z_AXIS][active_extruder]; |
|||
else |
|||
#endif |
|||
return zprobe_zoffset; |
|||
} |
|||
|
|||
void setZOffset_mm(const float zoffset_mm) { |
|||
const float diff = (zoffset_mm - getZOffset_mm()) / planner.steps_to_mm[Z_AXIS]; |
|||
incrementZOffset_steps(diff > 0 ? ceil(diff) : floor(diff)); |
|||
} |
|||
|
|||
void incrementZOffset_steps(int16_t babystep_increment) { |
|||
#if ENABLED(BABYSTEP_HOTEND_Z_OFFSET) |
|||
const bool do_probe = (active_extruder == 0); |
|||
#else |
|||
constexpr bool do_probe = true; |
|||
#endif |
|||
const float diff = planner.steps_to_mm[Z_AXIS] * babystep_increment, |
|||
new_probe_offset = zprobe_zoffset + diff, |
|||
new_offs = |
|||
#if ENABLED(BABYSTEP_HOTEND_Z_OFFSET) |
|||
do_probe ? new_probe_offset : hotend_offset[Z_AXIS][active_extruder] - diff |
|||
#else |
|||
new_probe_offset |
|||
#endif |
|||
; |
|||
if (WITHIN(new_offs, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) { |
|||
|
|||
thermalManager.babystep_axis(Z_AXIS, babystep_increment); |
|||
|
|||
if (do_probe) zprobe_zoffset = new_offs; |
|||
#if ENABLED(BABYSTEP_HOTEND_Z_OFFSET) |
|||
else hotend_offset[Z_AXIS][active_extruder] = new_offs; |
|||
#endif |
|||
} |
|||
} |
|||
#endif // ENABLED(BABYSTEP_ZPROBE_OFFSET)
|
|||
|
|||
#if HOTENDS > 1 |
|||
float getNozzleOffset_mm(const axis_t axis, uint8_t extruder) { |
|||
if (extruder >= HOTENDS) return 0; |
|||
return hotend_offset[axis][extruder]; |
|||
} |
|||
|
|||
void setNozzleOffset_mm(const axis_t axis, uint8_t extruder, float offset) { |
|||
if (extruder >= HOTENDS) return; |
|||
hotend_offset[axis][extruder] = offset; |
|||
} |
|||
#endif |
|||
|
|||
#if ENABLED(BACKLASH_GCODE) |
|||
float getAxisBacklash_mm(const axis_t axis) {return backlash_distance_mm[axis];} |
|||
void setAxisBacklash_mm(const axis_t axis, float distance) |
|||
{backlash_distance_mm[axis] = clamp(distance,0,5);} |
|||
|
|||
float getBacklashCorrection_percent() {return backlash_correction*100;} |
|||
void setBacklashCorrection_percent(float percent) {backlash_correction = clamp(percent, 0, 100)/100;} |
|||
|
|||
#ifdef BACKLASH_SMOOTHING_MM |
|||
float getBacklashSmoothing_mm() {return backlash_smoothing_mm;} |
|||
void setBacklashSmoothing_mm(float distance) {backlash_smoothing_mm = clamp(distance,0,999);} |
|||
#endif |
|||
#endif |
|||
|
|||
uint8_t getProgress_percent() { |
|||
#if ENABLED(SDSUPPORT) |
|||
return card.percentDone(); |
|||
#else |
|||
return 0; |
|||
#endif |
|||
} |
|||
|
|||
uint32_t getProgress_seconds_elapsed() { |
|||
const duration_t elapsed = print_job_timer.duration(); |
|||
return elapsed.value; |
|||
} |
|||
|
|||
float getFeedRate_percent() { |
|||
return feedrate_percentage; |
|||
} |
|||
|
|||
void enqueueCommands(progmem_str gcode) { |
|||
enqueue_and_echo_commands_P((PGM_P)gcode); |
|||
} |
|||
|
|||
bool isAxisPositionKnown(const axis_t axis) { |
|||
switch (axis) { |
|||
case X: case Y: case Z: |
|||
return TEST(axis_known_position, axis); |
|||
default: return true; |
|||
} |
|||
} |
|||
|
|||
progmem_str getFirmwareName() { |
|||
return F("Marlin " SHORT_BUILD_VERSION); |
|||
} |
|||
|
|||
void setTargetTemp_celsius(const uint8_t extruder, float temp) { |
|||
if (extruder) |
|||
thermalManager.setTargetHotend(clamp(temp,0,500), extruder-1); |
|||
#if HAS_HEATED_BED |
|||
else |
|||
thermalManager.setTargetBed(clamp(temp,0,200)); |
|||
#endif |
|||
} |
|||
|
|||
void setFan_percent(const uint8_t fan, float percent) { |
|||
if (fan < FAN_COUNT) |
|||
fan_speed[fan] = clamp(round(percent * 255 / 100), 0, 255); |
|||
} |
|||
|
|||
void setFeedrate_percent(const float percent) { |
|||
feedrate_percentage = clamp(percent, 10, 500); |
|||
} |
|||
|
|||
void printFile(const char *filename) { |
|||
#if ENABLED(SDSUPPORT) |
|||
card.openAndPrintFile(filename); |
|||
#endif |
|||
} |
|||
|
|||
bool isPrintingFromMedia() { |
|||
#if ENABLED(SDSUPPORT) |
|||
return card.cardOK && card.isFileOpen() && card.sdprinting; |
|||
#else |
|||
return false; |
|||
#endif |
|||
} |
|||
|
|||
bool isPrinting() { |
|||
return (planner.movesplanned() || IS_SD_PRINTING || |
|||
#if ENABLED(SDSUPPORT) |
|||
(card.cardOK && card.isFileOpen()) |
|||
#else |
|||
false |
|||
#endif |
|||
); |
|||
} |
|||
|
|||
bool isMediaInserted() { |
|||
#if ENABLED(SDSUPPORT) |
|||
return IS_SD_INSERTED && card.cardOK; |
|||
#else |
|||
return false; |
|||
#endif |
|||
} |
|||
|
|||
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::onStatusChanged(PSTR(MSG_PRINT_PAUSED)); |
|||
#endif |
|||
} |
|||
|
|||
void resumePrint() { |
|||
#if ENABLED(SDSUPPORT) |
|||
#if ENABLED(PARK_HEAD_ON_PAUSE) |
|||
enqueue_and_echo_commands_P(PSTR("M24")); |
|||
#else |
|||
card.startFileprint(); |
|||
print_job_timer.start(); |
|||
#endif |
|||
UI::onStatusChanged(PSTR(MSG_PRINTING)); |
|||
#endif |
|||
} |
|||
|
|||
void stopPrint() { |
|||
#if ENABLED(SDSUPPORT) |
|||
wait_for_heatup = wait_for_user = false; |
|||
abort_sd_printing = true; |
|||
UI::onStatusChanged(PSTR(MSG_PRINT_ABORTED)); |
|||
#endif |
|||
} |
|||
|
|||
FileList::FileList() { |
|||
refresh(); |
|||
} |
|||
|
|||
void FileList::refresh() { |
|||
num_files = 0xFFFF; |
|||
} |
|||
|
|||
bool FileList::seek(uint16_t pos, bool skip_range_check) { |
|||
#if ENABLED(SDSUPPORT) |
|||
if (!skip_range_check && pos > (count() - 1)) return false; |
|||
const uint16_t nr = |
|||
#if ENABLED(SDCARD_RATHERRECENTFIRST) && DISABLED(SDCARD_SORT_ALPHA) |
|||
count() - 1 - |
|||
#endif |
|||
pos; |
|||
|
|||
#if ENABLED(SDCARD_SORT_ALPHA) |
|||
card.getfilename_sorted(nr); |
|||
#else |
|||
card.getfilename(nr); |
|||
#endif |
|||
return card.filename && card.filename[0] != '\0'; |
|||
#endif |
|||
} |
|||
|
|||
const char* FileList::filename() { |
|||
#if ENABLED(SDSUPPORT) |
|||
return (card.longFilename && card.longFilename[0]) ? card.longFilename : card.filename; |
|||
#else |
|||
return ""; |
|||
#endif |
|||
} |
|||
|
|||
const char* FileList::shortFilename() { |
|||
#if ENABLED(SDSUPPORT) |
|||
return card.filename; |
|||
#else |
|||
return ""; |
|||
#endif |
|||
} |
|||
|
|||
const char* FileList::longFilename() { |
|||
#if ENABLED(SDSUPPORT) |
|||
return card.longFilename; |
|||
#else |
|||
return ""; |
|||
#endif |
|||
} |
|||
|
|||
bool FileList::isDir() { |
|||
#if ENABLED(SDSUPPORT) |
|||
return card.filenameIsDir; |
|||
#else |
|||
return false; |
|||
#endif |
|||
} |
|||
|
|||
uint16_t FileList::count() { |
|||
#if ENABLED(SDSUPPORT) |
|||
if (num_files == 0xFFFF) num_files = card.get_num_Files(); |
|||
return num_files; |
|||
#endif |
|||
} |
|||
|
|||
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 *dirname) { |
|||
#if ENABLED(SDSUPPORT) |
|||
card.chdir(dirname); |
|||
num_files = 0xFFFF; |
|||
#endif |
|||
} |
|||
|
|||
} // namespace UI
|
|||
|
|||
// At the moment, we piggy-back off the ultralcd calls, but this could be cleaned up in the future
|
|||
|
|||
void lcd_init() { |
|||
#if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT) |
|||
SET_INPUT_PULLUP(SD_DETECT_PIN); |
|||
#endif |
|||
UI::onStartup(); |
|||
} |
|||
|
|||
void lcd_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.cardOK) |
|||
UI::onMediaInserted(); |
|||
else |
|||
UI::onMediaError(); |
|||
} |
|||
else { |
|||
const bool ok = card.cardOK; |
|||
card.release(); |
|||
if (ok) |
|||
UI::onMediaRemoved(); |
|||
} |
|||
} |
|||
#endif // SDSUPPORT
|
|||
UI::onUpdate(); |
|||
} |
|||
|
|||
bool lcd_hasstatus() { return true; } |
|||
bool lcd_detected() { return true; } |
|||
void lcd_reset_alert_level() {} |
|||
void lcd_refresh() {} |
|||
void lcd_setstatus(const char * const message, const bool persist /* = false */) { UI::onStatusChanged(message); } |
|||
void lcd_setstatusPGM(const char * const message, int8_t level /* = 0 */) { UI::onStatusChanged((progmem_str)message); } |
|||
void lcd_reset_status() {} |
|||
void lcd_setalertstatusPGM(const char * const message) { lcd_setstatusPGM(message, 0); } |
|||
void lcd_status_printf_P(const uint8_t level, const char * const fmt, ...) { |
|||
char buff[64]; |
|||
va_list args; |
|||
va_start(args, fmt); |
|||
vsnprintf_P(buff, sizeof(buff), fmt, args); |
|||
va_end(args); |
|||
buff[63] = '\0'; |
|||
UI::onStatusChanged(buff); |
|||
} |
|||
|
|||
#endif // EXTENSIBLE_UI
|
|||
@ -0,0 +1,164 @@ |
|||
/************
|
|||
* 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 * |
|||
* location: <http://www.gnu.org/licenses/>. *
|
|||
****************************************************************************/ |
|||
|
|||
#pragma once |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
typedef const __FlashStringHelper *progmem_str; |
|||
|
|||
namespace UI { |
|||
|
|||
enum axis_t : uint8_t { X, Y, Z, E0, E1, E2, E3, E4, E5 }; |
|||
|
|||
constexpr uint8_t extruderCount = EXTRUDERS; |
|||
constexpr uint8_t fanCount = FAN_COUNT; |
|||
|
|||
// The following methods should be used by the extension module to
|
|||
// query or change Marlin's state.
|
|||
|
|||
progmem_str getFirmwareName(); |
|||
|
|||
bool isAxisPositionKnown(const axis_t axis); |
|||
bool isMoving(); |
|||
|
|||
float getActualTemp_celsius(const uint8_t extruder); |
|||
float getTargetTemp_celsius(const uint8_t extruder); |
|||
float getFan_percent(const uint8_t fan); |
|||
float getAxisPosition_mm(const axis_t axis); |
|||
float getAxisSteps_per_mm(const axis_t axis); |
|||
float getAxisMaxFeedrate_mm_s(const axis_t axis); |
|||
float getAxisMaxAcceleration_mm_s2(const axis_t axis); |
|||
float getMinFeedrate_mm_s(); |
|||
float getMinTravelFeedrate_mm_s(); |
|||
float getPrintingAcceleration_mm_per_s2(); |
|||
float getRetractAcceleration_mm_per_s2(); |
|||
float getTravelAcceleration_mm_per_s2(); |
|||
float getFeedRate_percent(); |
|||
uint8_t getProgress_percent(); |
|||
uint32_t getProgress_seconds_elapsed(); |
|||
|
|||
void setTargetTemp_celsius(const uint8_t extruder, float temp); |
|||
void setFan_percent(const uint8_t fan, const float percent); |
|||
void setAxisPosition_mm(const axis_t axis, float position, float _feedrate_mm_s); |
|||
void setAxisSteps_per_mm(const axis_t axis, const float steps_per_mm); |
|||
void setAxisMaxFeedrate_mm_s(const axis_t axis, const float max_feedrate_mm_s); |
|||
void setAxisMaxAcceleration_mm_s2(const axis_t axis, const float max_acceleration_mm_per_s2); |
|||
void setMinFeedrate_mm_s(const float min_feedrate_mm_s); |
|||
void setMinTravelFeedrate_mm_s(const float min_travel_feedrate_mm_s); |
|||
void setPrintingAcceleration_mm_s2(const float acceleration); |
|||
void setRetractAcceleration_mm_s2(const float retract_acceleration); |
|||
void setTravelAcceleration_mm_s2(const float travel_acceleration); |
|||
void setFeedrate_percent(const float percent); |
|||
|
|||
#if ENABLED(LIN_ADVANCE) |
|||
float getLinearAdvance_mm_mm_s(const uint8_t extruder); |
|||
void setLinearAdvance_mm_mm_s(const uint8_t extruder, const float k); |
|||
#endif |
|||
|
|||
#if ENABLED(JUNCTION_DEVIATION) |
|||
float getJunctionDeviation_mm(); |
|||
void setJunctionDeviation_mm(const float junc_dev); |
|||
#else |
|||
float getAxisMaxJerk_mm_s(const axis_t axis); |
|||
void setAxisMaxJerk_mm_s(const axis_t axis, const float max_jerk); |
|||
#endif |
|||
|
|||
void setActiveTool(uint8_t extruder, bool no_move); |
|||
uint8_t getActiveTool(); |
|||
|
|||
#if HOTENDS > 1 |
|||
float getNozzleOffset_mm(const axis_t axis, uint8_t extruder); |
|||
void setNozzleOffset_mm(const axis_t axis, uint8_t extruder, float offset); |
|||
#endif |
|||
|
|||
#if ENABLED(BABYSTEP_ZPROBE_OFFSET) |
|||
float getZOffset_mm(); |
|||
void setZOffset_mm(const float zoffset_mm); |
|||
void incrementZOffset_steps(const int16_t babystep_increment); |
|||
#endif |
|||
|
|||
#if ENABLED(BACKLASH_GCODE) |
|||
float getAxisBacklash_mm(const axis_t axis); |
|||
void setAxisBacklash_mm(const axis_t axis, float distance); |
|||
|
|||
float getBacklashCorrection_percent(); |
|||
void setBacklashCorrection_percent(float percent); |
|||
|
|||
#ifdef BACKLASH_SMOOTHING_MM |
|||
float getBacklashSmoothing_mm(); |
|||
void setBacklashSmoothing_mm(float distance); |
|||
#endif |
|||
#endif |
|||
|
|||
void delay_ms(unsigned long ms); |
|||
void yield(); // Within lengthy loop, call this periodically
|
|||
|
|||
void enqueueCommands(progmem_str gcode); |
|||
|
|||
void printFile(const char *filename); |
|||
bool isPrintingFromMedia(); |
|||
bool isPrinting(); |
|||
void stopPrint(); |
|||
void pausePrint(); |
|||
void resumePrint(); |
|||
|
|||
bool isMediaInserted(); |
|||
|
|||
class FileList { |
|||
private: |
|||
uint16_t num_files; |
|||
|
|||
public: |
|||
FileList(); |
|||
void refresh(); |
|||
bool seek(uint16_t, bool skip_range_check = false); |
|||
|
|||
const char *longFilename(); |
|||
const char *shortFilename(); |
|||
const char *filename(); |
|||
bool isDir(); |
|||
|
|||
void changeDir(const char *dirname); |
|||
void upDir(); |
|||
bool isAtRootDir(); |
|||
uint16_t count(); |
|||
}; |
|||
|
|||
// The following event handlers are to be declared by the extension
|
|||
// module and will be called by Marlin.
|
|||
|
|||
void onStartup(); |
|||
void onUpdate(); |
|||
void onMediaInserted(); |
|||
void onMediaError(); |
|||
void onMediaRemoved(); |
|||
void onPlayTone(const uint16_t frequency, const uint16_t duration); |
|||
void onPrinterKilled(const char* msg); |
|||
void onPrintTimerStarted(); |
|||
void onPrintTimerPaused(); |
|||
void onPrintTimerStopped(); |
|||
void onFilamentRunout(); |
|||
void onStatusChanged(const char* msg); |
|||
void onStatusChanged(progmem_str msg); |
|||
void onFactoryReset(); |
|||
void onStoreSettings(); |
|||
}; |
|||
Loading…
Reference in new issue